2 Provides interface to advanced shell functionality for parsing both handle and protocol database.
4 Copyright (c) 2010 - 2017, Intel Corporation. All rights reserved.<BR>
5 (C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>
6 (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>
7 This program and the accompanying materials
8 are licensed and made available under the terms and conditions of the BSD License
9 which accompanies this distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
17 #include "UefiHandleParsingLib.h"
18 #include "IndustryStandard/Acpi10.h"
20 #include <Protocol/FirmwareVolume2.h>
22 EFI_HANDLE mHandleParsingHiiHandle
= NULL
;
23 HANDLE_INDEX_LIST mHandleList
= {{{NULL
,NULL
},0,0},0};
24 GUID_INFO_BLOCK
*mGuidList
;
28 Function to find the file name associated with a LoadedImageProtocol.
30 @param[in] LoadedImage An instance of LoadedImageProtocol.
32 @retval A string representation of the file name associated
33 with LoadedImage, or NULL if no name can be found.
36 FindLoadedImageFileName (
37 IN EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
42 EFI_FIRMWARE_VOLUME2_PROTOCOL
*Fv
;
45 UINT32 AuthenticationStatus
;
47 if ((LoadedImage
== NULL
) || (LoadedImage
->FilePath
== NULL
)) {
51 NameGuid
= EfiGetNameGuidFromFwVolDevicePathNode((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
*)LoadedImage
->FilePath
);
53 if (NameGuid
== NULL
) {
58 // Get the FirmwareVolume2Protocol of the device handle that this image was loaded from.
60 Status
= gBS
->HandleProtocol (LoadedImage
->DeviceHandle
, &gEfiFirmwareVolume2ProtocolGuid
, (VOID
**) &Fv
);
63 // FirmwareVolume2Protocol is PI, and is not required to be available.
65 if (EFI_ERROR (Status
)) {
70 // Read the user interface section of the image.
73 Status
= Fv
->ReadSection(Fv
, NameGuid
, EFI_SECTION_USER_INTERFACE
, 0, &Buffer
, &BufferSize
, &AuthenticationStatus
);
75 if (EFI_ERROR (Status
)) {
80 // ReadSection returns just the section data, without any section header. For
81 // a user interface section, the only data is the file name.
87 Function to translate the EFI_MEMORY_TYPE into a string.
89 @param[in] Memory The memory type.
91 @retval A string representation of the type allocated from BS Pool.
95 IN CONST EFI_MEMORY_TYPE Memory
102 case EfiReservedMemoryType
: StrnCatGrow(&RetVal
, NULL
, L
"EfiReservedMemoryType", 0); break;
103 case EfiLoaderCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiLoaderCode", 0); break;
104 case EfiLoaderData
: StrnCatGrow(&RetVal
, NULL
, L
"EfiLoaderData", 0); break;
105 case EfiBootServicesCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiBootServicesCode", 0); break;
106 case EfiBootServicesData
: StrnCatGrow(&RetVal
, NULL
, L
"EfiBootServicesData", 0); break;
107 case EfiRuntimeServicesCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiRuntimeServicesCode", 0); break;
108 case EfiRuntimeServicesData
: StrnCatGrow(&RetVal
, NULL
, L
"EfiRuntimeServicesData", 0); break;
109 case EfiConventionalMemory
: StrnCatGrow(&RetVal
, NULL
, L
"EfiConventionalMemory", 0); break;
110 case EfiUnusableMemory
: StrnCatGrow(&RetVal
, NULL
, L
"EfiUnusableMemory", 0); break;
111 case EfiACPIReclaimMemory
: StrnCatGrow(&RetVal
, NULL
, L
"EfiACPIReclaimMemory", 0); break;
112 case EfiACPIMemoryNVS
: StrnCatGrow(&RetVal
, NULL
, L
"EfiACPIMemoryNVS", 0); break;
113 case EfiMemoryMappedIO
: StrnCatGrow(&RetVal
, NULL
, L
"EfiMemoryMappedIO", 0); break;
114 case EfiMemoryMappedIOPortSpace
: StrnCatGrow(&RetVal
, NULL
, L
"EfiMemoryMappedIOPortSpace", 0); break;
115 case EfiPalCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiPalCode", 0); break;
116 case EfiMaxMemoryType
: StrnCatGrow(&RetVal
, NULL
, L
"EfiMaxMemoryType", 0); break;
117 default: ASSERT(FALSE
);
123 Function to translate the EFI_GRAPHICS_PIXEL_FORMAT into a string.
125 @param[in] Fmt The format type.
127 @retval A string representation of the type allocated from BS Pool.
131 IN CONST EFI_GRAPHICS_PIXEL_FORMAT Fmt
138 case PixelRedGreenBlueReserved8BitPerColor
: StrnCatGrow(&RetVal
, NULL
, L
"PixelRedGreenBlueReserved8BitPerColor", 0); break;
139 case PixelBlueGreenRedReserved8BitPerColor
: StrnCatGrow(&RetVal
, NULL
, L
"PixelBlueGreenRedReserved8BitPerColor", 0); break;
140 case PixelBitMask
: StrnCatGrow(&RetVal
, NULL
, L
"PixelBitMask", 0); break;
141 case PixelBltOnly
: StrnCatGrow(&RetVal
, NULL
, L
"PixelBltOnly", 0); break;
142 case PixelFormatMax
: StrnCatGrow(&RetVal
, NULL
, L
"PixelFormatMax", 0); break;
143 default: ASSERT(FALSE
);
149 Constructor for the library.
151 @param[in] ImageHandle Ignored.
152 @param[in] SystemTable Ignored.
154 @retval EFI_SUCCESS The operation was successful.
158 HandleParsingLibConstructor (
159 IN EFI_HANDLE ImageHandle
,
160 IN EFI_SYSTEM_TABLE
*SystemTable
167 // Do nothing with mHandleParsingHiiHandle. Initialize HII as needed.
169 return (EFI_SUCCESS
);
173 Initialization function for HII packages.
177 HandleParsingHiiInit (VOID
)
179 if (mHandleParsingHiiHandle
== NULL
) {
180 mHandleParsingHiiHandle
= HiiAddPackages (&gHandleParsingHiiGuid
, gImageHandle
, UefiHandleParsingLibStrings
, NULL
);
181 ASSERT (mHandleParsingHiiHandle
!= NULL
);
186 Destructor for the library. free any resources.
188 @param[in] ImageHandle Ignored.
189 @param[in] SystemTable Ignored.
191 @retval EFI_SUCCESS The operation was successful.
195 HandleParsingLibDestructor (
196 IN EFI_HANDLE ImageHandle
,
197 IN EFI_SYSTEM_TABLE
*SystemTable
202 for (LoopCount
= 0; mGuidList
!= NULL
&& LoopCount
< mGuidListCount
; LoopCount
++) {
203 SHELL_FREE_NON_NULL(mGuidList
[LoopCount
].GuidId
);
206 SHELL_FREE_NON_NULL(mGuidList
);
207 if (mHandleParsingHiiHandle
!= NULL
) {
208 HiiRemovePackages(mHandleParsingHiiHandle
);
210 return (EFI_SUCCESS
);
214 Function to dump information about LoadedImage.
216 This will allocate the return buffer from boot services pool.
218 @param[in] TheHandle The handle that has LoadedImage installed.
219 @param[in] Verbose TRUE for additional information, FALSE otherwise.
221 @retval A poitner to a string containing the information.
225 LoadedImageProtocolDumpInformation(
226 IN CONST EFI_HANDLE TheHandle
,
227 IN CONST BOOLEAN Verbose
230 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
240 Status
= gBS
->OpenProtocol (
242 &gEfiLoadedImageProtocolGuid
,
243 (VOID
**)&LoadedImage
,
246 EFI_OPEN_PROTOCOL_GET_PROTOCOL
249 if (EFI_ERROR (Status
)) {
253 FileName
= FindLoadedImageFileName(LoadedImage
);
254 FilePath
= ConvertDevicePathToText(LoadedImage
->FilePath
, TRUE
, TRUE
);
256 if (FileName
== NULL
) {
259 SHELL_FREE_NON_NULL(FilePath
);
261 RetVal
= CatSPrint(NULL
, FileName
);
262 SHELL_FREE_NON_NULL(FileName
);
266 HandleParsingHiiInit();
268 if (FileName
!= NULL
) {
269 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_LI_DUMP_NAME
), NULL
);
272 RetVal
= CatSPrint(NULL
, Temp
, FileName
);
275 SHELL_FREE_NON_NULL(Temp
);
276 SHELL_FREE_NON_NULL(FileName
);
279 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_LI_DUMP_MAIN
), NULL
);
283 PdbFileName
= PeCoffLoaderGetPdbPointer (LoadedImage
->ImageBase
);
284 DataType
= ConvertMemoryType(LoadedImage
->ImageDataType
);
285 CodeType
= ConvertMemoryType(LoadedImage
->ImageCodeType
);
290 LoadedImage
->Revision
,
291 LoadedImage
->ParentHandle
,
292 LoadedImage
->SystemTable
,
293 LoadedImage
->DeviceHandle
,
296 LoadedImage
->LoadOptionsSize
,
297 LoadedImage
->LoadOptions
,
298 LoadedImage
->ImageBase
,
299 LoadedImage
->ImageSize
,
306 SHELL_FREE_NON_NULL(Temp
);
307 SHELL_FREE_NON_NULL(FilePath
);
308 SHELL_FREE_NON_NULL(CodeType
);
309 SHELL_FREE_NON_NULL(DataType
);
315 Function to dump information about GOP.
317 This will allocate the return buffer from boot services pool.
319 @param[in] TheHandle The handle that has LoadedImage installed.
320 @param[in] Verbose TRUE for additional information, FALSE otherwise.
322 @retval A poitner to a string containing the information.
326 GraphicsOutputProtocolDumpInformation(
327 IN CONST EFI_HANDLE TheHandle
,
328 IN CONST BOOLEAN Verbose
331 EFI_GRAPHICS_OUTPUT_PROTOCOL
*GraphicsOutput
;
339 EFI_GRAPHICS_OUTPUT_MODE_INFORMATION
*GopInfo
;
342 return (CatSPrint(NULL
, L
"GraphicsOutput"));
345 HandleParsingHiiInit();
347 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_GOP_DUMP_MAIN
), NULL
);
352 Status
= gBS
->OpenProtocol (
354 &gEfiGraphicsOutputProtocolGuid
,
355 (VOID
**)&GraphicsOutput
,
358 EFI_OPEN_PROTOCOL_GET_PROTOCOL
361 if (EFI_ERROR (Status
)) {
362 SHELL_FREE_NON_NULL (Temp
);
366 Fmt
= ConvertPixelFormat(GraphicsOutput
->Mode
->Info
->PixelFormat
);
371 GraphicsOutput
->Mode
->MaxMode
,
372 GraphicsOutput
->Mode
->Mode
,
373 GraphicsOutput
->Mode
->FrameBufferBase
,
374 (UINT64
)GraphicsOutput
->Mode
->FrameBufferSize
,
375 (UINT64
)GraphicsOutput
->Mode
->SizeOfInfo
,
376 GraphicsOutput
->Mode
->Info
->Version
,
377 GraphicsOutput
->Mode
->Info
->HorizontalResolution
,
378 GraphicsOutput
->Mode
->Info
->VerticalResolution
,
380 GraphicsOutput
->Mode
->Info
->PixelsPerScanLine
,
381 GraphicsOutput
->Mode
->Info
->PixelFormat
!=PixelBitMask
?0:GraphicsOutput
->Mode
->Info
->PixelInformation
.RedMask
,
382 GraphicsOutput
->Mode
->Info
->PixelFormat
!=PixelBitMask
?0:GraphicsOutput
->Mode
->Info
->PixelInformation
.GreenMask
,
383 GraphicsOutput
->Mode
->Info
->PixelFormat
!=PixelBitMask
?0:GraphicsOutput
->Mode
->Info
->PixelInformation
.BlueMask
386 SHELL_FREE_NON_NULL (Temp
);
388 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_GOP_RES_LIST_MAIN
), NULL
);
390 SHELL_FREE_NON_NULL (RetVal
);
394 TempRetVal
= CatSPrint (RetVal
, Temp
);
395 SHELL_FREE_NON_NULL (RetVal
);
396 if (TempRetVal
== NULL
) {
400 SHELL_FREE_NON_NULL (Temp
);
402 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_GOP_RES_LIST_ENTRY
), NULL
);
404 SHELL_FREE_NON_NULL (RetVal
);
409 for (Mode
= 0; Mode
< GraphicsOutput
->Mode
->MaxMode
; Mode
++) {
410 Status
= GraphicsOutput
->QueryMode (
416 if (EFI_ERROR (Status
)) {
420 TempRetVal
= CatSPrint (
424 GopInfo
->HorizontalResolution
,
425 GopInfo
->VerticalResolution
428 SHELL_FREE_NON_NULL (GopInfo
);
429 SHELL_FREE_NON_NULL (RetVal
);
435 SHELL_FREE_NON_NULL(Temp
);
436 SHELL_FREE_NON_NULL(Fmt
);
442 Function to dump information about EDID Discovered Protocol.
444 This will allocate the return buffer from boot services pool.
446 @param[in] TheHandle The handle that has LoadedImage installed.
447 @param[in] Verbose TRUE for additional information, FALSE otherwise.
449 @retval A pointer to a string containing the information.
453 EdidDiscoveredProtocolDumpInformation (
454 IN CONST EFI_HANDLE TheHandle
,
455 IN CONST BOOLEAN Verbose
458 EFI_EDID_DISCOVERED_PROTOCOL
*EdidDiscovered
;
465 return (CatSPrint (NULL
, L
"EDIDDiscovered"));
468 Status
= gBS
->OpenProtocol (
470 &gEfiEdidDiscoveredProtocolGuid
,
471 (VOID
**)&EdidDiscovered
,
474 EFI_OPEN_PROTOCOL_GET_PROTOCOL
477 if (EFI_ERROR (Status
)) {
481 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_DISCOVERED_MAIN
), NULL
);
486 RetVal
= CatSPrint (NULL
, Temp
, EdidDiscovered
->SizeOfEdid
);
487 SHELL_FREE_NON_NULL (Temp
);
489 if (EdidDiscovered
->SizeOfEdid
!= 0) {
490 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_DISCOVERED_DATA
), NULL
);
492 SHELL_FREE_NON_NULL (RetVal
);
495 TempRetVal
= CatSPrint (RetVal
, Temp
);
496 SHELL_FREE_NON_NULL (RetVal
);
499 TempRetVal
= CatSDumpHex (RetVal
, 7, 0, EdidDiscovered
->SizeOfEdid
, EdidDiscovered
->Edid
);
506 Function to dump information about EDID Active Protocol.
508 This will allocate the return buffer from boot services pool.
510 @param[in] TheHandle The handle that has LoadedImage installed.
511 @param[in] Verbose TRUE for additional information, FALSE otherwise.
513 @retval A pointer to a string containing the information.
517 EdidActiveProtocolDumpInformation (
518 IN CONST EFI_HANDLE TheHandle
,
519 IN CONST BOOLEAN Verbose
522 EFI_EDID_ACTIVE_PROTOCOL
*EdidActive
;
529 return (CatSPrint (NULL
, L
"EDIDActive"));
532 Status
= gBS
->OpenProtocol (
534 &gEfiEdidActiveProtocolGuid
,
538 EFI_OPEN_PROTOCOL_GET_PROTOCOL
541 if (EFI_ERROR (Status
)) {
545 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_ACTIVE_MAIN
), NULL
);
550 RetVal
= CatSPrint (NULL
, Temp
, EdidActive
->SizeOfEdid
);
551 SHELL_FREE_NON_NULL (Temp
);
553 if (EdidActive
->SizeOfEdid
!= 0) {
554 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_ACTIVE_DATA
), NULL
);
556 SHELL_FREE_NON_NULL (RetVal
);
559 TempRetVal
= CatSPrint (RetVal
, Temp
);
560 SHELL_FREE_NON_NULL (RetVal
);
563 TempRetVal
= CatSDumpHex (RetVal
, 7, 0, EdidActive
->SizeOfEdid
, EdidActive
->Edid
);
570 Function to dump information about PciRootBridgeIo.
572 This will allocate the return buffer from boot services pool.
574 @param[in] TheHandle The handle that has PciRootBridgeIo installed.
575 @param[in] Verbose TRUE for additional information, FALSE otherwise.
577 @retval A poitner to a string containing the information.
581 PciRootBridgeIoDumpInformation(
582 IN CONST EFI_HANDLE TheHandle
,
583 IN CONST BOOLEAN Verbose
586 EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL
*PciRootBridgeIo
;
587 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR
*Configuration
;
598 return (CatSPrint(NULL
, L
"PciRootBridgeIo"));
601 HandleParsingHiiInit();
603 Status
= gBS
->HandleProtocol(
605 &gEfiPciRootBridgeIoProtocolGuid
,
606 (VOID
**)&PciRootBridgeIo
);
608 if (EFI_ERROR(Status
)) {
612 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_PH
), NULL
);
616 Temp2
= CatSPrint(L
"\r\n", Temp
, PciRootBridgeIo
->ParentHandle
);
621 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_SEG
), NULL
);
623 SHELL_FREE_NON_NULL(RetVal
);
626 Temp2
= CatSPrint(RetVal
, Temp
, PciRootBridgeIo
->SegmentNumber
);
634 Status
= PciRootBridgeIo
->GetAttributes (PciRootBridgeIo
, &Supports
, &Attributes
);
635 if (!EFI_ERROR(Status
)) {
636 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_ATT
), NULL
);
638 SHELL_FREE_NON_NULL(RetVal
);
641 Temp2
= CatSPrint(RetVal
, Temp
, Attributes
);
647 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_SUPPORTS
), NULL
);
649 SHELL_FREE_NON_NULL(RetVal
);
652 Temp2
= CatSPrint(RetVal
, Temp
, Supports
);
659 Configuration
= NULL
;
660 Status
= PciRootBridgeIo
->Configuration (PciRootBridgeIo
, (VOID
**) &Configuration
);
661 if (!EFI_ERROR(Status
) && Configuration
!= NULL
) {
662 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_TITLE
), NULL
);
664 SHELL_FREE_NON_NULL(RetVal
);
667 Temp2
= CatSPrint(RetVal
, Temp
, Supports
);
672 while (Configuration
->Desc
== ACPI_ADDRESS_SPACE_DESCRIPTOR
) {
674 switch (Configuration
->ResType
) {
675 case ACPI_ADDRESS_SPACE_TYPE_MEM
:
676 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_MEM
), NULL
);
678 case ACPI_ADDRESS_SPACE_TYPE_IO
:
679 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_IO
), NULL
);
681 case ACPI_ADDRESS_SPACE_TYPE_BUS
:
682 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_BUS
), NULL
);
686 Temp2
= CatSPrint(RetVal
, L
"%s", Temp
);
693 Temp2
= CatSPrint(RetVal
,
694 L
"%H%02x %016lx %016lx %02x%N\r\n",
695 Configuration
->SpecificFlag
,
696 Configuration
->AddrRangeMin
,
697 Configuration
->AddrRangeMax
,
698 Configuration
->AddrSpaceGranularity
710 Function to dump information about SimpleTextOut.
712 This will allocate the return buffer from boot services pool.
714 @param[in] TheHandle The handle that has SimpleTextOut installed.
715 @param[in] Verbose TRUE for additional information, FALSE otherwise.
717 @retval A poitner to a string containing the information.
721 TxtOutProtocolDumpInformation(
722 IN CONST EFI_HANDLE TheHandle
,
723 IN CONST BOOLEAN Verbose
726 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL
*Dev
;
740 HandleParsingHiiInit();
745 Status
= gBS
->HandleProtocol(
747 &gEfiSimpleTextOutProtocolGuid
,
750 ASSERT_EFI_ERROR(Status
);
751 ASSERT (Dev
!= NULL
&& Dev
->Mode
!= NULL
);
753 Size
= (Dev
->Mode
->MaxMode
+ 1) * 80;
754 RetVal
= AllocateZeroPool(Size
);
756 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_TXT_OUT_DUMP_HEADER
), NULL
);
758 UnicodeSPrint(RetVal
, Size
, Temp
, Dev
, Dev
->Mode
->Attribute
);
765 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_TXT_OUT_DUMP_LINE
), NULL
);
766 for (Index
= 0; Index
< Dev
->Mode
->MaxMode
; Index
++) {
767 Status
= Dev
->QueryMode (Dev
, Index
, &Col
, &Row
);
768 NewSize
= Size
- StrSize(RetVal
);
770 RetVal
+ StrLen(RetVal
),
772 Temp
== NULL
?L
"":Temp
,
773 Index
== Dev
->Mode
->Mode
? L
'*' : L
' ',
775 !EFI_ERROR(Status
)?(INTN
)Col
:-1,
776 !EFI_ERROR(Status
)?(INTN
)Row
:-1
783 STATIC CONST UINTN VersionStringSize
= 60;
786 Function to dump information about EfiDriverSupportedEfiVersion protocol.
788 This will allocate the return buffer from boot services pool.
790 @param[in] TheHandle The handle that has the protocol installed.
791 @param[in] Verbose TRUE for additional information, FALSE otherwise.
793 @retval A poitner to a string containing the information.
797 DriverEfiVersionProtocolDumpInformation(
798 IN CONST EFI_HANDLE TheHandle
,
799 IN CONST BOOLEAN Verbose
802 EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL
*DriverEfiVersion
;
806 Status
= gBS
->HandleProtocol(
808 &gEfiDriverSupportedEfiVersionProtocolGuid
,
809 (VOID
**)&DriverEfiVersion
);
811 ASSERT_EFI_ERROR(Status
);
813 RetVal
= AllocateZeroPool(VersionStringSize
);
814 if (RetVal
!= NULL
) {
815 UnicodeSPrint (RetVal
, VersionStringSize
, L
"0x%08x", DriverEfiVersion
->FirmwareVersion
);
820 Function to convert device path to string.
822 This will allocate the return buffer from boot services pool.
824 @param[in] DevPath Pointer to device path instance.
825 @param[in] Verbose TRUE for additional information, FALSE otherwise.
826 @param[in] Length Maximum allowed text length of the device path.
828 @retval A pointer to a string containing the information.
831 ConvertDevicePathToShortText(
832 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevPath
,
833 IN CONST BOOLEAN Verbose
,
834 IN CONST UINTN Length
842 // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)
844 Temp
= ConvertDevicePathToText(DevPath
, TRUE
, TRUE
);
845 if (!Verbose
&& Temp
!= NULL
&& StrLen(Temp
) > Length
) {
848 Temp2
= StrnCatGrow(&Temp2
, &Size
, L
"..", 0);
849 Temp2
= StrnCatGrow(&Temp2
, &Size
, Temp
+(StrLen(Temp
) - (Length
- 2)), 0);
857 Function to dump protocol information.
859 This will allocate the return buffer from boot services pool.
861 @param[in] TheHandle The handle that has the protocol installed.
862 @param[in] Verbose TRUE for additional information, FALSE otherwise.
863 @param[in] Protocol The protocol is needed to dump.
865 @retval A pointer to a string containing the information.
869 DevicePathProtocolDumpInformationEx (
870 IN CONST EFI_HANDLE TheHandle
,
871 IN CONST BOOLEAN Verbose
,
872 IN EFI_GUID
*Protocol
875 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
877 CHAR16
*DevPathStrTemp
;
881 DevPathStrTemp
= NULL
;
882 Status
= gBS
->OpenProtocol(TheHandle
, Protocol
, (VOID
**)&DevPath
, gImageHandle
, NULL
, EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
883 if (!EFI_ERROR(Status
)) {
884 DevPathStr
= ConvertDevicePathToShortText (DevPath
, Verbose
, 30);
886 Size
= StrSize(DevPathStr
) + sizeof(CHAR16
) * 2;
887 DevPathStrTemp
= AllocateZeroPool (Size
);
888 if (DevPathStrTemp
!= NULL
) {
889 StrnCatS (DevPathStrTemp
, Size
/sizeof(CHAR16
), L
" ", 2);
890 StrnCatS (DevPathStrTemp
, Size
/sizeof(CHAR16
), DevPathStr
, StrLen (DevPathStr
));
892 FreePool (DevPathStr
);
893 DevPathStr
= DevPathStrTemp
;
895 gBS
->CloseProtocol(TheHandle
, Protocol
, gImageHandle
, NULL
);
901 Function to dump information about DevicePath protocol.
903 This will allocate the return buffer from boot services pool.
905 @param[in] TheHandle The handle that has the protocol installed.
906 @param[in] Verbose TRUE for additional information, FALSE otherwise.
908 @retval A pointer to a string containing the information.
912 DevicePathProtocolDumpInformation(
913 IN CONST EFI_HANDLE TheHandle
,
914 IN CONST BOOLEAN Verbose
917 return DevicePathProtocolDumpInformationEx (TheHandle
, Verbose
, &gEfiDevicePathProtocolGuid
);
921 Function to dump information about LoadedImageDevicePath protocol.
923 This will allocate the return buffer from boot services pool.
925 @param[in] TheHandle The handle that has the protocol installed.
926 @param[in] Verbose TRUE for additional information, FALSE otherwise.
928 @retval A pointer to a string containing the information.
932 LoadedImageDevicePathProtocolDumpInformation(
933 IN CONST EFI_HANDLE TheHandle
,
934 IN CONST BOOLEAN Verbose
937 return DevicePathProtocolDumpInformationEx (TheHandle
, Verbose
, &gEfiLoadedImageDevicePathProtocolGuid
);
941 Function to dump information about BusSpecificDriverOverride protocol.
943 This will allocate the return buffer from boot services pool.
945 @param[in] TheHandle The handle that has the protocol installed.
946 @param[in] Verbose TRUE for additional information, FALSE otherwise.
948 @retval A pointer to a string containing the information.
952 BusSpecificDriverOverrideProtocolDumpInformation (
953 IN CONST EFI_HANDLE TheHandle
,
954 IN CONST BOOLEAN Verbose
961 EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL
*BusSpecificDriverOverride
;
962 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
963 EFI_HANDLE ImageHandle
;
975 Status
= gBS
->OpenProtocol (
977 &gEfiBusSpecificDriverOverrideProtocolGuid
,
978 (VOID
**)&BusSpecificDriverOverride
,
981 EFI_OPEN_PROTOCOL_GET_PROTOCOL
983 if (EFI_ERROR (Status
)) {
986 HandleParsingHiiInit ();
987 GetString
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_BSDO_DUMP_MAIN
), NULL
);
988 if (GetString
== NULL
) {
992 Status
= BusSpecificDriverOverride
->GetDriver (
993 BusSpecificDriverOverride
,
996 if (!EFI_ERROR (Status
)) {
997 Status
= gBS
->HandleProtocol (
999 &gEfiLoadedImageProtocolGuid
,
1000 (VOID
**) &LoadedImage
1002 if(!EFI_ERROR (Status
)) {
1003 TempRetVal
= CatSPrint (
1006 ConvertHandleToHandleIndex (ImageHandle
),
1007 ConvertDevicePathToText (LoadedImage
->FilePath
, TRUE
, TRUE
)
1009 StrnCatGrow (&RetVal
, &Size
, TempRetVal
, 0);
1010 SHELL_FREE_NON_NULL (TempRetVal
);
1013 } while (!EFI_ERROR (Status
));
1015 SHELL_FREE_NON_NULL (GetString
);
1020 Function to dump information about BlockIo protocol.
1022 This will allocate the return buffer from boot services pool.
1024 @param[in] TheHandle The handle that has the protocol installed.
1025 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1027 @retval A pointer to a string containing the information.
1031 BlockIoProtocolDumpInformation (
1032 IN CONST EFI_HANDLE TheHandle
,
1033 IN CONST BOOLEAN Verbose
1037 EFI_BLOCK_IO_PROTOCOL
*BlockIo
;
1038 EFI_BLOCK_IO_MEDIA
*BlockMedia
;
1048 Status
= gBS
->OpenProtocol (
1050 &gEfiBlockIoProtocolGuid
,
1054 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1056 if (EFI_ERROR (Status
)) {
1059 BlockMedia
= BlockIo
->Media
;
1062 // The function (ReadBlocks) must return EFI_NO_MEDIA or
1063 // EFI_MEDIA_CHANGED even if LBA, BufferSize, or Buffer are invalid so the caller can probe
1064 // for changes in media state.
1066 BlockIo
->ReadBlocks (
1068 BlockIo
->Media
->MediaId
,
1074 HandleParsingHiiInit ();
1075 GetString
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_BLOCKIO_INFO
), NULL
);
1076 if (GetString
== NULL
) {
1079 RetVal
= CatSPrint (
1082 BlockMedia
->RemovableMedia
? L
"Removable " : L
"Fixed ",
1083 BlockMedia
->MediaPresent
? L
"" : L
"not-present ",
1084 BlockMedia
->MediaId
,
1085 BlockMedia
->BlockSize
,
1086 BlockMedia
->LastBlock
,
1087 MultU64x32 (BlockMedia
->LastBlock
+ 1, BlockMedia
->BlockSize
),
1088 BlockMedia
->LogicalPartition
? L
"partition" : L
"raw",
1089 BlockMedia
->ReadOnly
? L
"ro" : L
"rw",
1090 BlockMedia
->WriteCaching
? L
"cached" : L
"!cached"
1093 SHELL_FREE_NON_NULL (GetString
);
1098 Function to dump information about DebugSupport Protocol.
1100 @param[in] TheHandle The handle that has the protocol installed.
1101 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1103 @retval A pointer to a string containing the information.
1107 DebugSupportProtocolDumpInformation (
1108 IN CONST EFI_HANDLE TheHandle
,
1109 IN CONST BOOLEAN Verbose
1113 EFI_DEBUG_SUPPORT_PROTOCOL
*DebugSupport
;
1122 Status
= gBS
->OpenProtocol (
1124 &gEfiDebugSupportProtocolGuid
,
1125 (VOID
**)&DebugSupport
,
1128 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1130 if (EFI_ERROR (Status
)) {
1133 HandleParsingHiiInit ();
1134 GetString
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_DEBUGSUPPORT_INFO
), NULL
);
1135 if (GetString
== NULL
) {
1139 // Dump Debug support info
1141 switch (DebugSupport
->Isa
) {
1143 RetVal
= CatSPrint (RetVal
, GetString
, L
"IA-32");
1146 RetVal
= CatSPrint (RetVal
, GetString
, L
"IPF");
1149 RetVal
= CatSPrint (RetVal
, GetString
, L
"EBC");
1152 SHELL_FREE_NON_NULL (GetString
);
1153 GetString
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_DEBUGSUPPORT_UNKNOWN
), NULL
);
1154 RetVal
= GetString
!= NULL
? CatSPrint (RetVal
, GetString
, DebugSupport
->Isa
) : NULL
;
1158 SHELL_FREE_NON_NULL (GetString
);
1163 Function to dump information about EfiAdapterInformation Protocol.
1165 @param[in] TheHandle The handle that has the protocol installed.
1166 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1168 @retval A pointer to a string containing the information.
1172 AdapterInformationDumpInformation (
1173 IN CONST EFI_HANDLE TheHandle
,
1174 IN CONST BOOLEAN Verbose
1178 EFI_ADAPTER_INFORMATION_PROTOCOL
*EfiAdptrInfoProtocol
;
1179 UINTN InfoTypesBufferCount
;
1181 EFI_GUID
*InfoTypesBuffer
;
1186 VOID
*InformationBlock
;
1187 UINTN InformationBlockSize
;
1190 return (CatSPrint(NULL
, L
"AdapterInfo"));
1193 InfoTypesBuffer
= NULL
;
1194 InformationBlock
= NULL
;
1197 Status
= gBS
->OpenProtocol (
1198 (EFI_HANDLE
) (TheHandle
),
1199 &gEfiAdapterInformationProtocolGuid
,
1200 (VOID
**) &EfiAdptrInfoProtocol
,
1203 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1206 if (EFI_ERROR (Status
)) {
1211 // Get a list of supported information types for this instance of the protocol.
1213 Status
= EfiAdptrInfoProtocol
->GetSupportedTypes (
1214 EfiAdptrInfoProtocol
,
1216 &InfoTypesBufferCount
1219 if (EFI_ERROR (Status
)) {
1220 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GET_SUPP_TYPES_FAILED
), NULL
);
1221 if (TempStr
!= NULL
) {
1222 RetVal
= CatSPrint (NULL
, TempStr
, Status
);
1227 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_SUPP_TYPE_HEADER
), NULL
);
1228 if (TempStr
== NULL
) {
1231 RetVal
= CatSPrint (NULL
, TempStr
);
1232 SHELL_FREE_NON_NULL (TempStr
);
1234 for (GuidIndex
= 0; GuidIndex
< InfoTypesBufferCount
; GuidIndex
++) {
1235 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GUID_NUMBER
), NULL
);
1236 if (TempStr
== NULL
) {
1239 TempRetVal
= CatSPrint (RetVal
, TempStr
, (GuidIndex
+ 1), &InfoTypesBuffer
[GuidIndex
]);
1240 SHELL_FREE_NON_NULL (RetVal
);
1241 RetVal
= TempRetVal
;
1242 SHELL_FREE_NON_NULL (TempStr
);
1244 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GUID_STRING
), NULL
);
1245 if (TempStr
== NULL
) {
1249 if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoMediaStateGuid
)) {
1250 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoMediaStateGuid");
1251 SHELL_FREE_NON_NULL (RetVal
);
1252 RetVal
= TempRetVal
;
1253 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoNetworkBootGuid
)) {
1254 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoNetworkBootGuid");
1255 SHELL_FREE_NON_NULL (RetVal
);
1256 RetVal
= TempRetVal
;
1257 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoSanMacAddressGuid
)) {
1258 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoSanMacAddressGuid");
1259 SHELL_FREE_NON_NULL (RetVal
);
1260 RetVal
= TempRetVal
;
1261 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoUndiIpv6SupportGuid
)) {
1262 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoUndiIpv6SupportGuid");
1263 SHELL_FREE_NON_NULL (RetVal
);
1264 RetVal
= TempRetVal
;
1267 GuidStr
= GetStringNameFromGuid (&InfoTypesBuffer
[GuidIndex
], NULL
);
1268 if (GuidStr
== NULL
) {
1269 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"UnknownInfoType");
1270 SHELL_FREE_NON_NULL (RetVal
);
1271 RetVal
= TempRetVal
;
1273 SHELL_FREE_NON_NULL (TempStr
);
1274 SHELL_FREE_NON_NULL(GuidStr
);
1276 // So that we never have to pass this UnknownInfoType to the parsing function "GetInformation" service of AIP
1280 TempRetVal
= CatSPrint (RetVal
, TempStr
, GuidStr
);
1281 SHELL_FREE_NON_NULL (RetVal
);
1282 RetVal
= TempRetVal
;
1283 SHELL_FREE_NON_NULL(GuidStr
);
1287 SHELL_FREE_NON_NULL (TempStr
);
1289 Status
= EfiAdptrInfoProtocol
->GetInformation (
1290 EfiAdptrInfoProtocol
,
1291 &InfoTypesBuffer
[GuidIndex
],
1293 &InformationBlockSize
1296 if (EFI_ERROR (Status
)) {
1297 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GETINFO_FAILED
), NULL
);
1298 if (TempStr
== NULL
) {
1301 TempRetVal
= CatSPrint (RetVal
, TempStr
, Status
);
1302 SHELL_FREE_NON_NULL (RetVal
);
1303 RetVal
= TempRetVal
;
1305 if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoMediaStateGuid
)) {
1306 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_MEDIA_STATE
), NULL
);
1307 if (TempStr
== NULL
) {
1310 TempRetVal
= CatSPrint (
1313 ((EFI_ADAPTER_INFO_MEDIA_STATE
*)InformationBlock
)->MediaState
,
1314 ((EFI_ADAPTER_INFO_MEDIA_STATE
*)InformationBlock
)->MediaState
1316 SHELL_FREE_NON_NULL (RetVal
);
1317 RetVal
= TempRetVal
;
1318 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoNetworkBootGuid
)) {
1319 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_NETWORK_BOOT_INFO
), NULL
);
1320 if (TempStr
== NULL
) {
1323 TempRetVal
= CatSPrint (
1326 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv4BootCapablity
,
1327 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv6BootCapablity
,
1328 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->FCoeBootCapablity
,
1329 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->OffloadCapability
,
1330 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiMpioCapability
,
1331 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv4Boot
,
1332 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv6Boot
,
1333 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->FCoeBoot
1335 SHELL_FREE_NON_NULL (RetVal
);
1336 RetVal
= TempRetVal
;
1337 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoSanMacAddressGuid
) == TRUE
) {
1338 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_SAN_MAC_ADDRESS_INFO
), NULL
);
1339 if (TempStr
== NULL
) {
1342 TempRetVal
= CatSPrint (
1345 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[0],
1346 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[1],
1347 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[2],
1348 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[3],
1349 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[4],
1350 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[5]
1352 SHELL_FREE_NON_NULL (RetVal
);
1353 RetVal
= TempRetVal
;
1354 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoUndiIpv6SupportGuid
) == TRUE
) {
1355 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_UNDI_IPV6_INFO
), NULL
);
1356 if (TempStr
== NULL
) {
1360 TempRetVal
= CatSPrint (
1363 ((EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT
*)InformationBlock
)->Ipv6Support
1365 SHELL_FREE_NON_NULL (RetVal
);
1366 RetVal
= TempRetVal
;
1368 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_UNKNOWN_INFO_TYPE
), NULL
);
1369 if (TempStr
== NULL
) {
1372 TempRetVal
= CatSPrint (RetVal
, TempStr
, &InfoTypesBuffer
[GuidIndex
]);
1373 SHELL_FREE_NON_NULL (RetVal
);
1374 RetVal
= TempRetVal
;
1377 SHELL_FREE_NON_NULL (TempStr
);
1378 SHELL_FREE_NON_NULL (InformationBlock
);
1382 SHELL_FREE_NON_NULL (InfoTypesBuffer
);
1386 SHELL_FREE_NON_NULL (RetVal
);
1387 SHELL_FREE_NON_NULL (InfoTypesBuffer
);
1388 SHELL_FREE_NON_NULL (InformationBlock
);
1393 Function to dump information about EFI_FIRMWARE_MANAGEMENT_PROTOCOL Protocol.
1395 @param[in] TheHandle The handle that has the protocol installed.
1396 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1398 @retval A pointer to a string containing the information.
1402 FirmwareManagementDumpInformation (
1403 IN CONST EFI_HANDLE TheHandle
,
1404 IN CONST BOOLEAN Verbose
1408 EFI_FIRMWARE_MANAGEMENT_PROTOCOL
*EfiFwMgmtProtocol
;
1409 EFI_FIRMWARE_IMAGE_DESCRIPTOR
*ImageInfo
;
1410 EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1
*ImageInfoV1
;
1411 EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2
*ImageInfoV2
;
1412 UINT64 AttributeSetting
;
1413 UINTN ImageInfoSize
;
1414 UINTN DescriptorSize
;
1415 UINT32 DescriptorVersion
;
1416 UINT32 PackageVersion
;
1417 UINT8 DescriptorCount
;
1421 CHAR16
*PackageVersionName
;
1425 CHAR16
*AttributeSettingStr
;
1427 BOOLEAN AttributeSupported
;
1430 // Initialize local variables
1434 AttributeSetting
= 0;
1436 AttributeSupported
= FALSE
;
1440 PackageVersionName
= NULL
;
1444 AttributeSettingStr
= NULL
;
1447 return (CatSPrint(NULL
, L
"FirmwareManagement"));
1450 Status
= gBS
->OpenProtocol (
1451 (EFI_HANDLE
) (TheHandle
),
1452 &gEfiFirmwareManagementProtocolGuid
,
1453 (VOID
**) &EfiFwMgmtProtocol
,
1456 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1459 if (EFI_ERROR (Status
)) {
1463 Status
= EfiFwMgmtProtocol
->GetImageInfo (
1474 if (Status
== EFI_BUFFER_TOO_SMALL
) {
1475 ImageInfo
= AllocateZeroPool (ImageInfoSize
);
1477 if (ImageInfo
== NULL
) {
1478 Status
= EFI_OUT_OF_RESOURCES
;
1480 Status
= EfiFwMgmtProtocol
->GetImageInfo (
1493 if (EFI_ERROR (Status
)) {
1498 // Decode Image Descriptor data only if its version is supported
1500 if (DescriptorVersion
<= EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION
) {
1502 if (ImageInfo
== NULL
) {
1506 ImageInfoV1
= (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1
*)ImageInfo
;
1507 ImageInfoV2
= (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2
*)ImageInfo
;
1510 // Set ImageInfoSize in return buffer
1512 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_INFO_SIZE
), NULL
);
1513 if (TempStr
== NULL
) {
1516 RetVal
= CatSPrint (NULL
, TempStr
, ImageInfoSize
);
1517 SHELL_FREE_NON_NULL (TempStr
);
1520 // Set DescriptorVersion in return buffer
1522 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_DESCRIPTOR_VERSION
), NULL
);
1523 if (TempStr
== NULL
) {
1526 TempRetVal
= CatSPrint (RetVal
, TempStr
, DescriptorVersion
);
1527 SHELL_FREE_NON_NULL (RetVal
);
1528 RetVal
= TempRetVal
;
1529 SHELL_FREE_NON_NULL (TempStr
);
1532 // Set DescriptorCount in return buffer
1534 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_DESCRIPTOR_COUNT
), NULL
);
1535 if (TempStr
== NULL
) {
1538 TempRetVal
= CatSPrint (RetVal
, TempStr
, DescriptorCount
);
1539 SHELL_FREE_NON_NULL (RetVal
);
1540 RetVal
= TempRetVal
;
1541 SHELL_FREE_NON_NULL (TempStr
);
1545 // Set DescriptorSize in return buffer
1547 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_DESCRIPTOR_SIZE
), NULL
);
1548 if (TempStr
== NULL
) {
1551 TempRetVal
= CatSPrint (RetVal
, TempStr
, DescriptorSize
);
1552 SHELL_FREE_NON_NULL (RetVal
);
1553 RetVal
= TempRetVal
;
1554 SHELL_FREE_NON_NULL (TempStr
);
1557 // Set PackageVersion in return buffer
1559 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_PACKAGE_VERSION
), NULL
);
1560 if (TempStr
== NULL
) {
1563 TempRetVal
= CatSPrint (RetVal
, TempStr
, PackageVersion
);
1564 SHELL_FREE_NON_NULL (RetVal
);
1565 RetVal
= TempRetVal
;
1566 SHELL_FREE_NON_NULL (TempStr
);
1569 // Set PackageVersionName in return buffer
1571 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_PACKAGE_VERSION_NAME
), NULL
);
1572 if (TempStr
== NULL
) {
1575 TempRetVal
= CatSPrint (RetVal
, TempStr
, PackageVersionName
);
1576 SHELL_FREE_NON_NULL (RetVal
);
1577 RetVal
= TempRetVal
;
1578 SHELL_FREE_NON_NULL (TempStr
);
1580 for (Index
= 0; Index
< DescriptorCount
; Index
++) {
1582 // First check if Attribute is supported
1583 // and generate a string for AttributeSetting field
1585 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1586 AttributeSupported
= FALSE
;
1587 AttributeSetting
= 0;
1588 if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1
) {
1589 if (ImageInfoV1
[Index
].AttributesSupported
!= 0x0) {
1590 AttributeSupported
= TRUE
;
1591 AttributeSetting
= ImageInfoV1
[Index
].AttributesSetting
;
1593 } else if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2
) {
1594 if (ImageInfoV2
[Index
].AttributesSupported
!= 0x0) {
1595 AttributeSupported
= TRUE
;
1596 AttributeSetting
= ImageInfoV2
[Index
].AttributesSetting
;
1599 if (ImageInfo
[Index
].AttributesSupported
!= 0x0) {
1600 AttributeSupported
= TRUE
;
1601 AttributeSetting
= ImageInfo
[Index
].AttributesSetting
;
1605 if (!AttributeSupported
) {
1606 AttributeSettingStr
= CatSPrint (NULL
, L
"None");
1608 AttributeSettingStr
= CatSPrint (NULL
, L
"(");
1610 if ((AttributeSetting
& IMAGE_ATTRIBUTE_IMAGE_UPDATABLE
) != 0x0) {
1611 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_IMAGE_UPDATABLE");
1612 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1613 AttributeSettingStr
= TempRetVal
;
1615 if ((AttributeSetting
& IMAGE_ATTRIBUTE_RESET_REQUIRED
) != 0x0) {
1616 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_RESET_REQUIRED");
1617 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1618 AttributeSettingStr
= TempRetVal
;
1620 if ((AttributeSetting
& IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED
) != 0x0) {
1621 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED");
1622 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1623 AttributeSettingStr
= TempRetVal
;
1625 if ((AttributeSetting
& IMAGE_ATTRIBUTE_IN_USE
) != 0x0) {
1626 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_IN_USE");
1627 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1628 AttributeSettingStr
= TempRetVal
;
1630 if ((AttributeSetting
& IMAGE_ATTRIBUTE_UEFI_IMAGE
) != 0x0) {
1631 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_UEFI_IMAGE");
1632 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1633 AttributeSettingStr
= TempRetVal
;
1635 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" )");
1636 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1637 AttributeSettingStr
= TempRetVal
;
1640 if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1
) {
1641 if (ImageInfoV1
[Index
].ImageIndex
!= 0x0) {
1645 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V1
), NULL
);
1646 if (TempStr
== NULL
) {
1649 TempRetVal
= CatSPrint (
1653 ImageInfoV1
[Index
].ImageIndex
,
1654 &ImageInfoV1
[Index
].ImageTypeId
,
1655 ImageInfoV1
[Index
].ImageId
,
1656 ImageInfoV1
[Index
].ImageIdName
,
1657 ImageInfoV1
[Index
].Version
,
1658 ImageInfoV1
[Index
].VersionName
,
1659 ImageInfoV1
[Index
].Size
,
1660 ImageInfoV1
[Index
].AttributesSupported
,
1661 AttributeSettingStr
,
1662 ImageInfoV1
[Index
].Compatibilities
1664 SHELL_FREE_NON_NULL (RetVal
);
1665 RetVal
= TempRetVal
;
1666 SHELL_FREE_NON_NULL (TempStr
);
1667 } else if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2
) {
1668 if (ImageInfoV2
[Index
].ImageIndex
!= 0x0) {
1672 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V2
), NULL
);
1673 if (TempStr
== NULL
) {
1676 TempRetVal
= CatSPrint (
1680 ImageInfoV2
[Index
].ImageIndex
,
1681 &ImageInfoV2
[Index
].ImageTypeId
,
1682 ImageInfoV2
[Index
].ImageId
,
1683 ImageInfoV2
[Index
].ImageIdName
,
1684 ImageInfoV2
[Index
].Version
,
1685 ImageInfoV2
[Index
].VersionName
,
1686 ImageInfoV2
[Index
].Size
,
1687 ImageInfoV2
[Index
].AttributesSupported
,
1688 AttributeSettingStr
,
1689 ImageInfoV2
[Index
].Compatibilities
,
1690 ImageInfoV2
[Index
].LowestSupportedImageVersion
1692 SHELL_FREE_NON_NULL (RetVal
);
1693 RetVal
= TempRetVal
;
1694 SHELL_FREE_NON_NULL (TempStr
);
1696 if (ImageInfo
[Index
].ImageIndex
!= 0x0) {
1700 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO
), NULL
);
1701 if (TempStr
== NULL
) {
1704 TempRetVal
= CatSPrint (
1708 ImageInfo
[Index
].ImageIndex
,
1709 &ImageInfo
[Index
].ImageTypeId
,
1710 ImageInfo
[Index
].ImageId
,
1711 ImageInfo
[Index
].ImageIdName
,
1712 ImageInfo
[Index
].Version
,
1713 ImageInfo
[Index
].VersionName
,
1714 ImageInfo
[Index
].Size
,
1715 ImageInfo
[Index
].AttributesSupported
,
1716 AttributeSettingStr
,
1717 ImageInfo
[Index
].Compatibilities
,
1718 ImageInfo
[Index
].LowestSupportedImageVersion
,
1719 ImageInfo
[Index
].LastAttemptVersion
,
1720 ImageInfo
[Index
].LastAttemptStatus
,
1721 ImageInfo
[Index
].HardwareInstance
1723 SHELL_FREE_NON_NULL (RetVal
);
1724 RetVal
= TempRetVal
;
1725 SHELL_FREE_NON_NULL (TempStr
);
1730 if (ImageCount
> 0) {
1731 for (Index
=0; Index
<DescriptorCount
; Index
++) {
1732 for (Index1
=Index
+1; Index1
<DescriptorCount
; Index1
++) {
1733 if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1
) {
1734 if (ImageInfoV1
[Index
].ImageId
== ImageInfoV1
[Index1
].ImageId
) {
1737 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1741 } else if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2
) {
1742 if (ImageInfoV2
[Index
].ImageId
== ImageInfoV2
[Index1
].ImageId
) {
1745 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1750 if (ImageInfo
[Index
].ImageId
== ImageInfo
[Index1
].ImageId
) {
1753 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1764 // Check if ImageId with duplicate value was found
1767 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGEID_NON_UNIQUE
), NULL
);
1768 if (TempStr
== NULL
) {
1771 TempRetVal
= CatSPrint (RetVal
, TempStr
);
1772 SHELL_FREE_NON_NULL (RetVal
);
1773 RetVal
= TempRetVal
;
1774 SHELL_FREE_NON_NULL (TempStr
);
1777 SHELL_FREE_NON_NULL (ImageInfo
);
1778 SHELL_FREE_NON_NULL (PackageVersionName
);
1779 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1784 SHELL_FREE_NON_NULL (RetVal
);
1785 SHELL_FREE_NON_NULL (ImageInfo
);
1786 SHELL_FREE_NON_NULL (PackageVersionName
);
1787 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1793 // Put the information on the NT32 protocol GUIDs here so we are not dependant on the Nt32Pkg
1795 #define LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID \
1797 0x58c518b1, 0x76f3, 0x11d4, { 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
1800 #define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \
1802 0x96eb4ad6, 0xa32a, 0x11d4, { 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
1805 #define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \
1807 0xc95a93d, 0xa006, 0x11d4, { 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
1809 STATIC CONST EFI_GUID WinNtThunkProtocolGuid
= LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID
;
1810 STATIC CONST EFI_GUID WinNtIoProtocolGuid
= LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID
;
1811 STATIC CONST EFI_GUID WinNtSerialPortGuid
= LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID
;
1814 // Deprecated protocols we dont want to link from IntelFrameworkModulePkg
1816 #define LOCAL_EFI_ISA_IO_PROTOCOL_GUID \
1818 0x7ee2bd44, 0x3da0, 0x11d4, { 0x9a, 0x38, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
1820 #define LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID \
1822 0x64a892dc, 0x5561, 0x4536, { 0x92, 0xc7, 0x79, 0x9b, 0xfc, 0x18, 0x33, 0x55 } \
1824 STATIC CONST EFI_GUID EfiIsaIoProtocolGuid
= LOCAL_EFI_ISA_IO_PROTOCOL_GUID
;
1825 STATIC CONST EFI_GUID EfiIsaAcpiProtocolGuid
= LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID
;
1828 STATIC CONST GUID_INFO_BLOCK mGuidStringListNT
[] = {
1829 {STRING_TOKEN(STR_WINNT_THUNK
), (EFI_GUID
*)&WinNtThunkProtocolGuid
, NULL
},
1830 {STRING_TOKEN(STR_WINNT_DRIVER_IO
), (EFI_GUID
*)&WinNtIoProtocolGuid
, NULL
},
1831 {STRING_TOKEN(STR_WINNT_SERIAL_PORT
), (EFI_GUID
*)&WinNtSerialPortGuid
, NULL
},
1835 STATIC CONST GUID_INFO_BLOCK mGuidStringList
[] = {
1836 {STRING_TOKEN(STR_LOADED_IMAGE
), &gEfiLoadedImageProtocolGuid
, LoadedImageProtocolDumpInformation
},
1837 {STRING_TOKEN(STR_DEVICE_PATH
), &gEfiDevicePathProtocolGuid
, DevicePathProtocolDumpInformation
},
1838 {STRING_TOKEN(STR_IMAGE_PATH
), &gEfiLoadedImageDevicePathProtocolGuid
, LoadedImageDevicePathProtocolDumpInformation
},
1839 {STRING_TOKEN(STR_DEVICE_PATH_UTIL
), &gEfiDevicePathUtilitiesProtocolGuid
, NULL
},
1840 {STRING_TOKEN(STR_DEVICE_PATH_TXT
), &gEfiDevicePathToTextProtocolGuid
, NULL
},
1841 {STRING_TOKEN(STR_DEVICE_PATH_FTXT
), &gEfiDevicePathFromTextProtocolGuid
, NULL
},
1842 {STRING_TOKEN(STR_DEVICE_PATH_PC
), &gEfiPcAnsiGuid
, NULL
},
1843 {STRING_TOKEN(STR_DEVICE_PATH_VT100
), &gEfiVT100Guid
, NULL
},
1844 {STRING_TOKEN(STR_DEVICE_PATH_VT100P
), &gEfiVT100PlusGuid
, NULL
},
1845 {STRING_TOKEN(STR_DEVICE_PATH_VTUTF8
), &gEfiVTUTF8Guid
, NULL
},
1846 {STRING_TOKEN(STR_DRIVER_BINDING
), &gEfiDriverBindingProtocolGuid
, NULL
},
1847 {STRING_TOKEN(STR_PLATFORM_OVERRIDE
), &gEfiPlatformDriverOverrideProtocolGuid
, NULL
},
1848 {STRING_TOKEN(STR_BUS_OVERRIDE
), &gEfiBusSpecificDriverOverrideProtocolGuid
, BusSpecificDriverOverrideProtocolDumpInformation
},
1849 {STRING_TOKEN(STR_DRIVER_DIAG
), &gEfiDriverDiagnosticsProtocolGuid
, NULL
},
1850 {STRING_TOKEN(STR_DRIVER_DIAG2
), &gEfiDriverDiagnostics2ProtocolGuid
, NULL
},
1851 {STRING_TOKEN(STR_DRIVER_CN
), &gEfiComponentNameProtocolGuid
, NULL
},
1852 {STRING_TOKEN(STR_DRIVER_CN2
), &gEfiComponentName2ProtocolGuid
, NULL
},
1853 {STRING_TOKEN(STR_PLAT_DRV_CFG
), &gEfiPlatformToDriverConfigurationProtocolGuid
, NULL
},
1854 {STRING_TOKEN(STR_DRIVER_VERSION
), &gEfiDriverSupportedEfiVersionProtocolGuid
, DriverEfiVersionProtocolDumpInformation
},
1855 {STRING_TOKEN(STR_TXT_IN
), &gEfiSimpleTextInProtocolGuid
, NULL
},
1856 {STRING_TOKEN(STR_TXT_IN_EX
), &gEfiSimpleTextInputExProtocolGuid
, NULL
},
1857 {STRING_TOKEN(STR_TXT_OUT
), &gEfiSimpleTextOutProtocolGuid
, TxtOutProtocolDumpInformation
},
1858 {STRING_TOKEN(STR_SIM_POINTER
), &gEfiSimplePointerProtocolGuid
, NULL
},
1859 {STRING_TOKEN(STR_ABS_POINTER
), &gEfiAbsolutePointerProtocolGuid
, NULL
},
1860 {STRING_TOKEN(STR_SERIAL_IO
), &gEfiSerialIoProtocolGuid
, NULL
},
1861 {STRING_TOKEN(STR_GRAPHICS_OUTPUT
), &gEfiGraphicsOutputProtocolGuid
, GraphicsOutputProtocolDumpInformation
},
1862 {STRING_TOKEN(STR_EDID_DISCOVERED
), &gEfiEdidDiscoveredProtocolGuid
, EdidDiscoveredProtocolDumpInformation
},
1863 {STRING_TOKEN(STR_EDID_ACTIVE
), &gEfiEdidActiveProtocolGuid
, EdidActiveProtocolDumpInformation
},
1864 {STRING_TOKEN(STR_EDID_OVERRIDE
), &gEfiEdidOverrideProtocolGuid
, NULL
},
1865 {STRING_TOKEN(STR_CON_IN
), &gEfiConsoleInDeviceGuid
, NULL
},
1866 {STRING_TOKEN(STR_CON_OUT
), &gEfiConsoleOutDeviceGuid
, NULL
},
1867 {STRING_TOKEN(STR_STD_ERR
), &gEfiStandardErrorDeviceGuid
, NULL
},
1868 {STRING_TOKEN(STR_LOAD_FILE
), &gEfiLoadFileProtocolGuid
, NULL
},
1869 {STRING_TOKEN(STR_LOAD_FILE2
), &gEfiLoadFile2ProtocolGuid
, NULL
},
1870 {STRING_TOKEN(STR_SIMPLE_FILE_SYS
), &gEfiSimpleFileSystemProtocolGuid
, NULL
},
1871 {STRING_TOKEN(STR_TAPE_IO
), &gEfiTapeIoProtocolGuid
, NULL
},
1872 {STRING_TOKEN(STR_DISK_IO
), &gEfiDiskIoProtocolGuid
, NULL
},
1873 {STRING_TOKEN(STR_BLK_IO
), &gEfiBlockIoProtocolGuid
, BlockIoProtocolDumpInformation
},
1874 {STRING_TOKEN(STR_UC
), &gEfiUnicodeCollationProtocolGuid
, NULL
},
1875 {STRING_TOKEN(STR_UC2
), &gEfiUnicodeCollation2ProtocolGuid
, NULL
},
1876 {STRING_TOKEN(STR_PCIRB_IO
), &gEfiPciRootBridgeIoProtocolGuid
, PciRootBridgeIoDumpInformation
},
1877 {STRING_TOKEN(STR_PCI_IO
), &gEfiPciIoProtocolGuid
, NULL
},
1878 {STRING_TOKEN(STR_SCSI_PT
), &gEfiScsiPassThruProtocolGuid
, NULL
},
1879 {STRING_TOKEN(STR_SCSI_IO
), &gEfiScsiIoProtocolGuid
, NULL
},
1880 {STRING_TOKEN(STR_SCSI_PT_EXT
), &gEfiExtScsiPassThruProtocolGuid
, NULL
},
1881 {STRING_TOKEN(STR_ISCSI
), &gEfiIScsiInitiatorNameProtocolGuid
, NULL
},
1882 {STRING_TOKEN(STR_USB_IO
), &gEfiUsbIoProtocolGuid
, NULL
},
1883 {STRING_TOKEN(STR_USB_HC
), &gEfiUsbHcProtocolGuid
, NULL
},
1884 {STRING_TOKEN(STR_USB_HC2
), &gEfiUsb2HcProtocolGuid
, NULL
},
1885 {STRING_TOKEN(STR_DEBUG_SUPPORT
), &gEfiDebugSupportProtocolGuid
, DebugSupportProtocolDumpInformation
},
1886 {STRING_TOKEN(STR_DEBUG_PORT
), &gEfiDebugPortProtocolGuid
, NULL
},
1887 {STRING_TOKEN(STR_DECOMPRESS
), &gEfiDecompressProtocolGuid
, NULL
},
1888 {STRING_TOKEN(STR_ACPI_TABLE
), &gEfiAcpiTableProtocolGuid
, NULL
},
1889 {STRING_TOKEN(STR_EBC_INTERPRETER
), &gEfiEbcProtocolGuid
, NULL
},
1890 {STRING_TOKEN(STR_SNP
), &gEfiSimpleNetworkProtocolGuid
, NULL
},
1891 {STRING_TOKEN(STR_NII
), &gEfiNetworkInterfaceIdentifierProtocolGuid
, NULL
},
1892 {STRING_TOKEN(STR_NII_31
), &gEfiNetworkInterfaceIdentifierProtocolGuid_31
, NULL
},
1893 {STRING_TOKEN(STR_PXE_BC
), &gEfiPxeBaseCodeProtocolGuid
, NULL
},
1894 {STRING_TOKEN(STR_PXE_CB
), &gEfiPxeBaseCodeCallbackProtocolGuid
, NULL
},
1895 {STRING_TOKEN(STR_BIS
), &gEfiBisProtocolGuid
, NULL
},
1896 {STRING_TOKEN(STR_MNP_SB
), &gEfiManagedNetworkServiceBindingProtocolGuid
, NULL
},
1897 {STRING_TOKEN(STR_MNP
), &gEfiManagedNetworkProtocolGuid
, NULL
},
1898 {STRING_TOKEN(STR_ARP_SB
), &gEfiArpServiceBindingProtocolGuid
, NULL
},
1899 {STRING_TOKEN(STR_ARP
), &gEfiArpProtocolGuid
, NULL
},
1900 {STRING_TOKEN(STR_DHCPV4_SB
), &gEfiDhcp4ServiceBindingProtocolGuid
, NULL
},
1901 {STRING_TOKEN(STR_DHCPV4
), &gEfiDhcp4ProtocolGuid
, NULL
},
1902 {STRING_TOKEN(STR_TCPV4_SB
), &gEfiTcp4ServiceBindingProtocolGuid
, NULL
},
1903 {STRING_TOKEN(STR_TCPV4
), &gEfiTcp4ProtocolGuid
, NULL
},
1904 {STRING_TOKEN(STR_IPV4_SB
), &gEfiIp4ServiceBindingProtocolGuid
, NULL
},
1905 {STRING_TOKEN(STR_IPV4
), &gEfiIp4ProtocolGuid
, NULL
},
1906 {STRING_TOKEN(STR_IPV4_CFG
), &gEfiIp4ConfigProtocolGuid
, NULL
},
1907 {STRING_TOKEN(STR_IPV4_CFG2
), &gEfiIp4Config2ProtocolGuid
, NULL
},
1908 {STRING_TOKEN(STR_UDPV4_SB
), &gEfiUdp4ServiceBindingProtocolGuid
, NULL
},
1909 {STRING_TOKEN(STR_UDPV4
), &gEfiUdp4ProtocolGuid
, NULL
},
1910 {STRING_TOKEN(STR_MTFTPV4_SB
), &gEfiMtftp4ServiceBindingProtocolGuid
, NULL
},
1911 {STRING_TOKEN(STR_MTFTPV4
), &gEfiMtftp4ProtocolGuid
, NULL
},
1912 {STRING_TOKEN(STR_AUTH_INFO
), &gEfiAuthenticationInfoProtocolGuid
, NULL
},
1913 {STRING_TOKEN(STR_HASH_SB
), &gEfiHashServiceBindingProtocolGuid
, NULL
},
1914 {STRING_TOKEN(STR_HASH
), &gEfiHashProtocolGuid
, NULL
},
1915 {STRING_TOKEN(STR_HII_FONT
), &gEfiHiiFontProtocolGuid
, NULL
},
1916 {STRING_TOKEN(STR_HII_STRING
), &gEfiHiiStringProtocolGuid
, NULL
},
1917 {STRING_TOKEN(STR_HII_IMAGE
), &gEfiHiiImageProtocolGuid
, NULL
},
1918 {STRING_TOKEN(STR_HII_DATABASE
), &gEfiHiiDatabaseProtocolGuid
, NULL
},
1919 {STRING_TOKEN(STR_HII_CONFIG_ROUT
), &gEfiHiiConfigRoutingProtocolGuid
, NULL
},
1920 {STRING_TOKEN(STR_HII_CONFIG_ACC
), &gEfiHiiConfigAccessProtocolGuid
, NULL
},
1921 {STRING_TOKEN(STR_HII_FORM_BROWSER2
), &gEfiFormBrowser2ProtocolGuid
, NULL
},
1922 {STRING_TOKEN(STR_DRIVER_FAM_OVERRIDE
), &gEfiDriverFamilyOverrideProtocolGuid
, NULL
},
1923 {STRING_TOKEN(STR_PCD
), &gPcdProtocolGuid
, NULL
},
1924 {STRING_TOKEN(STR_TCG
), &gEfiTcgProtocolGuid
, NULL
},
1925 {STRING_TOKEN(STR_HII_PACKAGE_LIST
), &gEfiHiiPackageListProtocolGuid
, NULL
},
1928 // the ones under this are deprecated by the current UEFI Spec, but may be found anyways...
1930 {STRING_TOKEN(STR_SHELL_INTERFACE
), &gEfiShellInterfaceGuid
, NULL
},
1931 {STRING_TOKEN(STR_SHELL_ENV2
), &gEfiShellEnvironment2Guid
, NULL
},
1932 {STRING_TOKEN(STR_SHELL_ENV
), &gEfiShellEnvironment2Guid
, NULL
},
1933 {STRING_TOKEN(STR_DEVICE_IO
), &gEfiDeviceIoProtocolGuid
, NULL
},
1934 {STRING_TOKEN(STR_UGA_DRAW
), &gEfiUgaDrawProtocolGuid
, NULL
},
1935 {STRING_TOKEN(STR_UGA_IO
), &gEfiUgaIoProtocolGuid
, NULL
},
1936 {STRING_TOKEN(STR_ESP
), &gEfiPartTypeSystemPartGuid
, NULL
},
1937 {STRING_TOKEN(STR_GPT_NBR
), &gEfiPartTypeLegacyMbrGuid
, NULL
},
1938 {STRING_TOKEN(STR_DRIVER_CONFIG
), &gEfiDriverConfigurationProtocolGuid
, NULL
},
1939 {STRING_TOKEN(STR_DRIVER_CONFIG2
), &gEfiDriverConfiguration2ProtocolGuid
, NULL
},
1942 // these are using local (non-global) definitions to reduce package dependancy.
1944 {STRING_TOKEN(STR_ISA_IO
), (EFI_GUID
*)&EfiIsaIoProtocolGuid
, NULL
},
1945 {STRING_TOKEN(STR_ISA_ACPI
), (EFI_GUID
*)&EfiIsaAcpiProtocolGuid
, NULL
},
1948 // the ones under this are GUID identified structs, not protocols
1950 {STRING_TOKEN(STR_FILE_INFO
), &gEfiFileInfoGuid
, NULL
},
1951 {STRING_TOKEN(STR_FILE_SYS_INFO
), &gEfiFileSystemInfoGuid
, NULL
},
1954 // the ones under this are misc GUIDS.
1956 {STRING_TOKEN(STR_EFI_GLOBAL_VARIABLE
), &gEfiGlobalVariableGuid
, NULL
},
1961 {STRING_TOKEN(STR_IP6_SB
), &gEfiIp6ServiceBindingProtocolGuid
, NULL
},
1962 {STRING_TOKEN(STR_IP6
), &gEfiIp6ProtocolGuid
, NULL
},
1963 {STRING_TOKEN(STR_IP6_CONFIG
), &gEfiIp6ConfigProtocolGuid
, NULL
},
1964 {STRING_TOKEN(STR_MTFTP6_SB
), &gEfiMtftp6ServiceBindingProtocolGuid
, NULL
},
1965 {STRING_TOKEN(STR_MTFTP6
), &gEfiMtftp6ProtocolGuid
, NULL
},
1966 {STRING_TOKEN(STR_DHCP6_SB
), &gEfiDhcp6ServiceBindingProtocolGuid
, NULL
},
1967 {STRING_TOKEN(STR_DHCP6
), &gEfiDhcp6ProtocolGuid
, NULL
},
1968 {STRING_TOKEN(STR_UDP6_SB
), &gEfiUdp6ServiceBindingProtocolGuid
, NULL
},
1969 {STRING_TOKEN(STR_UDP6
), &gEfiUdp6ProtocolGuid
, NULL
},
1970 {STRING_TOKEN(STR_TCP6_SB
), &gEfiTcp6ServiceBindingProtocolGuid
, NULL
},
1971 {STRING_TOKEN(STR_TCP6
), &gEfiTcp6ProtocolGuid
, NULL
},
1972 {STRING_TOKEN(STR_VLAN_CONFIG
), &gEfiVlanConfigProtocolGuid
, NULL
},
1973 {STRING_TOKEN(STR_EAP
), &gEfiEapProtocolGuid
, NULL
},
1974 {STRING_TOKEN(STR_EAP_MGMT
), &gEfiEapManagementProtocolGuid
, NULL
},
1975 {STRING_TOKEN(STR_FTP4_SB
), &gEfiFtp4ServiceBindingProtocolGuid
, NULL
},
1976 {STRING_TOKEN(STR_FTP4
), &gEfiFtp4ProtocolGuid
, NULL
},
1977 {STRING_TOKEN(STR_IP_SEC_CONFIG
), &gEfiIpSecConfigProtocolGuid
, NULL
},
1978 {STRING_TOKEN(STR_DH
), &gEfiDriverHealthProtocolGuid
, NULL
},
1979 {STRING_TOKEN(STR_DEF_IMG_LOAD
), &gEfiDeferredImageLoadProtocolGuid
, NULL
},
1980 {STRING_TOKEN(STR_USER_CRED
), &gEfiUserCredentialProtocolGuid
, NULL
},
1981 {STRING_TOKEN(STR_USER_MNGR
), &gEfiUserManagerProtocolGuid
, NULL
},
1982 {STRING_TOKEN(STR_ATA_PASS_THRU
), &gEfiAtaPassThruProtocolGuid
, NULL
},
1987 {STRING_TOKEN(STR_FW_MGMT
), &gEfiFirmwareManagementProtocolGuid
, FirmwareManagementDumpInformation
},
1988 {STRING_TOKEN(STR_IP_SEC
), &gEfiIpSecProtocolGuid
, NULL
},
1989 {STRING_TOKEN(STR_IP_SEC2
), &gEfiIpSec2ProtocolGuid
, NULL
},
1994 {STRING_TOKEN(STR_KMS
), &gEfiKmsProtocolGuid
, NULL
},
1995 {STRING_TOKEN(STR_BLK_IO2
), &gEfiBlockIo2ProtocolGuid
, NULL
},
1996 {STRING_TOKEN(STR_SSC
), &gEfiStorageSecurityCommandProtocolGuid
, NULL
},
1997 {STRING_TOKEN(STR_UCRED2
), &gEfiUserCredential2ProtocolGuid
, NULL
},
2002 {STRING_TOKEN(STR_DISK_IO2
), &gEfiDiskIo2ProtocolGuid
, NULL
},
2003 {STRING_TOKEN(STR_ADAPTER_INFO
), &gEfiAdapterInformationProtocolGuid
, AdapterInformationDumpInformation
},
2008 {STRING_TOKEN(STR_IDE_CONT_INIT
), &gEfiIdeControllerInitProtocolGuid
, NULL
},
2009 {STRING_TOKEN(STR_DISK_INFO
), &gEfiDiskInfoProtocolGuid
, NULL
},
2014 {STRING_TOKEN(STR_BDS_ARCH
), &gEfiBdsArchProtocolGuid
, NULL
},
2015 {STRING_TOKEN(STR_CPU_ARCH
), &gEfiCpuArchProtocolGuid
, NULL
},
2016 {STRING_TOKEN(STR_MET_ARCH
), &gEfiMetronomeArchProtocolGuid
, NULL
},
2017 {STRING_TOKEN(STR_MON_ARCH
), &gEfiMonotonicCounterArchProtocolGuid
, NULL
},
2018 {STRING_TOKEN(STR_RTC_ARCH
), &gEfiRealTimeClockArchProtocolGuid
, NULL
},
2019 {STRING_TOKEN(STR_RESET_ARCH
), &gEfiResetArchProtocolGuid
, NULL
},
2020 {STRING_TOKEN(STR_RT_ARCH
), &gEfiRuntimeArchProtocolGuid
, NULL
},
2021 {STRING_TOKEN(STR_SEC_ARCH
), &gEfiSecurityArchProtocolGuid
, NULL
},
2022 {STRING_TOKEN(STR_TIMER_ARCH
), &gEfiTimerArchProtocolGuid
, NULL
},
2023 {STRING_TOKEN(STR_VAR_ARCH
), &gEfiVariableWriteArchProtocolGuid
, NULL
},
2024 {STRING_TOKEN(STR_V_ARCH
), &gEfiVariableArchProtocolGuid
, NULL
},
2025 {STRING_TOKEN(STR_SECP
), &gEfiSecurityPolicyProtocolGuid
, NULL
},
2026 {STRING_TOKEN(STR_WDT_ARCH
), &gEfiWatchdogTimerArchProtocolGuid
, NULL
},
2027 {STRING_TOKEN(STR_SCR
), &gEfiStatusCodeRuntimeProtocolGuid
, NULL
},
2028 {STRING_TOKEN(STR_SMB_HC
), &gEfiSmbusHcProtocolGuid
, NULL
},
2029 {STRING_TOKEN(STR_FV_2
), &gEfiFirmwareVolume2ProtocolGuid
, NULL
},
2030 {STRING_TOKEN(STR_FV_BLOCK
), &gEfiFirmwareVolumeBlockProtocolGuid
, NULL
},
2031 {STRING_TOKEN(STR_CAP_ARCH
), &gEfiCapsuleArchProtocolGuid
, NULL
},
2032 {STRING_TOKEN(STR_MP_SERVICE
), &gEfiMpServiceProtocolGuid
, NULL
},
2033 {STRING_TOKEN(STR_HBRAP
), &gEfiPciHostBridgeResourceAllocationProtocolGuid
, NULL
},
2034 {STRING_TOKEN(STR_PCIP
), &gEfiPciPlatformProtocolGuid
, NULL
},
2035 {STRING_TOKEN(STR_PCIO
), &gEfiPciOverrideProtocolGuid
, NULL
},
2036 {STRING_TOKEN(STR_PCIE
), &gEfiPciEnumerationCompleteProtocolGuid
, NULL
},
2037 {STRING_TOKEN(STR_IPCID
), &gEfiIncompatiblePciDeviceSupportProtocolGuid
, NULL
},
2038 {STRING_TOKEN(STR_PCIHPI
), &gEfiPciHotPlugInitProtocolGuid
, NULL
},
2039 {STRING_TOKEN(STR_PCIHPR
), &gEfiPciHotPlugRequestProtocolGuid
, NULL
},
2040 {STRING_TOKEN(STR_SMBIOS
), &gEfiSmbiosProtocolGuid
, NULL
},
2041 {STRING_TOKEN(STR_S3_SAVE
), &gEfiS3SaveStateProtocolGuid
, NULL
},
2042 {STRING_TOKEN(STR_S3_S_SMM
), &gEfiS3SmmSaveStateProtocolGuid
, NULL
},
2043 {STRING_TOKEN(STR_RSC
), &gEfiRscHandlerProtocolGuid
, NULL
},
2044 {STRING_TOKEN(STR_S_RSC
), &gEfiSmmRscHandlerProtocolGuid
, NULL
},
2045 {STRING_TOKEN(STR_ACPI_SDT
), &gEfiAcpiSdtProtocolGuid
, NULL
},
2046 {STRING_TOKEN(STR_SIO
), &gEfiSioProtocolGuid
, NULL
},
2047 {STRING_TOKEN(STR_S_CPU2
), &gEfiSmmCpuIo2ProtocolGuid
, NULL
},
2048 {STRING_TOKEN(STR_S_BASE2
), &gEfiSmmBase2ProtocolGuid
, NULL
},
2049 {STRING_TOKEN(STR_S_ACC_2
), &gEfiSmmAccess2ProtocolGuid
, NULL
},
2050 {STRING_TOKEN(STR_S_CON_2
), &gEfiSmmControl2ProtocolGuid
, NULL
},
2051 {STRING_TOKEN(STR_S_CONFIG
), &gEfiSmmConfigurationProtocolGuid
, NULL
},
2052 {STRING_TOKEN(STR_S_RTL
), &gEfiSmmReadyToLockProtocolGuid
, NULL
},
2053 {STRING_TOKEN(STR_DS_RTL
), &gEfiDxeSmmReadyToLockProtocolGuid
, NULL
},
2054 {STRING_TOKEN(STR_S_COMM
), &gEfiSmmCommunicationProtocolGuid
, NULL
},
2055 {STRING_TOKEN(STR_S_STAT
), &gEfiSmmStatusCodeProtocolGuid
, NULL
},
2056 {STRING_TOKEN(STR_S_CPU
), &gEfiSmmCpuProtocolGuid
, NULL
},
2057 {STRING_TOKEN(STR_S_PCIRBIO
), &gEfiPciRootBridgeIoProtocolGuid
, NULL
},
2058 {STRING_TOKEN(STR_S_SWD
), &gEfiSmmSwDispatch2ProtocolGuid
, NULL
},
2059 {STRING_TOKEN(STR_S_SXD
), &gEfiSmmSxDispatch2ProtocolGuid
, NULL
},
2060 {STRING_TOKEN(STR_S_PTD2
), &gEfiSmmPeriodicTimerDispatch2ProtocolGuid
, NULL
},
2061 {STRING_TOKEN(STR_S_UD2
), &gEfiSmmUsbDispatch2ProtocolGuid
, NULL
},
2062 {STRING_TOKEN(STR_S_GD2
), &gEfiSmmGpiDispatch2ProtocolGuid
, NULL
},
2063 {STRING_TOKEN(STR_S_SBD2
), &gEfiSmmStandbyButtonDispatch2ProtocolGuid
, NULL
},
2064 {STRING_TOKEN(STR_S_PBD2
), &gEfiSmmPowerButtonDispatch2ProtocolGuid
, NULL
},
2065 {STRING_TOKEN(STR_S_ITD2
), &gEfiSmmIoTrapDispatch2ProtocolGuid
, NULL
},
2066 {STRING_TOKEN(STR_PCD
), &gEfiPcdProtocolGuid
, NULL
},
2067 {STRING_TOKEN(STR_FVB2
), &gEfiFirmwareVolumeBlock2ProtocolGuid
, NULL
},
2068 {STRING_TOKEN(STR_CPUIO2
), &gEfiCpuIo2ProtocolGuid
, NULL
},
2069 {STRING_TOKEN(STR_LEGACY_R2
), &gEfiLegacyRegion2ProtocolGuid
, NULL
},
2070 {STRING_TOKEN(STR_SAL_MIP
), &gEfiSalMcaInitPmiProtocolGuid
, NULL
},
2071 {STRING_TOKEN(STR_ES_BS
), &gEfiExtendedSalBootServiceProtocolGuid
, NULL
},
2072 {STRING_TOKEN(STR_ES_BIO
), &gEfiExtendedSalBaseIoServicesProtocolGuid
, NULL
},
2073 {STRING_TOKEN(STR_ES_STALL
), &gEfiExtendedSalStallServicesProtocolGuid
, NULL
},
2074 {STRING_TOKEN(STR_ES_RTC
), &gEfiExtendedSalRtcServicesProtocolGuid
, NULL
},
2075 {STRING_TOKEN(STR_ES_VS
), &gEfiExtendedSalVariableServicesProtocolGuid
, NULL
},
2076 {STRING_TOKEN(STR_ES_MTC
), &gEfiExtendedSalMtcServicesProtocolGuid
, NULL
},
2077 {STRING_TOKEN(STR_ES_RESET
), &gEfiExtendedSalResetServicesProtocolGuid
, NULL
},
2078 {STRING_TOKEN(STR_ES_SC
), &gEfiExtendedSalStatusCodeServicesProtocolGuid
, NULL
},
2079 {STRING_TOKEN(STR_ES_FBS
), &gEfiExtendedSalFvBlockServicesProtocolGuid
, NULL
},
2080 {STRING_TOKEN(STR_ES_MP
), &gEfiExtendedSalMpServicesProtocolGuid
, NULL
},
2081 {STRING_TOKEN(STR_ES_PAL
), &gEfiExtendedSalPalServicesProtocolGuid
, NULL
},
2082 {STRING_TOKEN(STR_ES_BASE
), &gEfiExtendedSalBaseServicesProtocolGuid
, NULL
},
2083 {STRING_TOKEN(STR_ES_MCA
), &gEfiExtendedSalMcaServicesProtocolGuid
, NULL
},
2084 {STRING_TOKEN(STR_ES_PCI
), &gEfiExtendedSalPciServicesProtocolGuid
, NULL
},
2085 {STRING_TOKEN(STR_ES_CACHE
), &gEfiExtendedSalCacheServicesProtocolGuid
, NULL
},
2086 {STRING_TOKEN(STR_ES_MCA_LOG
), &gEfiExtendedSalMcaLogServicesProtocolGuid
, NULL
},
2087 {STRING_TOKEN(STR_S2ARCH
), &gEfiSecurity2ArchProtocolGuid
, NULL
},
2088 {STRING_TOKEN(STR_EODXE
), &gEfiSmmEndOfDxeProtocolGuid
, NULL
},
2089 {STRING_TOKEN(STR_ISAHC
), &gEfiIsaHcProtocolGuid
, NULL
},
2090 {STRING_TOKEN(STR_ISAHC_B
), &gEfiIsaHcServiceBindingProtocolGuid
, NULL
},
2091 {STRING_TOKEN(STR_SIO_C
), &gEfiSioControlProtocolGuid
, NULL
},
2092 {STRING_TOKEN(STR_GET_PCD
), &gEfiGetPcdInfoProtocolGuid
, NULL
},
2093 {STRING_TOKEN(STR_I2C_M
), &gEfiI2cMasterProtocolGuid
, NULL
},
2094 {STRING_TOKEN(STR_I2CIO
), &gEfiI2cIoProtocolGuid
, NULL
},
2095 {STRING_TOKEN(STR_I2CEN
), &gEfiI2cEnumerateProtocolGuid
, NULL
},
2096 {STRING_TOKEN(STR_I2C_H
), &gEfiI2cHostProtocolGuid
, NULL
},
2097 {STRING_TOKEN(STR_I2C_BCM
), &gEfiI2cBusConfigurationManagementProtocolGuid
, NULL
},
2098 {STRING_TOKEN(STR_TREE
), &gEfiTrEEProtocolGuid
, NULL
},
2099 {STRING_TOKEN(STR_TCG2
), &gEfiTcg2ProtocolGuid
, NULL
},
2100 {STRING_TOKEN(STR_TIMESTAMP
), &gEfiTimestampProtocolGuid
, NULL
},
2101 {STRING_TOKEN(STR_RNG
), &gEfiRngProtocolGuid
, NULL
},
2102 {STRING_TOKEN(STR_NVMEPT
), &gEfiNvmExpressPassThruProtocolGuid
, NULL
},
2103 {STRING_TOKEN(STR_H2_SB
), &gEfiHash2ServiceBindingProtocolGuid
, NULL
},
2104 {STRING_TOKEN(STR_HASH2
), &gEfiHash2ProtocolGuid
, NULL
},
2105 {STRING_TOKEN(STR_BIO_C
), &gEfiBlockIoCryptoProtocolGuid
, NULL
},
2106 {STRING_TOKEN(STR_SCR
), &gEfiSmartCardReaderProtocolGuid
, NULL
},
2107 {STRING_TOKEN(STR_SCE
), &gEfiSmartCardEdgeProtocolGuid
, NULL
},
2108 {STRING_TOKEN(STR_USB_FIO
), &gEfiUsbFunctionIoProtocolGuid
, NULL
},
2109 {STRING_TOKEN(STR_BC_HC
), &gEfiBluetoothHcProtocolGuid
, NULL
},
2110 {STRING_TOKEN(STR_BC_IO_SB
), &gEfiBluetoothIoServiceBindingProtocolGuid
, NULL
},
2111 {STRING_TOKEN(STR_BC_IO
), &gEfiBluetoothIoProtocolGuid
, NULL
},
2112 {STRING_TOKEN(STR_BC_C
), &gEfiBluetoothConfigProtocolGuid
, NULL
},
2113 {STRING_TOKEN(STR_REG_EXP
), &gEfiRegularExpressionProtocolGuid
, NULL
},
2114 {STRING_TOKEN(STR_B_MGR_P
), &gEfiBootManagerPolicyProtocolGuid
, NULL
},
2115 {STRING_TOKEN(STR_CKH
), &gEfiConfigKeywordHandlerProtocolGuid
, NULL
},
2116 {STRING_TOKEN(STR_WIFI
), &gEfiWiFiProtocolGuid
, NULL
},
2117 {STRING_TOKEN(STR_EAP_M
), &gEfiEapManagement2ProtocolGuid
, NULL
},
2118 {STRING_TOKEN(STR_EAP_C
), &gEfiEapConfigurationProtocolGuid
, NULL
},
2119 {STRING_TOKEN(STR_PKCS7
), &gEfiPkcs7VerifyProtocolGuid
, NULL
},
2120 {STRING_TOKEN(STR_NET_DNS4_SB
), &gEfiDns4ServiceBindingProtocolGuid
, NULL
},
2121 {STRING_TOKEN(STR_NET_DNS4
), &gEfiDns4ProtocolGuid
, NULL
},
2122 {STRING_TOKEN(STR_NET_DNS6_SB
), &gEfiDns6ServiceBindingProtocolGuid
, NULL
},
2123 {STRING_TOKEN(STR_NET_DNS6
), &gEfiDns6ProtocolGuid
, NULL
},
2124 {STRING_TOKEN(STR_NET_HTTP_SB
), &gEfiHttpServiceBindingProtocolGuid
, NULL
},
2125 {STRING_TOKEN(STR_NET_HTTP
), &gEfiHttpProtocolGuid
, NULL
},
2126 {STRING_TOKEN(STR_NET_HTTP_U
), &gEfiHttpUtilitiesProtocolGuid
, NULL
},
2127 {STRING_TOKEN(STR_REST
), &gEfiRestProtocolGuid
, NULL
},
2130 // UEFI Shell Spec 2.0
2132 {STRING_TOKEN(STR_SHELL_PARAMETERS
), &gEfiShellParametersProtocolGuid
, NULL
},
2133 {STRING_TOKEN(STR_SHELL
), &gEfiShellProtocolGuid
, NULL
},
2136 // UEFI Shell Spec 2.1
2138 {STRING_TOKEN(STR_SHELL_DYNAMIC
), &gEfiShellDynamicCommandProtocolGuid
, NULL
},
2143 {STRING_TOKEN(STR_PCDINFOPROT
), &gGetPcdInfoProtocolGuid
, NULL
},
2152 Function to get the node for a protocol or struct from it's GUID.
2154 if Guid is NULL, then ASSERT.
2156 @param[in] Guid The GUID to look for the name of.
2160 CONST GUID_INFO_BLOCK
*
2161 InternalShellGetNodeFromGuid(
2162 IN CONST EFI_GUID
* Guid
2165 CONST GUID_INFO_BLOCK
*ListWalker
;
2168 ASSERT(Guid
!= NULL
);
2170 for (LoopCount
= 0, ListWalker
= mGuidList
; mGuidList
!= NULL
&& LoopCount
< mGuidListCount
; LoopCount
++, ListWalker
++) {
2171 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
2172 return (ListWalker
);
2176 if (PcdGetBool(PcdShellIncludeNtGuids
)) {
2177 for (ListWalker
= mGuidStringListNT
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
2178 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
2179 return (ListWalker
);
2183 for (ListWalker
= mGuidStringList
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
2184 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
2185 return (ListWalker
);
2192 Function to add a new GUID/Name mapping.
2194 @param[in] Guid The Guid
2195 @param[in] NameID The STRING id of the HII string to use
2196 @param[in] DumpFunc The pointer to the dump function
2199 @retval EFI_SUCCESS The operation was sucessful
2200 @retval EFI_OUT_OF_RESOURCES A memory allocation failed
2201 @retval EFI_INVALID_PARAMETER Guid NameId was invalid
2204 InsertNewGuidNameMapping(
2205 IN CONST EFI_GUID
*Guid
,
2206 IN CONST EFI_STRING_ID NameID
,
2207 IN CONST DUMP_PROTOCOL_INFO DumpFunc OPTIONAL
2210 ASSERT(Guid
!= NULL
);
2211 ASSERT(NameID
!= 0);
2213 mGuidList
= ReallocatePool(mGuidListCount
* sizeof(GUID_INFO_BLOCK
), mGuidListCount
+1 * sizeof(GUID_INFO_BLOCK
), mGuidList
);
2214 if (mGuidList
== NULL
) {
2216 return (EFI_OUT_OF_RESOURCES
);
2220 mGuidList
[mGuidListCount
- 1].GuidId
= AllocateCopyPool(sizeof(EFI_GUID
), Guid
);
2221 mGuidList
[mGuidListCount
- 1].StringId
= NameID
;
2222 mGuidList
[mGuidListCount
- 1].DumpInfo
= DumpFunc
;
2224 if (mGuidList
[mGuidListCount
- 1].GuidId
== NULL
) {
2225 return (EFI_OUT_OF_RESOURCES
);
2228 return (EFI_SUCCESS
);
2232 Function to add a new GUID/Name mapping.
2234 This cannot overwrite an existing mapping.
2236 @param[in] Guid The Guid
2237 @param[in] TheName The Guid's name
2238 @param[in] Lang RFC4646 language code list or NULL
2240 @retval EFI_SUCCESS The operation was sucessful
2241 @retval EFI_ACCESS_DENIED There was a duplicate
2242 @retval EFI_OUT_OF_RESOURCES A memory allocation failed
2243 @retval EFI_INVALID_PARAMETER Guid or TheName was NULL
2247 AddNewGuidNameMapping(
2248 IN CONST EFI_GUID
*Guid
,
2249 IN CONST CHAR16
*TheName
,
2250 IN CONST CHAR8
*Lang OPTIONAL
2253 EFI_STRING_ID NameID
;
2255 HandleParsingHiiInit();
2257 if (Guid
== NULL
|| TheName
== NULL
){
2258 return (EFI_INVALID_PARAMETER
);
2261 if ((InternalShellGetNodeFromGuid(Guid
)) != NULL
) {
2262 return (EFI_ACCESS_DENIED
);
2265 NameID
= HiiSetString(mHandleParsingHiiHandle
, 0, (CHAR16
*)TheName
, Lang
);
2267 return (EFI_OUT_OF_RESOURCES
);
2270 return (InsertNewGuidNameMapping(Guid
, NameID
, NULL
));
2274 Function to get the name of a protocol or struct from it's GUID.
2276 if Guid is NULL, then ASSERT.
2278 @param[in] Guid The GUID to look for the name of.
2279 @param[in] Lang The language to use.
2281 @return pointer to string of the name. The caller
2282 is responsible to free this memory.
2286 GetStringNameFromGuid(
2287 IN CONST EFI_GUID
*Guid
,
2288 IN CONST CHAR8
*Lang OPTIONAL
2291 CONST GUID_INFO_BLOCK
*Id
;
2293 HandleParsingHiiInit();
2295 Id
= InternalShellGetNodeFromGuid(Guid
);
2299 return HiiGetString (mHandleParsingHiiHandle
, Id
->StringId
, Lang
);
2303 Function to dump protocol information from a handle.
2305 This function will return a allocated string buffer containing the
2306 information. The caller is responsible for freeing the memory.
2308 If Guid is NULL, ASSERT().
2309 If TheHandle is NULL, ASSERT().
2311 @param[in] TheHandle The handle to dump information from.
2312 @param[in] Guid The GUID of the protocol to dump.
2313 @param[in] Verbose TRUE for extra info. FALSE otherwise.
2315 @return The pointer to string.
2316 @retval NULL An error was encountered.
2320 GetProtocolInformationDump(
2321 IN CONST EFI_HANDLE TheHandle
,
2322 IN CONST EFI_GUID
*Guid
,
2323 IN CONST BOOLEAN Verbose
2326 CONST GUID_INFO_BLOCK
*Id
;
2328 ASSERT(TheHandle
!= NULL
);
2329 ASSERT(Guid
!= NULL
);
2331 if (TheHandle
== NULL
|| Guid
== NULL
) {
2335 Id
= InternalShellGetNodeFromGuid(Guid
);
2336 if (Id
!= NULL
&& Id
->DumpInfo
!= NULL
) {
2337 return (Id
->DumpInfo(TheHandle
, Verbose
));
2343 Function to get the Guid for a protocol or struct based on it's string name.
2345 do not modify the returned Guid.
2347 @param[in] Name The pointer to the string name.
2348 @param[in] Lang The pointer to the language code.
2349 @param[out] Guid The pointer to the Guid.
2351 @retval EFI_SUCCESS The operation was sucessful.
2355 GetGuidFromStringName(
2356 IN CONST CHAR16
*Name
,
2357 IN CONST CHAR8
*Lang OPTIONAL
,
2361 CONST GUID_INFO_BLOCK
*ListWalker
;
2365 HandleParsingHiiInit();
2367 ASSERT(Guid
!= NULL
);
2369 return (EFI_INVALID_PARAMETER
);
2373 if (PcdGetBool(PcdShellIncludeNtGuids
)) {
2374 for (ListWalker
= mGuidStringListNT
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
2375 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
2376 if (Name
!= NULL
&& String
!= NULL
&& StringNoCaseCompare (&Name
, &String
) == 0) {
2377 *Guid
= ListWalker
->GuidId
;
2379 SHELL_FREE_NON_NULL(String
);
2380 if (*Guid
!= NULL
) {
2381 return (EFI_SUCCESS
);
2385 for (ListWalker
= mGuidStringList
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
2386 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
2387 if (Name
!= NULL
&& String
!= NULL
&& StringNoCaseCompare (&Name
, &String
) == 0) {
2388 *Guid
= ListWalker
->GuidId
;
2390 SHELL_FREE_NON_NULL(String
);
2391 if (*Guid
!= NULL
) {
2392 return (EFI_SUCCESS
);
2396 for (LoopCount
= 0, ListWalker
= mGuidList
; mGuidList
!= NULL
&& LoopCount
< mGuidListCount
; LoopCount
++, ListWalker
++) {
2397 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
2398 if (Name
!= NULL
&& String
!= NULL
&& StringNoCaseCompare (&Name
, &String
) == 0) {
2399 *Guid
= ListWalker
->GuidId
;
2401 SHELL_FREE_NON_NULL(String
);
2402 if (*Guid
!= NULL
) {
2403 return (EFI_SUCCESS
);
2407 return (EFI_NOT_FOUND
);
2411 Get best support language for this driver.
2413 First base on the user input language to search, second base on the current
2414 platform used language to search, third get the first language from the
2415 support language list. The caller need to free the buffer of the best language.
2417 @param[in] SupportedLanguages The support languages for this driver.
2418 @param[in] InputLanguage The user input language.
2419 @param[in] Iso639Language Whether get language for ISO639.
2421 @return The best support language for this driver.
2425 GetBestLanguageForDriver (
2426 IN CONST CHAR8
*SupportedLanguages
,
2427 IN CONST CHAR8
*InputLanguage
,
2428 IN BOOLEAN Iso639Language
2431 CHAR8
*LanguageVariable
;
2432 CHAR8
*BestLanguage
;
2434 GetVariable2 (Iso639Language
? L
"Lang" : L
"PlatformLang", &gEfiGlobalVariableGuid
, (VOID
**)&LanguageVariable
, NULL
);
2436 BestLanguage
= GetBestLanguage(
2439 (InputLanguage
!= NULL
) ? InputLanguage
: "",
2440 (LanguageVariable
!= NULL
) ? LanguageVariable
: "",
2445 if (LanguageVariable
!= NULL
) {
2446 FreePool (LanguageVariable
);
2449 return BestLanguage
;
2453 Function to retrieve the driver name (if possible) from the ComponentName or
2454 ComponentName2 protocol
2456 @param[in] TheHandle The driver handle to get the name of.
2457 @param[in] Language The language to use.
2459 @retval NULL The name could not be found.
2460 @return A pointer to the string name. Do not de-allocate the memory.
2464 GetStringNameFromHandle(
2465 IN CONST EFI_HANDLE TheHandle
,
2466 IN CONST CHAR8
*Language
2469 EFI_COMPONENT_NAME2_PROTOCOL
*CompNameStruct
;
2476 Status
= gBS
->OpenProtocol(
2478 &gEfiComponentName2ProtocolGuid
,
2479 (VOID
**)&CompNameStruct
,
2482 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
2483 if (!EFI_ERROR(Status
)) {
2484 BestLang
= GetBestLanguageForDriver (CompNameStruct
->SupportedLanguages
, Language
, FALSE
);
2485 Status
= CompNameStruct
->GetDriverName(CompNameStruct
, BestLang
, &RetVal
);
2486 if (BestLang
!= NULL
) {
2487 FreePool (BestLang
);
2490 if (!EFI_ERROR(Status
)) {
2494 Status
= gBS
->OpenProtocol(
2496 &gEfiComponentNameProtocolGuid
,
2497 (VOID
**)&CompNameStruct
,
2500 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
2501 if (!EFI_ERROR(Status
)) {
2502 BestLang
= GetBestLanguageForDriver (CompNameStruct
->SupportedLanguages
, Language
, FALSE
);
2503 Status
= CompNameStruct
->GetDriverName(CompNameStruct
, BestLang
, &RetVal
);
2504 if (BestLang
!= NULL
) {
2505 FreePool (BestLang
);
2507 if (!EFI_ERROR(Status
)) {
2515 Function to initialize the file global mHandleList object for use in
2516 vonverting handles to index and index to handle.
2518 @retval EFI_SUCCESS The operation was successful.
2521 InternalShellInitHandleList(
2526 EFI_HANDLE
*HandleBuffer
;
2528 HANDLE_LIST
*ListWalker
;
2530 if (mHandleList
.NextIndex
!= 0) {
2533 InitializeListHead(&mHandleList
.List
.Link
);
2534 mHandleList
.NextIndex
= 1;
2535 Status
= gBS
->LocateHandleBuffer (
2542 ASSERT_EFI_ERROR(Status
);
2543 if (EFI_ERROR(Status
)) {
2546 for (mHandleList
.NextIndex
= 1 ; mHandleList
.NextIndex
<= HandleCount
; mHandleList
.NextIndex
++){
2547 ListWalker
= AllocateZeroPool(sizeof(HANDLE_LIST
));
2548 if (ListWalker
!= NULL
) {
2549 ListWalker
->TheHandle
= HandleBuffer
[mHandleList
.NextIndex
- 1];
2550 ListWalker
->TheIndex
= mHandleList
.NextIndex
;
2551 InsertTailList (&mHandleList
.List
.Link
, &ListWalker
->Link
);
2554 FreePool(HandleBuffer
);
2555 return (EFI_SUCCESS
);
2559 Function to retrieve the human-friendly index of a given handle. If the handle
2560 does not have a index one will be automatically assigned. The index value is valid
2561 until the termination of the shell application.
2563 @param[in] TheHandle The handle to retrieve an index for.
2565 @retval 0 A memory allocation failed.
2566 @return The index of the handle.
2571 ConvertHandleToHandleIndex(
2572 IN CONST EFI_HANDLE TheHandle
2576 EFI_GUID
**ProtocolBuffer
;
2577 UINTN ProtocolCount
;
2578 HANDLE_LIST
*ListWalker
;
2580 if (TheHandle
== NULL
) {
2584 InternalShellInitHandleList();
2586 for (ListWalker
= (HANDLE_LIST
*)GetFirstNode(&mHandleList
.List
.Link
)
2587 ; !IsNull(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2588 ; ListWalker
= (HANDLE_LIST
*)GetNextNode(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2590 if (ListWalker
->TheHandle
== TheHandle
) {
2592 // Verify that TheHandle is still present in the Handle Database
2594 Status
= gBS
->ProtocolsPerHandle(TheHandle
, &ProtocolBuffer
, &ProtocolCount
);
2595 if (EFI_ERROR (Status
)) {
2597 // TheHandle is not present in the Handle Database, so delete from the handle list
2599 RemoveEntryList (&ListWalker
->Link
);
2602 FreePool (ProtocolBuffer
);
2603 return (ListWalker
->TheIndex
);
2608 // Verify that TheHandle is valid handle
2610 Status
= gBS
->ProtocolsPerHandle(TheHandle
, &ProtocolBuffer
, &ProtocolCount
);
2611 if (EFI_ERROR (Status
)) {
2613 // TheHandle is not valid, so do not add to handle list
2617 FreePool (ProtocolBuffer
);
2619 ListWalker
= AllocateZeroPool(sizeof(HANDLE_LIST
));
2620 if (ListWalker
== NULL
) {
2623 ListWalker
->TheHandle
= TheHandle
;
2624 ListWalker
->TheIndex
= mHandleList
.NextIndex
++;
2625 InsertTailList(&mHandleList
.List
.Link
,&ListWalker
->Link
);
2626 return (ListWalker
->TheIndex
);
2632 Function to retrieve the EFI_HANDLE from the human-friendly index.
2634 @param[in] TheIndex The index to retrieve the EFI_HANDLE for.
2636 @retval NULL The index was invalid.
2637 @return The EFI_HANDLE that index represents.
2642 ConvertHandleIndexToHandle(
2643 IN CONST UINTN TheIndex
2647 EFI_GUID
**ProtocolBuffer
;
2648 UINTN ProtocolCount
;
2649 HANDLE_LIST
*ListWalker
;
2651 InternalShellInitHandleList();
2653 if (TheIndex
>= mHandleList
.NextIndex
) {
2657 for (ListWalker
= (HANDLE_LIST
*)GetFirstNode(&mHandleList
.List
.Link
)
2658 ; !IsNull(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2659 ; ListWalker
= (HANDLE_LIST
*)GetNextNode(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2661 if (ListWalker
->TheIndex
== TheIndex
&& ListWalker
->TheHandle
!= NULL
) {
2663 // Verify that LinkWalker->TheHandle is valid handle
2665 Status
= gBS
->ProtocolsPerHandle(ListWalker
->TheHandle
, &ProtocolBuffer
, &ProtocolCount
);
2666 if (!EFI_ERROR (Status
)) {
2667 FreePool (ProtocolBuffer
);
2670 // TheHandle is not valid, so do not add to handle list
2672 ListWalker
->TheHandle
= NULL
;
2674 return (ListWalker
->TheHandle
);
2681 Gets all the related EFI_HANDLEs based on the mask supplied.
2683 This function scans all EFI_HANDLES in the UEFI environment's handle database
2684 and returns the ones with the specified relationship (Mask) to the specified
2687 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
2688 If MatchingHandleCount is NULL, then ASSERT.
2690 If MatchingHandleBuffer is not NULL upon a successful return the memory must be
2693 @param[in] DriverBindingHandle The handle with Driver Binding protocol on it.
2694 @param[in] ControllerHandle The handle with Device Path protocol on it.
2695 @param[in] MatchingHandleCount The pointer to UINTN that specifies the number of HANDLES in
2696 MatchingHandleBuffer.
2697 @param[out] MatchingHandleBuffer On a successful return, a buffer of MatchingHandleCount
2698 EFI_HANDLEs with a terminating NULL EFI_HANDLE.
2699 @param[out] HandleType An array of type information.
2701 @retval EFI_SUCCESS The operation was successful, and any related handles
2702 are in MatchingHandleBuffer.
2703 @retval EFI_NOT_FOUND No matching handles were found.
2704 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.
2708 ParseHandleDatabaseByRelationshipWithType (
2709 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL
,
2710 IN CONST EFI_HANDLE ControllerHandle OPTIONAL
,
2711 IN UINTN
*HandleCount
,
2712 OUT EFI_HANDLE
**HandleBuffer
,
2713 OUT UINTN
**HandleType
2718 EFI_GUID
**ProtocolGuidArray
;
2720 UINTN ProtocolIndex
;
2721 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY
*OpenInfo
;
2722 UINTN OpenInfoCount
;
2723 UINTN OpenInfoIndex
;
2725 INTN DriverBindingHandleIndex
;
2727 ASSERT(HandleCount
!= NULL
);
2728 ASSERT(HandleBuffer
!= NULL
);
2729 ASSERT(HandleType
!= NULL
);
2730 ASSERT(DriverBindingHandle
!= NULL
|| ControllerHandle
!= NULL
);
2733 *HandleBuffer
= NULL
;
2737 // Retrieve the list of all handles from the handle database
2739 Status
= gBS
->LocateHandleBuffer (
2746 if (EFI_ERROR (Status
)) {
2750 *HandleType
= AllocateZeroPool (*HandleCount
* sizeof (UINTN
));
2751 if (*HandleType
== NULL
) {
2752 SHELL_FREE_NON_NULL (*HandleBuffer
);
2754 return EFI_OUT_OF_RESOURCES
;
2757 DriverBindingHandleIndex
= -1;
2758 for (HandleIndex
= 0; HandleIndex
< *HandleCount
; HandleIndex
++) {
2759 if (DriverBindingHandle
!= NULL
&& (*HandleBuffer
)[HandleIndex
] == DriverBindingHandle
) {
2760 DriverBindingHandleIndex
= (INTN
)HandleIndex
;
2764 for (HandleIndex
= 0; HandleIndex
< *HandleCount
; HandleIndex
++) {
2766 // Retrieve the list of all the protocols on each handle
2768 Status
= gBS
->ProtocolsPerHandle (
2769 (*HandleBuffer
)[HandleIndex
],
2773 if (EFI_ERROR (Status
)) {
2777 for (ProtocolIndex
= 0; ProtocolIndex
< ArrayCount
; ProtocolIndex
++) {
2780 // Set the bit describing what this handle has
2782 if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiLoadedImageProtocolGuid
) ) {
2783 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_IMAGE_HANDLE
;
2784 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverBindingProtocolGuid
) ) {
2785 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_BINDING_HANDLE
;
2786 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverConfiguration2ProtocolGuid
)) {
2787 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_CONFIGURATION_HANDLE
;
2788 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverConfigurationProtocolGuid
) ) {
2789 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_CONFIGURATION_HANDLE
;
2790 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverDiagnostics2ProtocolGuid
) ) {
2791 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_DIAGNOSTICS_HANDLE
;
2792 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverDiagnosticsProtocolGuid
) ) {
2793 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_DIAGNOSTICS_HANDLE
;
2794 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiComponentName2ProtocolGuid
) ) {
2795 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_COMPONENT_NAME_HANDLE
;
2796 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiComponentNameProtocolGuid
) ) {
2797 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_COMPONENT_NAME_HANDLE
;
2798 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDevicePathProtocolGuid
) ) {
2799 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DEVICE_HANDLE
;
2802 // Retrieve the list of agents that have opened each protocol
2804 Status
= gBS
->OpenProtocolInformation (
2805 (*HandleBuffer
)[HandleIndex
],
2806 ProtocolGuidArray
[ProtocolIndex
],
2810 if (EFI_ERROR (Status
)) {
2814 if (ControllerHandle
== NULL
) {
2816 // ControllerHandle == NULL and DriverBindingHandle != NULL.
2817 // Return information on all the controller handles that the driver specified by DriverBindingHandle is managing
2819 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
2820 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
&& (OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) != 0) {
2821 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
2822 if (DriverBindingHandleIndex
!= -1) {
2823 (*HandleType
)[DriverBindingHandleIndex
] |= (UINTN
)HR_DEVICE_DRIVER
;
2826 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
&& (OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
2827 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
2828 if (DriverBindingHandleIndex
!= -1) {
2829 (*HandleType
)[DriverBindingHandleIndex
] |= (UINTN
)(HR_BUS_DRIVER
| HR_DEVICE_DRIVER
);
2831 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
2832 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== (*HandleBuffer
)[ChildIndex
]) {
2833 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
2839 if (DriverBindingHandle
== NULL
&& ControllerHandle
!= NULL
) {
2840 if (ControllerHandle
== (*HandleBuffer
)[HandleIndex
]) {
2841 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
2842 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
2843 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) != 0) {
2844 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
2845 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== (*HandleBuffer
)[ChildIndex
]) {
2846 (*HandleType
)[ChildIndex
] |= (UINTN
)HR_DEVICE_DRIVER
;
2850 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
2851 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
2852 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== (*HandleBuffer
)[ChildIndex
]) {
2853 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_BUS_DRIVER
| HR_DEVICE_DRIVER
);
2855 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== (*HandleBuffer
)[ChildIndex
]) {
2856 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
2862 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
2863 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
2864 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== ControllerHandle
) {
2865 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_PARENT_HANDLE
);
2871 if (DriverBindingHandle
!= NULL
&& ControllerHandle
!= NULL
) {
2872 if (ControllerHandle
== (*HandleBuffer
)[HandleIndex
]) {
2873 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
2874 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
2875 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) != 0) {
2876 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
) {
2877 if (DriverBindingHandleIndex
!= -1) {
2878 (*HandleType
)[DriverBindingHandleIndex
] |= (UINTN
)HR_DEVICE_DRIVER
;
2882 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
2883 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
) {
2884 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
2885 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== (*HandleBuffer
)[ChildIndex
]) {
2886 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
2891 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
2892 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== (*HandleBuffer
)[ChildIndex
]) {
2893 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_BUS_DRIVER
| HR_DEVICE_DRIVER
);
2899 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
2900 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
2901 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== ControllerHandle
) {
2902 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_PARENT_HANDLE
);
2908 FreePool (OpenInfo
);
2910 FreePool (ProtocolGuidArray
);
2916 Gets all the related EFI_HANDLEs based on the single EFI_HANDLE and the mask
2919 This function will scan all EFI_HANDLES in the UEFI environment's handle database
2920 and return all the ones with the specified relationship (Mask) to the specified
2923 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
2924 If MatchingHandleCount is NULL, then ASSERT.
2926 If MatchingHandleBuffer is not NULL upon a sucessful return the memory must be
2929 @param[in] DriverBindingHandle Handle to a object with Driver Binding protocol
2931 @param[in] ControllerHandle Handle to a device with Device Path protocol on it.
2932 @param[in] Mask Mask of what relationship(s) is desired.
2933 @param[in] MatchingHandleCount Poitner to UINTN specifying number of HANDLES in
2934 MatchingHandleBuffer.
2935 @param[out] MatchingHandleBuffer On a sucessful return a buffer of MatchingHandleCount
2936 EFI_HANDLEs and a terminating NULL EFI_HANDLE.
2938 @retval EFI_SUCCESS The operation was sucessful and any related handles
2939 are in MatchingHandleBuffer;
2940 @retval EFI_NOT_FOUND No matching handles were found.
2941 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.
2945 ParseHandleDatabaseByRelationship (
2946 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL
,
2947 IN CONST EFI_HANDLE ControllerHandle OPTIONAL
,
2948 IN CONST UINTN Mask
,
2949 IN UINTN
*MatchingHandleCount
,
2950 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
2955 EFI_HANDLE
*HandleBuffer
;
2959 ASSERT(MatchingHandleCount
!= NULL
);
2960 ASSERT(DriverBindingHandle
!= NULL
|| ControllerHandle
!= NULL
);
2962 if ((Mask
& HR_VALID_MASK
) != Mask
) {
2963 return (EFI_INVALID_PARAMETER
);
2966 if ((Mask
& HR_CHILD_HANDLE
) != 0 && DriverBindingHandle
== NULL
) {
2967 return (EFI_INVALID_PARAMETER
);
2970 *MatchingHandleCount
= 0;
2971 if (MatchingHandleBuffer
!= NULL
) {
2972 *MatchingHandleBuffer
= NULL
;
2975 HandleBuffer
= NULL
;
2978 Status
= ParseHandleDatabaseByRelationshipWithType (
2979 DriverBindingHandle
,
2985 if (!EFI_ERROR (Status
)) {
2987 // Count the number of handles that match the attributes in Mask
2989 for (HandleIndex
= 0; HandleIndex
< HandleCount
; HandleIndex
++) {
2990 if ((HandleType
[HandleIndex
] & Mask
) == Mask
) {
2991 (*MatchingHandleCount
)++;
2995 // If no handles match the attributes in Mask then return EFI_NOT_FOUND
2997 if (*MatchingHandleCount
== 0) {
2998 Status
= EFI_NOT_FOUND
;
3001 if (MatchingHandleBuffer
== NULL
) {
3003 // Someone just wanted the count...
3005 Status
= EFI_SUCCESS
;
3008 // Allocate a handle buffer for the number of handles that matched the attributes in Mask
3010 *MatchingHandleBuffer
= AllocateZeroPool ((*MatchingHandleCount
+1)* sizeof (EFI_HANDLE
));
3011 if (*MatchingHandleBuffer
== NULL
) {
3012 Status
= EFI_OUT_OF_RESOURCES
;
3014 for (HandleIndex
= 0, *MatchingHandleCount
= 0
3015 ; HandleIndex
< HandleCount
3019 // Fill the allocated buffer with the handles that matched the attributes in Mask
3021 if ((HandleType
[HandleIndex
] & Mask
) == Mask
) {
3022 (*MatchingHandleBuffer
)[(*MatchingHandleCount
)++] = HandleBuffer
[HandleIndex
];
3027 // Make the last one NULL
3029 (*MatchingHandleBuffer
)[*MatchingHandleCount
] = NULL
;
3031 Status
= EFI_SUCCESS
;
3032 } // *MatchingHandleBuffer == NULL (ELSE)
3033 } // MacthingHandleBuffer == NULL (ELSE)
3034 } // *MatchingHandleCount == 0 (ELSE)
3035 } // no error on ParseHandleDatabaseByRelationshipWithType
3037 if (HandleBuffer
!= NULL
) {
3038 FreePool (HandleBuffer
);
3041 if (HandleType
!= NULL
) {
3042 FreePool (HandleType
);
3045 ASSERT ((MatchingHandleBuffer
== NULL
) ||
3046 (*MatchingHandleCount
== 0 && *MatchingHandleBuffer
== NULL
) ||
3047 (*MatchingHandleCount
!= 0 && *MatchingHandleBuffer
!= NULL
));
3052 Gets handles for any child controllers of the passed in controller.
3054 @param[in] ControllerHandle The handle of the "parent controller"
3055 @param[out] MatchingHandleCount Pointer to the number of handles in
3056 MatchingHandleBuffer on return.
3057 @param[out] MatchingHandleBuffer Buffer containing handles on a successful
3061 @retval EFI_SUCCESS The operation was sucessful.
3065 ParseHandleDatabaseForChildControllers(
3066 IN CONST EFI_HANDLE ControllerHandle
,
3067 OUT UINTN
*MatchingHandleCount
,
3068 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
3073 UINTN DriverBindingHandleCount
;
3074 EFI_HANDLE
*DriverBindingHandleBuffer
;
3075 UINTN DriverBindingHandleIndex
;
3076 UINTN ChildControllerHandleCount
;
3077 EFI_HANDLE
*ChildControllerHandleBuffer
;
3078 UINTN ChildControllerHandleIndex
;
3079 EFI_HANDLE
*HandleBufferForReturn
;
3081 if (MatchingHandleCount
== NULL
) {
3082 return (EFI_INVALID_PARAMETER
);
3084 *MatchingHandleCount
= 0;
3086 Status
= PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
3088 &DriverBindingHandleCount
,
3089 &DriverBindingHandleBuffer
3091 if (EFI_ERROR (Status
)) {
3096 // Get a buffer big enough for all the controllers.
3098 HandleBufferForReturn
= GetHandleListByProtocol(NULL
);
3099 if (HandleBufferForReturn
== NULL
) {
3100 FreePool (DriverBindingHandleBuffer
);
3101 return (EFI_NOT_FOUND
);
3104 for (DriverBindingHandleIndex
= 0; DriverBindingHandleIndex
< DriverBindingHandleCount
; DriverBindingHandleIndex
++) {
3105 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
3106 DriverBindingHandleBuffer
[DriverBindingHandleIndex
],
3108 &ChildControllerHandleCount
,
3109 &ChildControllerHandleBuffer
3111 if (EFI_ERROR (Status
)) {
3115 for (ChildControllerHandleIndex
= 0;
3116 ChildControllerHandleIndex
< ChildControllerHandleCount
;
3117 ChildControllerHandleIndex
++
3119 for (HandleIndex
= 0; HandleIndex
< *MatchingHandleCount
; HandleIndex
++) {
3120 if (HandleBufferForReturn
[HandleIndex
] == ChildControllerHandleBuffer
[ChildControllerHandleIndex
]) {
3124 if (HandleIndex
>= *MatchingHandleCount
) {
3125 HandleBufferForReturn
[(*MatchingHandleCount
)++] = ChildControllerHandleBuffer
[ChildControllerHandleIndex
];
3129 FreePool (ChildControllerHandleBuffer
);
3132 FreePool (DriverBindingHandleBuffer
);
3134 if (MatchingHandleBuffer
== NULL
|| *MatchingHandleCount
== 0) {
3136 // The caller is not interested in the actual handles, or we've found none.
3138 FreePool (HandleBufferForReturn
);
3139 HandleBufferForReturn
= NULL
;
3142 if (MatchingHandleBuffer
!= NULL
) {
3143 *MatchingHandleBuffer
= HandleBufferForReturn
;
3146 ASSERT ((MatchingHandleBuffer
== NULL
) ||
3147 (*MatchingHandleCount
== 0 && *MatchingHandleBuffer
== NULL
) ||
3148 (*MatchingHandleCount
!= 0 && *MatchingHandleBuffer
!= NULL
));
3150 return (EFI_SUCCESS
);
3154 Appends 1 buffer to another buffer. This will re-allocate the destination buffer
3155 if necessary to fit all of the data.
3157 If DestinationBuffer is NULL, then ASSERT().
3159 @param[in, out] DestinationBuffer The pointer to the pointer to the buffer to append onto.
3160 @param[in, out] DestinationSize The pointer to the size of DestinationBuffer.
3161 @param[in] SourceBuffer The pointer to the buffer to append onto DestinationBuffer.
3162 @param[in] SourceSize The number of bytes of SourceBuffer to append.
3164 @retval NULL A memory allocation failed.
3165 @retval NULL A parameter was invalid.
3166 @return A pointer to (*DestinationBuffer).
3170 IN OUT VOID
**DestinationBuffer
,
3171 IN OUT UINTN
*DestinationSize
,
3172 IN VOID
*SourceBuffer
,
3176 UINTN LocalDestinationSize
;
3177 UINTN LocalDestinationFinalSize
;
3179 ASSERT(DestinationBuffer
!= NULL
);
3181 if (SourceSize
== 0 || SourceBuffer
== NULL
) {
3182 return (*DestinationBuffer
);
3185 if (DestinationSize
== NULL
) {
3186 LocalDestinationSize
= 0;
3188 LocalDestinationSize
= *DestinationSize
;
3191 LocalDestinationFinalSize
= LocalDestinationSize
+ SourceSize
;
3193 if (DestinationSize
!= NULL
) {
3194 *DestinationSize
= LocalDestinationSize
;
3197 if (LocalDestinationSize
== 0) {
3199 *DestinationBuffer
= AllocateZeroPool(LocalDestinationFinalSize
);
3202 *DestinationBuffer
= ReallocatePool(LocalDestinationSize
, LocalDestinationFinalSize
, *DestinationBuffer
);
3205 ASSERT(*DestinationBuffer
!= NULL
);
3208 return (CopyMem(((UINT8
*)(*DestinationBuffer
)) + LocalDestinationSize
, SourceBuffer
, SourceSize
));
3212 Gets handles for any child devices produced by the passed in driver.
3214 @param[in] DriverHandle The handle of the driver.
3215 @param[in] MatchingHandleCount Pointer to the number of handles in
3216 MatchingHandleBuffer on return.
3217 @param[out] MatchingHandleBuffer Buffer containing handles on a successful
3219 @retval EFI_SUCCESS The operation was sucessful.
3220 @sa ParseHandleDatabaseByRelationship
3224 ParseHandleDatabaseForChildDevices(
3225 IN CONST EFI_HANDLE DriverHandle
,
3226 IN UINTN
*MatchingHandleCount
,
3227 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
3231 EFI_HANDLE
*Buffer2
;
3236 UINTN HandleBufferSize
;
3238 ASSERT(MatchingHandleCount
!= NULL
);
3240 HandleBufferSize
= 0;
3243 *MatchingHandleCount
= 0;
3245 Status
= PARSE_HANDLE_DATABASE_DEVICES (
3250 if (!EFI_ERROR (Status
)) {
3251 for (HandleIndex
= 0; HandleIndex
< Count1
; HandleIndex
++) {
3253 // now find the children
3255 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
3257 Buffer
[HandleIndex
],
3261 if (EFI_ERROR(Status
)) {
3265 // save out required and optional data elements
3267 *MatchingHandleCount
+= Count2
;
3268 if (MatchingHandleBuffer
!= NULL
) {
3269 *MatchingHandleBuffer
= BuffernCatGrow((VOID
**)MatchingHandleBuffer
, &HandleBufferSize
, Buffer2
, Count2
* sizeof(Buffer2
[0]));
3275 if (Buffer2
!= NULL
) {
3281 if (Buffer
!= NULL
) {
3288 Function to get all handles that support a given protocol or all handles.
3290 @param[in] ProtocolGuid The guid of the protocol to get handles for. If NULL
3291 then the function will return all handles.
3293 @retval NULL A memory allocation failed.
3294 @return A NULL terminated list of handles.
3298 GetHandleListByProtocol (
3299 IN CONST EFI_GUID
*ProtocolGuid OPTIONAL
3302 EFI_HANDLE
*HandleList
;
3310 // We cannot use LocateHandleBuffer since we need that NULL item on the ends of the list!
3312 if (ProtocolGuid
== NULL
) {
3313 Status
= gBS
->LocateHandle(AllHandles
, NULL
, NULL
, &Size
, HandleList
);
3314 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3315 HandleList
= AllocateZeroPool(Size
+ sizeof(EFI_HANDLE
));
3316 if (HandleList
== NULL
) {
3319 Status
= gBS
->LocateHandle(AllHandles
, NULL
, NULL
, &Size
, HandleList
);
3320 HandleList
[Size
/sizeof(EFI_HANDLE
)] = NULL
;
3323 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)ProtocolGuid
, NULL
, &Size
, HandleList
);
3324 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3325 HandleList
= AllocateZeroPool(Size
+ sizeof(EFI_HANDLE
));
3326 if (HandleList
== NULL
) {
3329 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)ProtocolGuid
, NULL
, &Size
, HandleList
);
3330 HandleList
[Size
/sizeof(EFI_HANDLE
)] = NULL
;
3333 if (EFI_ERROR(Status
)) {
3334 if (HandleList
!= NULL
) {
3335 FreePool(HandleList
);
3339 return (HandleList
);
3343 Function to get all handles that support some protocols.
3345 @param[in] ProtocolGuids A NULL terminated list of protocol GUIDs.
3347 @retval NULL A memory allocation failed.
3348 @retval NULL ProtocolGuids was NULL.
3349 @return A NULL terminated list of EFI_HANDLEs.
3353 GetHandleListByProtocolList (
3354 IN CONST EFI_GUID
**ProtocolGuids
3357 EFI_HANDLE
*HandleList
;
3362 CONST EFI_GUID
**GuidWalker
;
3363 EFI_HANDLE
*HandleWalker1
;
3364 EFI_HANDLE
*HandleWalker2
;
3368 TotalSize
= sizeof(EFI_HANDLE
);
3370 for (GuidWalker
= ProtocolGuids
; GuidWalker
!= NULL
&& *GuidWalker
!= NULL
; GuidWalker
++,Size
= 0){
3371 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)(*GuidWalker
), NULL
, &Size
, NULL
);
3372 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3378 // No handles were found...
3380 if (TotalSize
== sizeof(EFI_HANDLE
)) {
3384 HandleList
= AllocateZeroPool(TotalSize
);
3385 if (HandleList
== NULL
) {
3390 for (GuidWalker
= ProtocolGuids
; GuidWalker
!= NULL
&& *GuidWalker
!= NULL
; GuidWalker
++){
3391 TempSize
= TotalSize
- Size
;
3392 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)(*GuidWalker
), NULL
, &TempSize
, HandleList
+(Size
/sizeof(EFI_HANDLE
)));
3395 // Allow for missing protocols... Only update the 'used' size upon success.
3397 if (!EFI_ERROR(Status
)) {
3401 ASSERT(HandleList
[(TotalSize
/sizeof(EFI_HANDLE
))-1] == NULL
);
3403 for (HandleWalker1
= HandleList
; HandleWalker1
!= NULL
&& *HandleWalker1
!= NULL
; HandleWalker1
++) {
3404 for (HandleWalker2
= HandleWalker1
+ 1; HandleWalker2
!= NULL
&& *HandleWalker2
!= NULL
; HandleWalker2
++) {
3405 if (*HandleWalker1
== *HandleWalker2
) {
3407 // copy memory back 1 handle width.
3409 CopyMem(HandleWalker2
, HandleWalker2
+ 1, TotalSize
- ((HandleWalker2
-HandleList
+1)*sizeof(EFI_HANDLE
)));
3414 return (HandleList
);
3418 Return all supported GUIDs.
3420 @param[out] Guids The buffer to return all supported GUIDs.
3421 @param[in, out] Count On input, the count of GUIDs the buffer can hold,
3422 On output, the count of GUIDs to return.
3424 @retval EFI_INVALID_PARAMETER Count is NULL.
3425 @retval EFI_BUFFER_TOO_SMALL Buffer is not enough to hold all GUIDs.
3426 @retval EFI_SUCCESS GUIDs are returned successfully.
3430 GetAllMappingGuids (
3431 OUT EFI_GUID
*Guids
,
3439 if (Count
== NULL
) {
3440 return EFI_INVALID_PARAMETER
;
3444 if (PcdGetBool (PcdShellIncludeNtGuids
)) {
3445 NtGuidCount
= ARRAY_SIZE (mGuidStringListNT
) - 1;
3447 GuidCount
= ARRAY_SIZE (mGuidStringList
) - 1;
3449 if (*Count
< NtGuidCount
+ GuidCount
+ mGuidListCount
) {
3450 *Count
= NtGuidCount
+ GuidCount
+ mGuidListCount
;
3451 return EFI_BUFFER_TOO_SMALL
;
3454 for (Index
= 0; Index
< NtGuidCount
; Index
++) {
3455 CopyGuid (&Guids
[Index
], mGuidStringListNT
[Index
].GuidId
);
3458 for (Index
= 0; Index
< GuidCount
; Index
++) {
3459 CopyGuid (&Guids
[NtGuidCount
+ Index
], mGuidStringList
[Index
].GuidId
);
3462 for (Index
= 0; Index
< mGuidListCount
; Index
++) {
3463 CopyGuid (&Guids
[NtGuidCount
+ GuidCount
+ Index
], mGuidList
[Index
].GuidId
);