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"
19 #include "IndustryStandard/Pci.h"
21 #include <Protocol/FirmwareVolume2.h>
23 EFI_HANDLE mHandleParsingHiiHandle
= NULL
;
24 HANDLE_INDEX_LIST mHandleList
= {{{NULL
,NULL
},0,0},0};
25 GUID_INFO_BLOCK
*mGuidList
;
29 Function to find the file name associated with a LoadedImageProtocol.
31 @param[in] LoadedImage An instance of LoadedImageProtocol.
33 @retval A string representation of the file name associated
34 with LoadedImage, or NULL if no name can be found.
37 FindLoadedImageFileName (
38 IN EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
43 EFI_FIRMWARE_VOLUME2_PROTOCOL
*Fv
;
46 UINT32 AuthenticationStatus
;
48 if ((LoadedImage
== NULL
) || (LoadedImage
->FilePath
== NULL
)) {
52 NameGuid
= EfiGetNameGuidFromFwVolDevicePathNode((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
*)LoadedImage
->FilePath
);
54 if (NameGuid
== NULL
) {
59 // Get the FirmwareVolume2Protocol of the device handle that this image was loaded from.
61 Status
= gBS
->HandleProtocol (LoadedImage
->DeviceHandle
, &gEfiFirmwareVolume2ProtocolGuid
, (VOID
**) &Fv
);
64 // FirmwareVolume2Protocol is PI, and is not required to be available.
66 if (EFI_ERROR (Status
)) {
71 // Read the user interface section of the image.
74 Status
= Fv
->ReadSection(Fv
, NameGuid
, EFI_SECTION_USER_INTERFACE
, 0, &Buffer
, &BufferSize
, &AuthenticationStatus
);
76 if (EFI_ERROR (Status
)) {
81 // ReadSection returns just the section data, without any section header. For
82 // a user interface section, the only data is the file name.
88 Function to translate the EFI_MEMORY_TYPE into a string.
90 @param[in] Memory The memory type.
92 @retval A string representation of the type allocated from BS Pool.
96 IN CONST EFI_MEMORY_TYPE Memory
103 case EfiReservedMemoryType
: StrnCatGrow(&RetVal
, NULL
, L
"EfiReservedMemoryType", 0); break;
104 case EfiLoaderCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiLoaderCode", 0); break;
105 case EfiLoaderData
: StrnCatGrow(&RetVal
, NULL
, L
"EfiLoaderData", 0); break;
106 case EfiBootServicesCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiBootServicesCode", 0); break;
107 case EfiBootServicesData
: StrnCatGrow(&RetVal
, NULL
, L
"EfiBootServicesData", 0); break;
108 case EfiRuntimeServicesCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiRuntimeServicesCode", 0); break;
109 case EfiRuntimeServicesData
: StrnCatGrow(&RetVal
, NULL
, L
"EfiRuntimeServicesData", 0); break;
110 case EfiConventionalMemory
: StrnCatGrow(&RetVal
, NULL
, L
"EfiConventionalMemory", 0); break;
111 case EfiUnusableMemory
: StrnCatGrow(&RetVal
, NULL
, L
"EfiUnusableMemory", 0); break;
112 case EfiACPIReclaimMemory
: StrnCatGrow(&RetVal
, NULL
, L
"EfiACPIReclaimMemory", 0); break;
113 case EfiACPIMemoryNVS
: StrnCatGrow(&RetVal
, NULL
, L
"EfiACPIMemoryNVS", 0); break;
114 case EfiMemoryMappedIO
: StrnCatGrow(&RetVal
, NULL
, L
"EfiMemoryMappedIO", 0); break;
115 case EfiMemoryMappedIOPortSpace
: StrnCatGrow(&RetVal
, NULL
, L
"EfiMemoryMappedIOPortSpace", 0); break;
116 case EfiPalCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiPalCode", 0); break;
117 case EfiMaxMemoryType
: StrnCatGrow(&RetVal
, NULL
, L
"EfiMaxMemoryType", 0); break;
118 default: ASSERT(FALSE
);
124 Function to translate the EFI_GRAPHICS_PIXEL_FORMAT into a string.
126 @param[in] Fmt The format type.
128 @retval A string representation of the type allocated from BS Pool.
132 IN CONST EFI_GRAPHICS_PIXEL_FORMAT Fmt
139 case PixelRedGreenBlueReserved8BitPerColor
: StrnCatGrow(&RetVal
, NULL
, L
"PixelRedGreenBlueReserved8BitPerColor", 0); break;
140 case PixelBlueGreenRedReserved8BitPerColor
: StrnCatGrow(&RetVal
, NULL
, L
"PixelBlueGreenRedReserved8BitPerColor", 0); break;
141 case PixelBitMask
: StrnCatGrow(&RetVal
, NULL
, L
"PixelBitMask", 0); break;
142 case PixelBltOnly
: StrnCatGrow(&RetVal
, NULL
, L
"PixelBltOnly", 0); break;
143 case PixelFormatMax
: StrnCatGrow(&RetVal
, NULL
, L
"PixelFormatMax", 0); break;
144 default: ASSERT(FALSE
);
150 Constructor for the library.
152 @param[in] ImageHandle Ignored.
153 @param[in] SystemTable Ignored.
155 @retval EFI_SUCCESS The operation was successful.
159 HandleParsingLibConstructor (
160 IN EFI_HANDLE ImageHandle
,
161 IN EFI_SYSTEM_TABLE
*SystemTable
168 // Do nothing with mHandleParsingHiiHandle. Initialize HII as needed.
170 return (EFI_SUCCESS
);
174 Initialization function for HII packages.
178 HandleParsingHiiInit (VOID
)
180 if (mHandleParsingHiiHandle
== NULL
) {
181 mHandleParsingHiiHandle
= HiiAddPackages (&gHandleParsingHiiGuid
, gImageHandle
, UefiHandleParsingLibStrings
, NULL
);
182 ASSERT (mHandleParsingHiiHandle
!= NULL
);
187 Destructor for the library. free any resources.
189 @param[in] ImageHandle Ignored.
190 @param[in] SystemTable Ignored.
192 @retval EFI_SUCCESS The operation was successful.
196 HandleParsingLibDestructor (
197 IN EFI_HANDLE ImageHandle
,
198 IN EFI_SYSTEM_TABLE
*SystemTable
203 for (LoopCount
= 0; mGuidList
!= NULL
&& LoopCount
< mGuidListCount
; LoopCount
++) {
204 SHELL_FREE_NON_NULL(mGuidList
[LoopCount
].GuidId
);
207 SHELL_FREE_NON_NULL(mGuidList
);
208 if (mHandleParsingHiiHandle
!= NULL
) {
209 HiiRemovePackages(mHandleParsingHiiHandle
);
211 return (EFI_SUCCESS
);
215 Function to dump information about LoadedImage.
217 This will allocate the return buffer from boot services pool.
219 @param[in] TheHandle The handle that has LoadedImage installed.
220 @param[in] Verbose TRUE for additional information, FALSE otherwise.
222 @retval A poitner to a string containing the information.
226 LoadedImageProtocolDumpInformation(
227 IN CONST EFI_HANDLE TheHandle
,
228 IN CONST BOOLEAN Verbose
231 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
241 Status
= gBS
->OpenProtocol (
243 &gEfiLoadedImageProtocolGuid
,
244 (VOID
**)&LoadedImage
,
247 EFI_OPEN_PROTOCOL_GET_PROTOCOL
250 if (EFI_ERROR (Status
)) {
254 FileName
= FindLoadedImageFileName(LoadedImage
);
255 FilePath
= ConvertDevicePathToText(LoadedImage
->FilePath
, TRUE
, TRUE
);
257 if (FileName
== NULL
) {
260 SHELL_FREE_NON_NULL(FilePath
);
265 HandleParsingHiiInit();
267 if (FileName
!= NULL
) {
268 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_LI_DUMP_NAME
), NULL
);
271 RetVal
= CatSPrint(NULL
, Temp
, FileName
);
274 SHELL_FREE_NON_NULL(Temp
);
275 SHELL_FREE_NON_NULL(FileName
);
278 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_LI_DUMP_MAIN
), NULL
);
282 PdbFileName
= PeCoffLoaderGetPdbPointer (LoadedImage
->ImageBase
);
283 DataType
= ConvertMemoryType(LoadedImage
->ImageDataType
);
284 CodeType
= ConvertMemoryType(LoadedImage
->ImageCodeType
);
289 LoadedImage
->Revision
,
290 LoadedImage
->ParentHandle
,
291 LoadedImage
->SystemTable
,
292 LoadedImage
->DeviceHandle
,
295 LoadedImage
->LoadOptionsSize
,
296 LoadedImage
->LoadOptions
,
297 LoadedImage
->ImageBase
,
298 LoadedImage
->ImageSize
,
305 SHELL_FREE_NON_NULL(Temp
);
306 SHELL_FREE_NON_NULL(FilePath
);
307 SHELL_FREE_NON_NULL(CodeType
);
308 SHELL_FREE_NON_NULL(DataType
);
314 Function to dump information about GOP.
316 This will allocate the return buffer from boot services pool.
318 @param[in] TheHandle The handle that has LoadedImage installed.
319 @param[in] Verbose TRUE for additional information, FALSE otherwise.
321 @retval A poitner to a string containing the information.
325 GraphicsOutputProtocolDumpInformation(
326 IN CONST EFI_HANDLE TheHandle
,
327 IN CONST BOOLEAN Verbose
330 EFI_GRAPHICS_OUTPUT_PROTOCOL
*GraphicsOutput
;
338 EFI_GRAPHICS_OUTPUT_MODE_INFORMATION
*GopInfo
;
341 return (CatSPrint(NULL
, L
"GraphicsOutput"));
344 HandleParsingHiiInit();
346 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_GOP_DUMP_MAIN
), NULL
);
351 Status
= gBS
->OpenProtocol (
353 &gEfiGraphicsOutputProtocolGuid
,
354 (VOID
**)&GraphicsOutput
,
357 EFI_OPEN_PROTOCOL_GET_PROTOCOL
360 if (EFI_ERROR (Status
)) {
361 SHELL_FREE_NON_NULL (Temp
);
365 Fmt
= ConvertPixelFormat(GraphicsOutput
->Mode
->Info
->PixelFormat
);
370 GraphicsOutput
->Mode
->MaxMode
,
371 GraphicsOutput
->Mode
->Mode
,
372 GraphicsOutput
->Mode
->FrameBufferBase
,
373 (UINT64
)GraphicsOutput
->Mode
->FrameBufferSize
,
374 (UINT64
)GraphicsOutput
->Mode
->SizeOfInfo
,
375 GraphicsOutput
->Mode
->Info
->Version
,
376 GraphicsOutput
->Mode
->Info
->HorizontalResolution
,
377 GraphicsOutput
->Mode
->Info
->VerticalResolution
,
379 GraphicsOutput
->Mode
->Info
->PixelsPerScanLine
,
380 GraphicsOutput
->Mode
->Info
->PixelFormat
!=PixelBitMask
?0:GraphicsOutput
->Mode
->Info
->PixelInformation
.RedMask
,
381 GraphicsOutput
->Mode
->Info
->PixelFormat
!=PixelBitMask
?0:GraphicsOutput
->Mode
->Info
->PixelInformation
.GreenMask
,
382 GraphicsOutput
->Mode
->Info
->PixelFormat
!=PixelBitMask
?0:GraphicsOutput
->Mode
->Info
->PixelInformation
.BlueMask
385 SHELL_FREE_NON_NULL (Temp
);
387 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_GOP_RES_LIST_MAIN
), NULL
);
389 SHELL_FREE_NON_NULL (RetVal
);
393 TempRetVal
= CatSPrint (RetVal
, Temp
);
394 SHELL_FREE_NON_NULL (RetVal
);
395 if (TempRetVal
== NULL
) {
399 SHELL_FREE_NON_NULL (Temp
);
401 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_GOP_RES_LIST_ENTRY
), NULL
);
403 SHELL_FREE_NON_NULL (RetVal
);
408 for (Mode
= 0; Mode
< GraphicsOutput
->Mode
->MaxMode
; Mode
++) {
409 Status
= GraphicsOutput
->QueryMode (
415 if (EFI_ERROR (Status
)) {
419 TempRetVal
= CatSPrint (
423 GopInfo
->HorizontalResolution
,
424 GopInfo
->VerticalResolution
427 SHELL_FREE_NON_NULL (GopInfo
);
428 SHELL_FREE_NON_NULL (RetVal
);
434 SHELL_FREE_NON_NULL(Temp
);
435 SHELL_FREE_NON_NULL(Fmt
);
441 Function to dump information about EDID Discovered Protocol.
443 This will allocate the return buffer from boot services pool.
445 @param[in] TheHandle The handle that has LoadedImage installed.
446 @param[in] Verbose TRUE for additional information, FALSE otherwise.
448 @retval A pointer to a string containing the information.
452 EdidDiscoveredProtocolDumpInformation (
453 IN CONST EFI_HANDLE TheHandle
,
454 IN CONST BOOLEAN Verbose
457 EFI_EDID_DISCOVERED_PROTOCOL
*EdidDiscovered
;
464 return (CatSPrint (NULL
, L
"EDIDDiscovered"));
467 Status
= gBS
->OpenProtocol (
469 &gEfiEdidDiscoveredProtocolGuid
,
470 (VOID
**)&EdidDiscovered
,
473 EFI_OPEN_PROTOCOL_GET_PROTOCOL
476 if (EFI_ERROR (Status
)) {
480 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_DISCOVERED_MAIN
), NULL
);
485 RetVal
= CatSPrint (NULL
, Temp
, EdidDiscovered
->SizeOfEdid
);
486 SHELL_FREE_NON_NULL (Temp
);
488 if (EdidDiscovered
->SizeOfEdid
!= 0) {
489 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_DISCOVERED_DATA
), NULL
);
491 SHELL_FREE_NON_NULL (RetVal
);
494 TempRetVal
= CatSPrint (RetVal
, Temp
);
495 SHELL_FREE_NON_NULL (RetVal
);
498 TempRetVal
= CatSDumpHex (RetVal
, 4, 0, EdidDiscovered
->SizeOfEdid
, EdidDiscovered
->Edid
);
505 Function to dump information about EDID Active Protocol.
507 This will allocate the return buffer from boot services pool.
509 @param[in] TheHandle The handle that has LoadedImage installed.
510 @param[in] Verbose TRUE for additional information, FALSE otherwise.
512 @retval A pointer to a string containing the information.
516 EdidActiveProtocolDumpInformation (
517 IN CONST EFI_HANDLE TheHandle
,
518 IN CONST BOOLEAN Verbose
521 EFI_EDID_ACTIVE_PROTOCOL
*EdidActive
;
528 return (CatSPrint (NULL
, L
"EDIDActive"));
531 Status
= gBS
->OpenProtocol (
533 &gEfiEdidActiveProtocolGuid
,
537 EFI_OPEN_PROTOCOL_GET_PROTOCOL
540 if (EFI_ERROR (Status
)) {
544 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_ACTIVE_MAIN
), NULL
);
549 RetVal
= CatSPrint (NULL
, Temp
, EdidActive
->SizeOfEdid
);
550 SHELL_FREE_NON_NULL (Temp
);
552 if (EdidActive
->SizeOfEdid
!= 0) {
553 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_ACTIVE_DATA
), NULL
);
555 SHELL_FREE_NON_NULL (RetVal
);
558 TempRetVal
= CatSPrint (RetVal
, Temp
);
559 SHELL_FREE_NON_NULL (RetVal
);
562 TempRetVal
= CatSDumpHex (RetVal
, 4, 0, EdidActive
->SizeOfEdid
, EdidActive
->Edid
);
569 Function to dump information about PciRootBridgeIo.
571 This will allocate the return buffer from boot services pool.
573 @param[in] TheHandle The handle that has PciRootBridgeIo installed.
574 @param[in] Verbose TRUE for additional information, FALSE otherwise.
576 @retval A poitner to a string containing the information.
580 PciRootBridgeIoDumpInformation(
581 IN CONST EFI_HANDLE TheHandle
,
582 IN CONST BOOLEAN Verbose
585 EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL
*PciRootBridgeIo
;
586 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR
*Configuration
;
597 return (CatSPrint(NULL
, L
"PciRootBridgeIo"));
600 HandleParsingHiiInit();
602 Status
= gBS
->HandleProtocol(
604 &gEfiPciRootBridgeIoProtocolGuid
,
605 (VOID
**)&PciRootBridgeIo
);
607 if (EFI_ERROR(Status
)) {
611 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_PH
), NULL
);
615 Temp2
= CatSPrint(NULL
, Temp
, PciRootBridgeIo
->ParentHandle
);
620 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_SEG
), NULL
);
622 SHELL_FREE_NON_NULL(RetVal
);
625 Temp2
= CatSPrint(RetVal
, Temp
, PciRootBridgeIo
->SegmentNumber
);
633 Status
= PciRootBridgeIo
->GetAttributes (PciRootBridgeIo
, &Supports
, &Attributes
);
634 if (!EFI_ERROR(Status
)) {
635 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_ATT
), NULL
);
637 SHELL_FREE_NON_NULL(RetVal
);
640 Temp2
= CatSPrint(RetVal
, Temp
, Attributes
);
646 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_SUPPORTS
), NULL
);
648 SHELL_FREE_NON_NULL(RetVal
);
651 Temp2
= CatSPrint(RetVal
, Temp
, Supports
);
658 Configuration
= NULL
;
659 Status
= PciRootBridgeIo
->Configuration (PciRootBridgeIo
, (VOID
**) &Configuration
);
660 if (!EFI_ERROR(Status
) && Configuration
!= NULL
) {
661 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_TITLE
), NULL
);
663 SHELL_FREE_NON_NULL(RetVal
);
666 Temp2
= CatSPrint(RetVal
, Temp
, Supports
);
671 while (Configuration
->Desc
== ACPI_ADDRESS_SPACE_DESCRIPTOR
) {
673 switch (Configuration
->ResType
) {
674 case ACPI_ADDRESS_SPACE_TYPE_MEM
:
675 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_MEM
), NULL
);
677 case ACPI_ADDRESS_SPACE_TYPE_IO
:
678 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_IO
), NULL
);
680 case ACPI_ADDRESS_SPACE_TYPE_BUS
:
681 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_BUS
), NULL
);
685 Temp2
= CatSPrint(RetVal
, L
"\r\n%s", Temp
);
692 Temp2
= CatSPrint(RetVal
,
693 L
"%%H%02x %016lx %016lx %02x%%N",
694 Configuration
->SpecificFlag
,
695 Configuration
->AddrRangeMin
,
696 Configuration
->AddrRangeMax
,
697 Configuration
->AddrSpaceGranularity
709 Function to dump information about SimpleTextOut.
711 This will allocate the return buffer from boot services pool.
713 @param[in] TheHandle The handle that has SimpleTextOut installed.
714 @param[in] Verbose TRUE for additional information, FALSE otherwise.
716 @retval A poitner to a string containing the information.
720 TxtOutProtocolDumpInformation(
721 IN CONST EFI_HANDLE TheHandle
,
722 IN CONST BOOLEAN Verbose
725 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL
*Dev
;
739 HandleParsingHiiInit();
744 Status
= gBS
->HandleProtocol(
746 &gEfiSimpleTextOutProtocolGuid
,
749 ASSERT_EFI_ERROR(Status
);
750 ASSERT (Dev
!= NULL
&& Dev
->Mode
!= NULL
);
752 Size
= (Dev
->Mode
->MaxMode
+ 1) * 80;
753 RetVal
= AllocateZeroPool(Size
);
755 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_TXT_OUT_DUMP_HEADER
), NULL
);
757 UnicodeSPrint(RetVal
, Size
, Temp
, Dev
, Dev
->Mode
->Attribute
);
764 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_TXT_OUT_DUMP_LINE
), NULL
);
765 for (Index
= 0; Index
< Dev
->Mode
->MaxMode
; Index
++) {
766 Status
= Dev
->QueryMode (Dev
, Index
, &Col
, &Row
);
767 NewSize
= Size
- StrSize(RetVal
);
769 RetVal
+ StrLen(RetVal
),
771 Temp
== NULL
?L
"":Temp
,
772 Index
== Dev
->Mode
->Mode
? L
'*' : L
' ',
774 !EFI_ERROR(Status
)?(INTN
)Col
:-1,
775 !EFI_ERROR(Status
)?(INTN
)Row
:-1
782 STATIC CONST UINTN VersionStringSize
= 60;
785 Function to dump information about EfiDriverSupportedEfiVersion protocol.
787 This will allocate the return buffer from boot services pool.
789 @param[in] TheHandle The handle that has the protocol installed.
790 @param[in] Verbose TRUE for additional information, FALSE otherwise.
792 @retval A poitner to a string containing the information.
796 DriverEfiVersionProtocolDumpInformation(
797 IN CONST EFI_HANDLE TheHandle
,
798 IN CONST BOOLEAN Verbose
801 EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL
*DriverEfiVersion
;
805 Status
= gBS
->HandleProtocol(
807 &gEfiDriverSupportedEfiVersionProtocolGuid
,
808 (VOID
**)&DriverEfiVersion
);
810 ASSERT_EFI_ERROR(Status
);
812 RetVal
= AllocateZeroPool(VersionStringSize
);
813 if (RetVal
!= NULL
) {
814 UnicodeSPrint (RetVal
, VersionStringSize
, L
"0x%08x", DriverEfiVersion
->FirmwareVersion
);
819 Function to convert device path to string.
821 This will allocate the return buffer from boot services pool.
823 @param[in] DevPath Pointer to device path instance.
824 @param[in] Verbose TRUE for additional information, FALSE otherwise.
825 @param[in] Length Maximum allowed text length of the device path.
827 @retval A pointer to a string containing the information.
830 ConvertDevicePathToShortText(
831 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevPath
,
832 IN CONST BOOLEAN Verbose
,
833 IN CONST UINTN Length
841 // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)
843 Temp
= ConvertDevicePathToText(DevPath
, TRUE
, TRUE
);
844 if (!Verbose
&& Temp
!= NULL
&& StrLen(Temp
) > Length
) {
847 Temp2
= StrnCatGrow(&Temp2
, &Size
, L
"..", 0);
848 Temp2
= StrnCatGrow(&Temp2
, &Size
, Temp
+(StrLen(Temp
) - (Length
- 2)), 0);
856 Function to dump protocol information.
858 This will allocate the return buffer from boot services pool.
860 @param[in] TheHandle The handle that has the protocol installed.
861 @param[in] Verbose TRUE for additional information, FALSE otherwise.
862 @param[in] Protocol The protocol is needed to dump.
864 @retval A pointer to a string containing the information.
868 DevicePathProtocolDumpInformationEx (
869 IN CONST EFI_HANDLE TheHandle
,
870 IN CONST BOOLEAN Verbose
,
871 IN EFI_GUID
*Protocol
874 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
876 CHAR16
*DevPathStrTemp
;
880 DevPathStrTemp
= NULL
;
881 Status
= gBS
->OpenProtocol(TheHandle
, Protocol
, (VOID
**)&DevPath
, gImageHandle
, NULL
, EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
882 if (!EFI_ERROR(Status
)) {
883 DevPathStr
= ConvertDevicePathToShortText (DevPath
, Verbose
, 30);
885 Size
= StrSize(DevPathStr
) + sizeof(CHAR16
) * 2;
886 DevPathStrTemp
= AllocateZeroPool (Size
);
887 if (DevPathStrTemp
!= NULL
) {
888 StrnCatS (DevPathStrTemp
, Size
/sizeof(CHAR16
), L
" ", 2);
889 StrnCatS (DevPathStrTemp
, Size
/sizeof(CHAR16
), DevPathStr
, StrLen (DevPathStr
));
891 FreePool (DevPathStr
);
892 DevPathStr
= DevPathStrTemp
;
894 gBS
->CloseProtocol(TheHandle
, Protocol
, gImageHandle
, NULL
);
900 Function to dump information about DevicePath protocol.
902 This will allocate the return buffer from boot services pool.
904 @param[in] TheHandle The handle that has the protocol installed.
905 @param[in] Verbose TRUE for additional information, FALSE otherwise.
907 @retval A pointer to a string containing the information.
911 DevicePathProtocolDumpInformation(
912 IN CONST EFI_HANDLE TheHandle
,
913 IN CONST BOOLEAN Verbose
916 return DevicePathProtocolDumpInformationEx (TheHandle
, Verbose
, &gEfiDevicePathProtocolGuid
);
920 Function to dump information about LoadedImageDevicePath protocol.
922 This will allocate the return buffer from boot services pool.
924 @param[in] TheHandle The handle that has the protocol installed.
925 @param[in] Verbose TRUE for additional information, FALSE otherwise.
927 @retval A pointer to a string containing the information.
931 LoadedImageDevicePathProtocolDumpInformation(
932 IN CONST EFI_HANDLE TheHandle
,
933 IN CONST BOOLEAN Verbose
936 return DevicePathProtocolDumpInformationEx (TheHandle
, Verbose
, &gEfiLoadedImageDevicePathProtocolGuid
);
940 Function to dump information about BusSpecificDriverOverride protocol.
942 This will allocate the return buffer from boot services pool.
944 @param[in] TheHandle The handle that has the protocol installed.
945 @param[in] Verbose TRUE for additional information, FALSE otherwise.
947 @retval A pointer to a string containing the information.
951 BusSpecificDriverOverrideProtocolDumpInformation (
952 IN CONST EFI_HANDLE TheHandle
,
953 IN CONST BOOLEAN Verbose
960 EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL
*BusSpecificDriverOverride
;
961 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
962 EFI_HANDLE ImageHandle
;
974 Status
= gBS
->OpenProtocol (
976 &gEfiBusSpecificDriverOverrideProtocolGuid
,
977 (VOID
**)&BusSpecificDriverOverride
,
980 EFI_OPEN_PROTOCOL_GET_PROTOCOL
982 if (EFI_ERROR (Status
)) {
985 HandleParsingHiiInit ();
986 GetString
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_BSDO_DUMP_MAIN
), NULL
);
987 if (GetString
== NULL
) {
991 Status
= BusSpecificDriverOverride
->GetDriver (
992 BusSpecificDriverOverride
,
995 if (!EFI_ERROR (Status
)) {
996 Status
= gBS
->HandleProtocol (
998 &gEfiLoadedImageProtocolGuid
,
999 (VOID
**) &LoadedImage
1001 if(!EFI_ERROR (Status
)) {
1002 TempRetVal
= CatSPrint (
1005 ConvertHandleToHandleIndex (ImageHandle
),
1006 ConvertDevicePathToText (LoadedImage
->FilePath
, TRUE
, TRUE
)
1008 StrnCatGrow (&RetVal
, &Size
, TempRetVal
, 0);
1009 SHELL_FREE_NON_NULL (TempRetVal
);
1012 } while (!EFI_ERROR (Status
));
1014 SHELL_FREE_NON_NULL (GetString
);
1019 Function to dump information about BlockIo protocol.
1021 This will allocate the return buffer from boot services pool.
1023 @param[in] TheHandle The handle that has the protocol installed.
1024 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1026 @retval A pointer to a string containing the information.
1030 BlockIoProtocolDumpInformation (
1031 IN CONST EFI_HANDLE TheHandle
,
1032 IN CONST BOOLEAN Verbose
1036 EFI_BLOCK_IO_PROTOCOL
*BlockIo
;
1037 EFI_BLOCK_IO_MEDIA
*BlockMedia
;
1047 Status
= gBS
->OpenProtocol (
1049 &gEfiBlockIoProtocolGuid
,
1053 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1055 if (EFI_ERROR (Status
)) {
1058 BlockMedia
= BlockIo
->Media
;
1061 // The function (ReadBlocks) must return EFI_NO_MEDIA or
1062 // EFI_MEDIA_CHANGED even if LBA, BufferSize, or Buffer are invalid so the caller can probe
1063 // for changes in media state.
1065 BlockIo
->ReadBlocks (
1067 BlockIo
->Media
->MediaId
,
1073 HandleParsingHiiInit ();
1074 GetString
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_BLOCKIO_INFO
), NULL
);
1075 if (GetString
== NULL
) {
1078 RetVal
= CatSPrint (
1081 BlockMedia
->RemovableMedia
? L
"Removable " : L
"Fixed ",
1082 BlockMedia
->MediaPresent
? L
"" : L
"not-present ",
1083 BlockMedia
->MediaId
,
1084 BlockMedia
->BlockSize
,
1085 BlockMedia
->LastBlock
,
1086 MultU64x32 (BlockMedia
->LastBlock
+ 1, BlockMedia
->BlockSize
),
1087 BlockMedia
->LogicalPartition
? L
"partition" : L
"raw",
1088 BlockMedia
->ReadOnly
? L
"ro" : L
"rw",
1089 BlockMedia
->WriteCaching
? L
"cached" : L
"!cached"
1092 SHELL_FREE_NON_NULL (GetString
);
1097 Function to dump information about DebugSupport Protocol.
1099 @param[in] TheHandle The handle that has the protocol installed.
1100 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1102 @retval A pointer to a string containing the information.
1106 DebugSupportProtocolDumpInformation (
1107 IN CONST EFI_HANDLE TheHandle
,
1108 IN CONST BOOLEAN Verbose
1112 EFI_DEBUG_SUPPORT_PROTOCOL
*DebugSupport
;
1121 Status
= gBS
->OpenProtocol (
1123 &gEfiDebugSupportProtocolGuid
,
1124 (VOID
**)&DebugSupport
,
1127 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1129 if (EFI_ERROR (Status
)) {
1132 HandleParsingHiiInit ();
1133 GetString
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_DEBUGSUPPORT_INFO
), NULL
);
1134 if (GetString
== NULL
) {
1138 // Dump Debug support info
1140 switch (DebugSupport
->Isa
) {
1142 RetVal
= CatSPrint (RetVal
, GetString
, L
"IA-32");
1145 RetVal
= CatSPrint (RetVal
, GetString
, L
"IPF");
1148 RetVal
= CatSPrint (RetVal
, GetString
, L
"EBC");
1151 SHELL_FREE_NON_NULL (GetString
);
1152 GetString
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_DEBUGSUPPORT_UNKNOWN
), NULL
);
1153 RetVal
= GetString
!= NULL
? CatSPrint (RetVal
, GetString
, DebugSupport
->Isa
) : NULL
;
1157 SHELL_FREE_NON_NULL (GetString
);
1162 Function to dump information about PciIoProtocol.
1164 This will allocate the return buffer from boot services pool.
1166 @param[in] TheHandle The handle that has PciRootBridgeIo installed.
1167 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1169 @retval A poitner to a string containing the information.
1173 PciIoProtocolDumpInformation (
1174 IN CONST EFI_HANDLE TheHandle
,
1175 IN CONST BOOLEAN Verbose
1179 EFI_PCI_IO_PROTOCOL
*PciIo
;
1196 Status
= gBS
->OpenProtocol (
1198 &gEfiPciIoProtocolGuid
,
1202 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1205 if (EFI_ERROR(Status
)) {
1208 PciIo
->Pci
.Read (PciIo
, EfiPciIoWidthUint8
, 0, sizeof (Pci
), &Pci
);
1209 PciIo
->GetLocation (PciIo
, &Segment
, &Bus
, &Device
, &Function
);
1210 HandleParsingHiiInit ();
1211 GetString
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIIO_DUMP_MAIN
), NULL
);
1212 if (GetString
== NULL
) {
1215 RetVal
= CatSPrint (
1226 Pci
.Hdr
.ClassCode
[0],
1227 Pci
.Hdr
.ClassCode
[1],
1228 Pci
.Hdr
.ClassCode
[2]
1230 for (Index
= 0; Index
< sizeof (Pci
); Index
++) {
1231 if ((Index
% 0x10) == 0) {
1232 TempRetVal
= CatSPrint (RetVal
, L
"\r\n %02x", *((UINT8
*) (&Pci
) + Index
));
1234 TempRetVal
= CatSPrint (RetVal
, L
"%02x", *((UINT8
*) (&Pci
) + Index
));
1237 RetVal
= TempRetVal
;
1241 FreePool(GetString
);
1246 Function to dump information about UsbIoProtocol.
1248 This will allocate the return buffer from boot services pool.
1250 @param[in] TheHandle The handle that has PciRootBridgeIo installed.
1251 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1253 @retval A poitner to a string containing the information.
1257 UsbIoProtocolDumpInformation (
1258 IN CONST EFI_HANDLE TheHandle
,
1259 IN CONST BOOLEAN Verbose
1263 EFI_USB_IO_PROTOCOL
*UsbIo
;
1264 EFI_USB_INTERFACE_DESCRIPTOR InterfaceDesc
;
1273 Status
= gBS
->OpenProtocol (
1275 &gEfiUsbIoProtocolGuid
,
1279 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1282 if (EFI_ERROR(Status
)) {
1285 UsbIo
->UsbGetInterfaceDescriptor (UsbIo
, &InterfaceDesc
);
1286 HandleParsingHiiInit ();
1287 GetString
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_USBIO_DUMP_MAIN
), NULL
);
1288 if (GetString
== NULL
) {
1291 RetVal
= CatSPrint (
1294 InterfaceDesc
.InterfaceNumber
,
1295 InterfaceDesc
.InterfaceClass
,
1296 InterfaceDesc
.InterfaceSubClass
,
1297 InterfaceDesc
.InterfaceProtocol
1300 FreePool (GetString
);
1305 Function to dump information about EfiAdapterInformation Protocol.
1307 @param[in] TheHandle The handle that has the protocol installed.
1308 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1310 @retval A pointer to a string containing the information.
1314 AdapterInformationDumpInformation (
1315 IN CONST EFI_HANDLE TheHandle
,
1316 IN CONST BOOLEAN Verbose
1320 EFI_ADAPTER_INFORMATION_PROTOCOL
*EfiAdptrInfoProtocol
;
1321 UINTN InfoTypesBufferCount
;
1323 EFI_GUID
*InfoTypesBuffer
;
1328 VOID
*InformationBlock
;
1329 UINTN InformationBlockSize
;
1332 return (CatSPrint(NULL
, L
"AdapterInfo"));
1335 InfoTypesBuffer
= NULL
;
1336 InformationBlock
= NULL
;
1339 Status
= gBS
->OpenProtocol (
1340 (EFI_HANDLE
) (TheHandle
),
1341 &gEfiAdapterInformationProtocolGuid
,
1342 (VOID
**) &EfiAdptrInfoProtocol
,
1345 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1348 if (EFI_ERROR (Status
)) {
1353 // Get a list of supported information types for this instance of the protocol.
1355 Status
= EfiAdptrInfoProtocol
->GetSupportedTypes (
1356 EfiAdptrInfoProtocol
,
1358 &InfoTypesBufferCount
1361 if (EFI_ERROR (Status
)) {
1362 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GET_SUPP_TYPES_FAILED
), NULL
);
1363 if (TempStr
!= NULL
) {
1364 RetVal
= CatSPrint (NULL
, TempStr
, Status
);
1369 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_SUPP_TYPE_HEADER
), NULL
);
1370 if (TempStr
== NULL
) {
1373 RetVal
= CatSPrint (NULL
, TempStr
);
1374 SHELL_FREE_NON_NULL (TempStr
);
1376 for (GuidIndex
= 0; GuidIndex
< InfoTypesBufferCount
; GuidIndex
++) {
1377 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GUID_NUMBER
), NULL
);
1378 if (TempStr
== NULL
) {
1381 TempRetVal
= CatSPrint (RetVal
, TempStr
, (GuidIndex
+ 1), &InfoTypesBuffer
[GuidIndex
]);
1382 SHELL_FREE_NON_NULL (RetVal
);
1383 RetVal
= TempRetVal
;
1384 SHELL_FREE_NON_NULL (TempStr
);
1386 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GUID_STRING
), NULL
);
1387 if (TempStr
== NULL
) {
1391 if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoMediaStateGuid
)) {
1392 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoMediaStateGuid");
1393 SHELL_FREE_NON_NULL (RetVal
);
1394 RetVal
= TempRetVal
;
1395 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoNetworkBootGuid
)) {
1396 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoNetworkBootGuid");
1397 SHELL_FREE_NON_NULL (RetVal
);
1398 RetVal
= TempRetVal
;
1399 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoSanMacAddressGuid
)) {
1400 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoSanMacAddressGuid");
1401 SHELL_FREE_NON_NULL (RetVal
);
1402 RetVal
= TempRetVal
;
1403 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoUndiIpv6SupportGuid
)) {
1404 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoUndiIpv6SupportGuid");
1405 SHELL_FREE_NON_NULL (RetVal
);
1406 RetVal
= TempRetVal
;
1409 GuidStr
= GetStringNameFromGuid (&InfoTypesBuffer
[GuidIndex
], NULL
);
1410 if (GuidStr
== NULL
) {
1411 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"UnknownInfoType");
1412 SHELL_FREE_NON_NULL (RetVal
);
1413 RetVal
= TempRetVal
;
1415 SHELL_FREE_NON_NULL (TempStr
);
1416 SHELL_FREE_NON_NULL(GuidStr
);
1418 // So that we never have to pass this UnknownInfoType to the parsing function "GetInformation" service of AIP
1422 TempRetVal
= CatSPrint (RetVal
, TempStr
, GuidStr
);
1423 SHELL_FREE_NON_NULL (RetVal
);
1424 RetVal
= TempRetVal
;
1425 SHELL_FREE_NON_NULL(GuidStr
);
1429 SHELL_FREE_NON_NULL (TempStr
);
1431 Status
= EfiAdptrInfoProtocol
->GetInformation (
1432 EfiAdptrInfoProtocol
,
1433 &InfoTypesBuffer
[GuidIndex
],
1435 &InformationBlockSize
1438 if (EFI_ERROR (Status
)) {
1439 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GETINFO_FAILED
), NULL
);
1440 if (TempStr
== NULL
) {
1443 TempRetVal
= CatSPrint (RetVal
, TempStr
, Status
);
1444 SHELL_FREE_NON_NULL (RetVal
);
1445 RetVal
= TempRetVal
;
1447 if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoMediaStateGuid
)) {
1448 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_MEDIA_STATE
), NULL
);
1449 if (TempStr
== NULL
) {
1452 TempRetVal
= CatSPrint (
1455 ((EFI_ADAPTER_INFO_MEDIA_STATE
*)InformationBlock
)->MediaState
,
1456 ((EFI_ADAPTER_INFO_MEDIA_STATE
*)InformationBlock
)->MediaState
1458 SHELL_FREE_NON_NULL (RetVal
);
1459 RetVal
= TempRetVal
;
1460 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoNetworkBootGuid
)) {
1461 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_NETWORK_BOOT_INFO
), NULL
);
1462 if (TempStr
== NULL
) {
1465 TempRetVal
= CatSPrint (
1468 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv4BootCapablity
,
1469 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv6BootCapablity
,
1470 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->FCoeBootCapablity
,
1471 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->OffloadCapability
,
1472 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiMpioCapability
,
1473 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv4Boot
,
1474 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv6Boot
,
1475 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->FCoeBoot
1477 SHELL_FREE_NON_NULL (RetVal
);
1478 RetVal
= TempRetVal
;
1479 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoSanMacAddressGuid
) == TRUE
) {
1480 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_SAN_MAC_ADDRESS_INFO
), NULL
);
1481 if (TempStr
== NULL
) {
1484 TempRetVal
= CatSPrint (
1487 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[0],
1488 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[1],
1489 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[2],
1490 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[3],
1491 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[4],
1492 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[5]
1494 SHELL_FREE_NON_NULL (RetVal
);
1495 RetVal
= TempRetVal
;
1496 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoUndiIpv6SupportGuid
) == TRUE
) {
1497 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_UNDI_IPV6_INFO
), NULL
);
1498 if (TempStr
== NULL
) {
1502 TempRetVal
= CatSPrint (
1505 ((EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT
*)InformationBlock
)->Ipv6Support
1507 SHELL_FREE_NON_NULL (RetVal
);
1508 RetVal
= TempRetVal
;
1510 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_UNKNOWN_INFO_TYPE
), NULL
);
1511 if (TempStr
== NULL
) {
1514 TempRetVal
= CatSPrint (RetVal
, TempStr
, &InfoTypesBuffer
[GuidIndex
]);
1515 SHELL_FREE_NON_NULL (RetVal
);
1516 RetVal
= TempRetVal
;
1519 SHELL_FREE_NON_NULL (TempStr
);
1520 SHELL_FREE_NON_NULL (InformationBlock
);
1524 SHELL_FREE_NON_NULL (InfoTypesBuffer
);
1528 SHELL_FREE_NON_NULL (RetVal
);
1529 SHELL_FREE_NON_NULL (InfoTypesBuffer
);
1530 SHELL_FREE_NON_NULL (InformationBlock
);
1535 Function to dump information about EFI_FIRMWARE_MANAGEMENT_PROTOCOL Protocol.
1537 @param[in] TheHandle The handle that has the protocol installed.
1538 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1540 @retval A pointer to a string containing the information.
1544 FirmwareManagementDumpInformation (
1545 IN CONST EFI_HANDLE TheHandle
,
1546 IN CONST BOOLEAN Verbose
1550 EFI_FIRMWARE_MANAGEMENT_PROTOCOL
*EfiFwMgmtProtocol
;
1551 EFI_FIRMWARE_IMAGE_DESCRIPTOR
*ImageInfo
;
1552 EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1
*ImageInfoV1
;
1553 EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2
*ImageInfoV2
;
1554 UINT64 AttributeSetting
;
1555 UINTN ImageInfoSize
;
1556 UINTN DescriptorSize
;
1557 UINT32 DescriptorVersion
;
1558 UINT32 PackageVersion
;
1559 UINT8 DescriptorCount
;
1563 CHAR16
*PackageVersionName
;
1567 CHAR16
*AttributeSettingStr
;
1569 BOOLEAN AttributeSupported
;
1572 // Initialize local variables
1576 AttributeSetting
= 0;
1578 AttributeSupported
= FALSE
;
1582 PackageVersionName
= NULL
;
1586 AttributeSettingStr
= NULL
;
1589 return (CatSPrint(NULL
, L
"FirmwareManagement"));
1592 Status
= gBS
->OpenProtocol (
1593 (EFI_HANDLE
) (TheHandle
),
1594 &gEfiFirmwareManagementProtocolGuid
,
1595 (VOID
**) &EfiFwMgmtProtocol
,
1598 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1601 if (EFI_ERROR (Status
)) {
1605 Status
= EfiFwMgmtProtocol
->GetImageInfo (
1616 if (Status
== EFI_BUFFER_TOO_SMALL
) {
1617 ImageInfo
= AllocateZeroPool (ImageInfoSize
);
1619 if (ImageInfo
== NULL
) {
1620 Status
= EFI_OUT_OF_RESOURCES
;
1622 Status
= EfiFwMgmtProtocol
->GetImageInfo (
1635 if (EFI_ERROR (Status
)) {
1640 // Decode Image Descriptor data only if its version is supported
1642 if (DescriptorVersion
<= EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION
) {
1644 if (ImageInfo
== NULL
) {
1648 ImageInfoV1
= (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1
*)ImageInfo
;
1649 ImageInfoV2
= (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2
*)ImageInfo
;
1652 // Set ImageInfoSize in return buffer
1654 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_INFO_SIZE
), NULL
);
1655 if (TempStr
== NULL
) {
1658 RetVal
= CatSPrint (NULL
, TempStr
, ImageInfoSize
);
1659 SHELL_FREE_NON_NULL (TempStr
);
1662 // Set DescriptorVersion in return buffer
1664 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_DESCRIPTOR_VERSION
), NULL
);
1665 if (TempStr
== NULL
) {
1668 TempRetVal
= CatSPrint (RetVal
, TempStr
, DescriptorVersion
);
1669 SHELL_FREE_NON_NULL (RetVal
);
1670 RetVal
= TempRetVal
;
1671 SHELL_FREE_NON_NULL (TempStr
);
1674 // Set DescriptorCount in return buffer
1676 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_DESCRIPTOR_COUNT
), NULL
);
1677 if (TempStr
== NULL
) {
1680 TempRetVal
= CatSPrint (RetVal
, TempStr
, DescriptorCount
);
1681 SHELL_FREE_NON_NULL (RetVal
);
1682 RetVal
= TempRetVal
;
1683 SHELL_FREE_NON_NULL (TempStr
);
1687 // Set DescriptorSize in return buffer
1689 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_DESCRIPTOR_SIZE
), NULL
);
1690 if (TempStr
== NULL
) {
1693 TempRetVal
= CatSPrint (RetVal
, TempStr
, DescriptorSize
);
1694 SHELL_FREE_NON_NULL (RetVal
);
1695 RetVal
= TempRetVal
;
1696 SHELL_FREE_NON_NULL (TempStr
);
1699 // Set PackageVersion in return buffer
1701 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_PACKAGE_VERSION
), NULL
);
1702 if (TempStr
== NULL
) {
1705 TempRetVal
= CatSPrint (RetVal
, TempStr
, PackageVersion
);
1706 SHELL_FREE_NON_NULL (RetVal
);
1707 RetVal
= TempRetVal
;
1708 SHELL_FREE_NON_NULL (TempStr
);
1711 // Set PackageVersionName in return buffer
1713 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_PACKAGE_VERSION_NAME
), NULL
);
1714 if (TempStr
== NULL
) {
1717 TempRetVal
= CatSPrint (RetVal
, TempStr
, PackageVersionName
);
1718 SHELL_FREE_NON_NULL (RetVal
);
1719 RetVal
= TempRetVal
;
1720 SHELL_FREE_NON_NULL (TempStr
);
1722 for (Index
= 0; Index
< DescriptorCount
; Index
++) {
1724 // First check if Attribute is supported
1725 // and generate a string for AttributeSetting field
1727 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1728 AttributeSupported
= FALSE
;
1729 AttributeSetting
= 0;
1730 if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1
) {
1731 if (ImageInfoV1
[Index
].AttributesSupported
!= 0x0) {
1732 AttributeSupported
= TRUE
;
1733 AttributeSetting
= ImageInfoV1
[Index
].AttributesSetting
;
1735 } else if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2
) {
1736 if (ImageInfoV2
[Index
].AttributesSupported
!= 0x0) {
1737 AttributeSupported
= TRUE
;
1738 AttributeSetting
= ImageInfoV2
[Index
].AttributesSetting
;
1741 if (ImageInfo
[Index
].AttributesSupported
!= 0x0) {
1742 AttributeSupported
= TRUE
;
1743 AttributeSetting
= ImageInfo
[Index
].AttributesSetting
;
1747 if (!AttributeSupported
) {
1748 AttributeSettingStr
= CatSPrint (NULL
, L
"None");
1750 AttributeSettingStr
= CatSPrint (NULL
, L
"(");
1752 if ((AttributeSetting
& IMAGE_ATTRIBUTE_IMAGE_UPDATABLE
) != 0x0) {
1753 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_IMAGE_UPDATABLE");
1754 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1755 AttributeSettingStr
= TempRetVal
;
1757 if ((AttributeSetting
& IMAGE_ATTRIBUTE_RESET_REQUIRED
) != 0x0) {
1758 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_RESET_REQUIRED");
1759 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1760 AttributeSettingStr
= TempRetVal
;
1762 if ((AttributeSetting
& IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED
) != 0x0) {
1763 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED");
1764 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1765 AttributeSettingStr
= TempRetVal
;
1767 if ((AttributeSetting
& IMAGE_ATTRIBUTE_IN_USE
) != 0x0) {
1768 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_IN_USE");
1769 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1770 AttributeSettingStr
= TempRetVal
;
1772 if ((AttributeSetting
& IMAGE_ATTRIBUTE_UEFI_IMAGE
) != 0x0) {
1773 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_UEFI_IMAGE");
1774 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1775 AttributeSettingStr
= TempRetVal
;
1777 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" )");
1778 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1779 AttributeSettingStr
= TempRetVal
;
1782 if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1
) {
1783 if (ImageInfoV1
[Index
].ImageIndex
!= 0x0) {
1787 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V1
), NULL
);
1788 if (TempStr
== NULL
) {
1791 TempRetVal
= CatSPrint (
1795 ImageInfoV1
[Index
].ImageIndex
,
1796 &ImageInfoV1
[Index
].ImageTypeId
,
1797 ImageInfoV1
[Index
].ImageId
,
1798 ImageInfoV1
[Index
].ImageIdName
,
1799 ImageInfoV1
[Index
].Version
,
1800 ImageInfoV1
[Index
].VersionName
,
1801 ImageInfoV1
[Index
].Size
,
1802 ImageInfoV1
[Index
].AttributesSupported
,
1803 AttributeSettingStr
,
1804 ImageInfoV1
[Index
].Compatibilities
1806 SHELL_FREE_NON_NULL (RetVal
);
1807 RetVal
= TempRetVal
;
1808 SHELL_FREE_NON_NULL (TempStr
);
1809 } else if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2
) {
1810 if (ImageInfoV2
[Index
].ImageIndex
!= 0x0) {
1814 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V2
), NULL
);
1815 if (TempStr
== NULL
) {
1818 TempRetVal
= CatSPrint (
1822 ImageInfoV2
[Index
].ImageIndex
,
1823 &ImageInfoV2
[Index
].ImageTypeId
,
1824 ImageInfoV2
[Index
].ImageId
,
1825 ImageInfoV2
[Index
].ImageIdName
,
1826 ImageInfoV2
[Index
].Version
,
1827 ImageInfoV2
[Index
].VersionName
,
1828 ImageInfoV2
[Index
].Size
,
1829 ImageInfoV2
[Index
].AttributesSupported
,
1830 AttributeSettingStr
,
1831 ImageInfoV2
[Index
].Compatibilities
,
1832 ImageInfoV2
[Index
].LowestSupportedImageVersion
1834 SHELL_FREE_NON_NULL (RetVal
);
1835 RetVal
= TempRetVal
;
1836 SHELL_FREE_NON_NULL (TempStr
);
1838 if (ImageInfo
[Index
].ImageIndex
!= 0x0) {
1842 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO
), NULL
);
1843 if (TempStr
== NULL
) {
1846 TempRetVal
= CatSPrint (
1850 ImageInfo
[Index
].ImageIndex
,
1851 &ImageInfo
[Index
].ImageTypeId
,
1852 ImageInfo
[Index
].ImageId
,
1853 ImageInfo
[Index
].ImageIdName
,
1854 ImageInfo
[Index
].Version
,
1855 ImageInfo
[Index
].VersionName
,
1856 ImageInfo
[Index
].Size
,
1857 ImageInfo
[Index
].AttributesSupported
,
1858 AttributeSettingStr
,
1859 ImageInfo
[Index
].Compatibilities
,
1860 ImageInfo
[Index
].LowestSupportedImageVersion
,
1861 ImageInfo
[Index
].LastAttemptVersion
,
1862 ImageInfo
[Index
].LastAttemptStatus
,
1863 ImageInfo
[Index
].HardwareInstance
1865 SHELL_FREE_NON_NULL (RetVal
);
1866 RetVal
= TempRetVal
;
1867 SHELL_FREE_NON_NULL (TempStr
);
1872 if (ImageCount
> 0) {
1873 for (Index
=0; Index
<DescriptorCount
; Index
++) {
1874 for (Index1
=Index
+1; Index1
<DescriptorCount
; Index1
++) {
1875 if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1
) {
1876 if (ImageInfoV1
[Index
].ImageId
== ImageInfoV1
[Index1
].ImageId
) {
1879 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1883 } else if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2
) {
1884 if (ImageInfoV2
[Index
].ImageId
== ImageInfoV2
[Index1
].ImageId
) {
1887 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1892 if (ImageInfo
[Index
].ImageId
== ImageInfo
[Index1
].ImageId
) {
1895 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1906 // Check if ImageId with duplicate value was found
1909 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGEID_NON_UNIQUE
), NULL
);
1910 if (TempStr
== NULL
) {
1913 TempRetVal
= CatSPrint (RetVal
, TempStr
);
1914 SHELL_FREE_NON_NULL (RetVal
);
1915 RetVal
= TempRetVal
;
1916 SHELL_FREE_NON_NULL (TempStr
);
1919 SHELL_FREE_NON_NULL (ImageInfo
);
1920 SHELL_FREE_NON_NULL (PackageVersionName
);
1921 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1926 SHELL_FREE_NON_NULL (RetVal
);
1927 SHELL_FREE_NON_NULL (ImageInfo
);
1928 SHELL_FREE_NON_NULL (PackageVersionName
);
1929 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1935 Function to dump information about Partition Information protocol.
1937 This will allocate the return buffer from boot services pool.
1939 @param[in] TheHandle The handle that has the protocol installed.
1940 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1942 @retval A pointer to a string containing the information.
1946 PartitionInfoProtocolDumpInformation (
1947 IN CONST EFI_HANDLE TheHandle
,
1948 IN CONST BOOLEAN Verbose
1952 EFI_PARTITION_INFO_PROTOCOL
*PartitionInfo
;
1953 CHAR16
*PartitionType
;
1954 CHAR16
*EfiSystemPartition
;
1961 Status
= gBS
->OpenProtocol (
1963 &gEfiPartitionInfoProtocolGuid
,
1964 (VOID
**)&PartitionInfo
,
1967 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1969 if (EFI_ERROR (Status
)) {
1973 HandleParsingHiiInit ();
1975 switch (PartitionInfo
->Type
) {
1976 case PARTITION_TYPE_OTHER
:
1977 PartitionType
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_PARTINFO_DUMP_TYPE_OTHER
), NULL
);
1979 case PARTITION_TYPE_MBR
:
1980 PartitionType
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_PARTINFO_DUMP_TYPE_MBR
), NULL
);
1982 case PARTITION_TYPE_GPT
:
1983 PartitionType
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_PARTINFO_DUMP_TYPE_GPT
), NULL
);
1986 PartitionType
= NULL
;
1989 if (PartitionType
== NULL
) {
1993 if (PartitionInfo
->System
== 1) {
1994 EfiSystemPartition
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_PARTINFO_DUMP_EFI_SYS_PART
), NULL
);
1996 EfiSystemPartition
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_PARTINFO_DUMP_NOT_EFI_SYS_PART
), NULL
);
1998 if (EfiSystemPartition
== NULL
) {
1999 SHELL_FREE_NON_NULL (PartitionType
);
2003 RetVal
= CatSPrint (
2010 SHELL_FREE_NON_NULL (EfiSystemPartition
);
2011 SHELL_FREE_NON_NULL (PartitionType
);
2016 // Put the information on the NT32 protocol GUIDs here so we are not dependant on the Nt32Pkg
2018 #define LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID \
2020 0x58c518b1, 0x76f3, 0x11d4, { 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
2023 #define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \
2025 0x96eb4ad6, 0xa32a, 0x11d4, { 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
2028 #define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \
2030 0xc95a93d, 0xa006, 0x11d4, { 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
2032 STATIC CONST EFI_GUID WinNtThunkProtocolGuid
= LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID
;
2033 STATIC CONST EFI_GUID WinNtIoProtocolGuid
= LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID
;
2034 STATIC CONST EFI_GUID WinNtSerialPortGuid
= LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID
;
2037 // Deprecated protocols we dont want to link from IntelFrameworkModulePkg
2039 #define LOCAL_EFI_ISA_IO_PROTOCOL_GUID \
2041 0x7ee2bd44, 0x3da0, 0x11d4, { 0x9a, 0x38, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
2043 #define LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID \
2045 0x64a892dc, 0x5561, 0x4536, { 0x92, 0xc7, 0x79, 0x9b, 0xfc, 0x18, 0x33, 0x55 } \
2047 STATIC CONST EFI_GUID EfiIsaIoProtocolGuid
= LOCAL_EFI_ISA_IO_PROTOCOL_GUID
;
2048 STATIC CONST EFI_GUID EfiIsaAcpiProtocolGuid
= LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID
;
2051 STATIC CONST GUID_INFO_BLOCK mGuidStringListNT
[] = {
2052 {STRING_TOKEN(STR_WINNT_THUNK
), (EFI_GUID
*)&WinNtThunkProtocolGuid
, NULL
},
2053 {STRING_TOKEN(STR_WINNT_DRIVER_IO
), (EFI_GUID
*)&WinNtIoProtocolGuid
, NULL
},
2054 {STRING_TOKEN(STR_WINNT_SERIAL_PORT
), (EFI_GUID
*)&WinNtSerialPortGuid
, NULL
},
2058 STATIC CONST GUID_INFO_BLOCK mGuidStringList
[] = {
2059 {STRING_TOKEN(STR_LOADED_IMAGE
), &gEfiLoadedImageProtocolGuid
, LoadedImageProtocolDumpInformation
},
2060 {STRING_TOKEN(STR_DEVICE_PATH
), &gEfiDevicePathProtocolGuid
, DevicePathProtocolDumpInformation
},
2061 {STRING_TOKEN(STR_IMAGE_PATH
), &gEfiLoadedImageDevicePathProtocolGuid
, LoadedImageDevicePathProtocolDumpInformation
},
2062 {STRING_TOKEN(STR_DEVICE_PATH_UTIL
), &gEfiDevicePathUtilitiesProtocolGuid
, NULL
},
2063 {STRING_TOKEN(STR_DEVICE_PATH_TXT
), &gEfiDevicePathToTextProtocolGuid
, NULL
},
2064 {STRING_TOKEN(STR_DEVICE_PATH_FTXT
), &gEfiDevicePathFromTextProtocolGuid
, NULL
},
2065 {STRING_TOKEN(STR_DEVICE_PATH_PC
), &gEfiPcAnsiGuid
, NULL
},
2066 {STRING_TOKEN(STR_DEVICE_PATH_VT100
), &gEfiVT100Guid
, NULL
},
2067 {STRING_TOKEN(STR_DEVICE_PATH_VT100P
), &gEfiVT100PlusGuid
, NULL
},
2068 {STRING_TOKEN(STR_DEVICE_PATH_VTUTF8
), &gEfiVTUTF8Guid
, NULL
},
2069 {STRING_TOKEN(STR_DRIVER_BINDING
), &gEfiDriverBindingProtocolGuid
, NULL
},
2070 {STRING_TOKEN(STR_PLATFORM_OVERRIDE
), &gEfiPlatformDriverOverrideProtocolGuid
, NULL
},
2071 {STRING_TOKEN(STR_BUS_OVERRIDE
), &gEfiBusSpecificDriverOverrideProtocolGuid
, BusSpecificDriverOverrideProtocolDumpInformation
},
2072 {STRING_TOKEN(STR_DRIVER_DIAG
), &gEfiDriverDiagnosticsProtocolGuid
, NULL
},
2073 {STRING_TOKEN(STR_DRIVER_DIAG2
), &gEfiDriverDiagnostics2ProtocolGuid
, NULL
},
2074 {STRING_TOKEN(STR_DRIVER_CN
), &gEfiComponentNameProtocolGuid
, NULL
},
2075 {STRING_TOKEN(STR_DRIVER_CN2
), &gEfiComponentName2ProtocolGuid
, NULL
},
2076 {STRING_TOKEN(STR_PLAT_DRV_CFG
), &gEfiPlatformToDriverConfigurationProtocolGuid
, NULL
},
2077 {STRING_TOKEN(STR_DRIVER_VERSION
), &gEfiDriverSupportedEfiVersionProtocolGuid
, DriverEfiVersionProtocolDumpInformation
},
2078 {STRING_TOKEN(STR_TXT_IN
), &gEfiSimpleTextInProtocolGuid
, NULL
},
2079 {STRING_TOKEN(STR_TXT_IN_EX
), &gEfiSimpleTextInputExProtocolGuid
, NULL
},
2080 {STRING_TOKEN(STR_TXT_OUT
), &gEfiSimpleTextOutProtocolGuid
, TxtOutProtocolDumpInformation
},
2081 {STRING_TOKEN(STR_SIM_POINTER
), &gEfiSimplePointerProtocolGuid
, NULL
},
2082 {STRING_TOKEN(STR_ABS_POINTER
), &gEfiAbsolutePointerProtocolGuid
, NULL
},
2083 {STRING_TOKEN(STR_SERIAL_IO
), &gEfiSerialIoProtocolGuid
, NULL
},
2084 {STRING_TOKEN(STR_GRAPHICS_OUTPUT
), &gEfiGraphicsOutputProtocolGuid
, GraphicsOutputProtocolDumpInformation
},
2085 {STRING_TOKEN(STR_EDID_DISCOVERED
), &gEfiEdidDiscoveredProtocolGuid
, EdidDiscoveredProtocolDumpInformation
},
2086 {STRING_TOKEN(STR_EDID_ACTIVE
), &gEfiEdidActiveProtocolGuid
, EdidActiveProtocolDumpInformation
},
2087 {STRING_TOKEN(STR_EDID_OVERRIDE
), &gEfiEdidOverrideProtocolGuid
, NULL
},
2088 {STRING_TOKEN(STR_CON_IN
), &gEfiConsoleInDeviceGuid
, NULL
},
2089 {STRING_TOKEN(STR_CON_OUT
), &gEfiConsoleOutDeviceGuid
, NULL
},
2090 {STRING_TOKEN(STR_STD_ERR
), &gEfiStandardErrorDeviceGuid
, NULL
},
2091 {STRING_TOKEN(STR_LOAD_FILE
), &gEfiLoadFileProtocolGuid
, NULL
},
2092 {STRING_TOKEN(STR_LOAD_FILE2
), &gEfiLoadFile2ProtocolGuid
, NULL
},
2093 {STRING_TOKEN(STR_SIMPLE_FILE_SYS
), &gEfiSimpleFileSystemProtocolGuid
, NULL
},
2094 {STRING_TOKEN(STR_TAPE_IO
), &gEfiTapeIoProtocolGuid
, NULL
},
2095 {STRING_TOKEN(STR_DISK_IO
), &gEfiDiskIoProtocolGuid
, NULL
},
2096 {STRING_TOKEN(STR_BLK_IO
), &gEfiBlockIoProtocolGuid
, BlockIoProtocolDumpInformation
},
2097 {STRING_TOKEN(STR_UC
), &gEfiUnicodeCollationProtocolGuid
, NULL
},
2098 {STRING_TOKEN(STR_UC2
), &gEfiUnicodeCollation2ProtocolGuid
, NULL
},
2099 {STRING_TOKEN(STR_PCIRB_IO
), &gEfiPciRootBridgeIoProtocolGuid
, PciRootBridgeIoDumpInformation
},
2100 {STRING_TOKEN(STR_PCI_IO
), &gEfiPciIoProtocolGuid
, PciIoProtocolDumpInformation
},
2101 {STRING_TOKEN(STR_SCSI_PT
), &gEfiScsiPassThruProtocolGuid
, NULL
},
2102 {STRING_TOKEN(STR_SCSI_IO
), &gEfiScsiIoProtocolGuid
, NULL
},
2103 {STRING_TOKEN(STR_SCSI_PT_EXT
), &gEfiExtScsiPassThruProtocolGuid
, NULL
},
2104 {STRING_TOKEN(STR_ISCSI
), &gEfiIScsiInitiatorNameProtocolGuid
, NULL
},
2105 {STRING_TOKEN(STR_USB_IO
), &gEfiUsbIoProtocolGuid
, UsbIoProtocolDumpInformation
},
2106 {STRING_TOKEN(STR_USB_HC
), &gEfiUsbHcProtocolGuid
, NULL
},
2107 {STRING_TOKEN(STR_USB_HC2
), &gEfiUsb2HcProtocolGuid
, NULL
},
2108 {STRING_TOKEN(STR_DEBUG_SUPPORT
), &gEfiDebugSupportProtocolGuid
, DebugSupportProtocolDumpInformation
},
2109 {STRING_TOKEN(STR_DEBUG_PORT
), &gEfiDebugPortProtocolGuid
, NULL
},
2110 {STRING_TOKEN(STR_DECOMPRESS
), &gEfiDecompressProtocolGuid
, NULL
},
2111 {STRING_TOKEN(STR_ACPI_TABLE
), &gEfiAcpiTableProtocolGuid
, NULL
},
2112 {STRING_TOKEN(STR_EBC_INTERPRETER
), &gEfiEbcProtocolGuid
, NULL
},
2113 {STRING_TOKEN(STR_SNP
), &gEfiSimpleNetworkProtocolGuid
, NULL
},
2114 {STRING_TOKEN(STR_NII
), &gEfiNetworkInterfaceIdentifierProtocolGuid
, NULL
},
2115 {STRING_TOKEN(STR_NII_31
), &gEfiNetworkInterfaceIdentifierProtocolGuid_31
, NULL
},
2116 {STRING_TOKEN(STR_PXE_BC
), &gEfiPxeBaseCodeProtocolGuid
, NULL
},
2117 {STRING_TOKEN(STR_PXE_CB
), &gEfiPxeBaseCodeCallbackProtocolGuid
, NULL
},
2118 {STRING_TOKEN(STR_BIS
), &gEfiBisProtocolGuid
, NULL
},
2119 {STRING_TOKEN(STR_MNP_SB
), &gEfiManagedNetworkServiceBindingProtocolGuid
, NULL
},
2120 {STRING_TOKEN(STR_MNP
), &gEfiManagedNetworkProtocolGuid
, NULL
},
2121 {STRING_TOKEN(STR_ARP_SB
), &gEfiArpServiceBindingProtocolGuid
, NULL
},
2122 {STRING_TOKEN(STR_ARP
), &gEfiArpProtocolGuid
, NULL
},
2123 {STRING_TOKEN(STR_DHCPV4_SB
), &gEfiDhcp4ServiceBindingProtocolGuid
, NULL
},
2124 {STRING_TOKEN(STR_DHCPV4
), &gEfiDhcp4ProtocolGuid
, NULL
},
2125 {STRING_TOKEN(STR_TCPV4_SB
), &gEfiTcp4ServiceBindingProtocolGuid
, NULL
},
2126 {STRING_TOKEN(STR_TCPV4
), &gEfiTcp4ProtocolGuid
, NULL
},
2127 {STRING_TOKEN(STR_IPV4_SB
), &gEfiIp4ServiceBindingProtocolGuid
, NULL
},
2128 {STRING_TOKEN(STR_IPV4
), &gEfiIp4ProtocolGuid
, NULL
},
2129 {STRING_TOKEN(STR_IPV4_CFG
), &gEfiIp4ConfigProtocolGuid
, NULL
},
2130 {STRING_TOKEN(STR_IPV4_CFG2
), &gEfiIp4Config2ProtocolGuid
, NULL
},
2131 {STRING_TOKEN(STR_UDPV4_SB
), &gEfiUdp4ServiceBindingProtocolGuid
, NULL
},
2132 {STRING_TOKEN(STR_UDPV4
), &gEfiUdp4ProtocolGuid
, NULL
},
2133 {STRING_TOKEN(STR_MTFTPV4_SB
), &gEfiMtftp4ServiceBindingProtocolGuid
, NULL
},
2134 {STRING_TOKEN(STR_MTFTPV4
), &gEfiMtftp4ProtocolGuid
, NULL
},
2135 {STRING_TOKEN(STR_AUTH_INFO
), &gEfiAuthenticationInfoProtocolGuid
, NULL
},
2136 {STRING_TOKEN(STR_HASH_SB
), &gEfiHashServiceBindingProtocolGuid
, NULL
},
2137 {STRING_TOKEN(STR_HASH
), &gEfiHashProtocolGuid
, NULL
},
2138 {STRING_TOKEN(STR_HII_FONT
), &gEfiHiiFontProtocolGuid
, NULL
},
2139 {STRING_TOKEN(STR_HII_STRING
), &gEfiHiiStringProtocolGuid
, NULL
},
2140 {STRING_TOKEN(STR_HII_IMAGE
), &gEfiHiiImageProtocolGuid
, NULL
},
2141 {STRING_TOKEN(STR_HII_DATABASE
), &gEfiHiiDatabaseProtocolGuid
, NULL
},
2142 {STRING_TOKEN(STR_HII_CONFIG_ROUT
), &gEfiHiiConfigRoutingProtocolGuid
, NULL
},
2143 {STRING_TOKEN(STR_HII_CONFIG_ACC
), &gEfiHiiConfigAccessProtocolGuid
, NULL
},
2144 {STRING_TOKEN(STR_HII_FORM_BROWSER2
), &gEfiFormBrowser2ProtocolGuid
, NULL
},
2145 {STRING_TOKEN(STR_DRIVER_FAM_OVERRIDE
), &gEfiDriverFamilyOverrideProtocolGuid
, NULL
},
2146 {STRING_TOKEN(STR_PCD
), &gPcdProtocolGuid
, NULL
},
2147 {STRING_TOKEN(STR_TCG
), &gEfiTcgProtocolGuid
, NULL
},
2148 {STRING_TOKEN(STR_HII_PACKAGE_LIST
), &gEfiHiiPackageListProtocolGuid
, NULL
},
2151 // the ones under this are deprecated by the current UEFI Spec, but may be found anyways...
2153 {STRING_TOKEN(STR_SHELL_INTERFACE
), &gEfiShellInterfaceGuid
, NULL
},
2154 {STRING_TOKEN(STR_SHELL_ENV2
), &gEfiShellEnvironment2Guid
, NULL
},
2155 {STRING_TOKEN(STR_SHELL_ENV
), &gEfiShellEnvironment2Guid
, NULL
},
2156 {STRING_TOKEN(STR_DEVICE_IO
), &gEfiDeviceIoProtocolGuid
, NULL
},
2157 {STRING_TOKEN(STR_UGA_DRAW
), &gEfiUgaDrawProtocolGuid
, NULL
},
2158 {STRING_TOKEN(STR_UGA_IO
), &gEfiUgaIoProtocolGuid
, NULL
},
2159 {STRING_TOKEN(STR_ESP
), &gEfiPartTypeSystemPartGuid
, NULL
},
2160 {STRING_TOKEN(STR_GPT_NBR
), &gEfiPartTypeLegacyMbrGuid
, NULL
},
2161 {STRING_TOKEN(STR_DRIVER_CONFIG
), &gEfiDriverConfigurationProtocolGuid
, NULL
},
2162 {STRING_TOKEN(STR_DRIVER_CONFIG2
), &gEfiDriverConfiguration2ProtocolGuid
, NULL
},
2165 // these are using local (non-global) definitions to reduce package dependancy.
2167 {STRING_TOKEN(STR_ISA_IO
), (EFI_GUID
*)&EfiIsaIoProtocolGuid
, NULL
},
2168 {STRING_TOKEN(STR_ISA_ACPI
), (EFI_GUID
*)&EfiIsaAcpiProtocolGuid
, NULL
},
2171 // the ones under this are GUID identified structs, not protocols
2173 {STRING_TOKEN(STR_FILE_INFO
), &gEfiFileInfoGuid
, NULL
},
2174 {STRING_TOKEN(STR_FILE_SYS_INFO
), &gEfiFileSystemInfoGuid
, NULL
},
2177 // the ones under this are misc GUIDS.
2179 {STRING_TOKEN(STR_EFI_GLOBAL_VARIABLE
), &gEfiGlobalVariableGuid
, NULL
},
2184 {STRING_TOKEN(STR_IP6_SB
), &gEfiIp6ServiceBindingProtocolGuid
, NULL
},
2185 {STRING_TOKEN(STR_IP6
), &gEfiIp6ProtocolGuid
, NULL
},
2186 {STRING_TOKEN(STR_IP6_CONFIG
), &gEfiIp6ConfigProtocolGuid
, NULL
},
2187 {STRING_TOKEN(STR_MTFTP6_SB
), &gEfiMtftp6ServiceBindingProtocolGuid
, NULL
},
2188 {STRING_TOKEN(STR_MTFTP6
), &gEfiMtftp6ProtocolGuid
, NULL
},
2189 {STRING_TOKEN(STR_DHCP6_SB
), &gEfiDhcp6ServiceBindingProtocolGuid
, NULL
},
2190 {STRING_TOKEN(STR_DHCP6
), &gEfiDhcp6ProtocolGuid
, NULL
},
2191 {STRING_TOKEN(STR_UDP6_SB
), &gEfiUdp6ServiceBindingProtocolGuid
, NULL
},
2192 {STRING_TOKEN(STR_UDP6
), &gEfiUdp6ProtocolGuid
, NULL
},
2193 {STRING_TOKEN(STR_TCP6_SB
), &gEfiTcp6ServiceBindingProtocolGuid
, NULL
},
2194 {STRING_TOKEN(STR_TCP6
), &gEfiTcp6ProtocolGuid
, NULL
},
2195 {STRING_TOKEN(STR_VLAN_CONFIG
), &gEfiVlanConfigProtocolGuid
, NULL
},
2196 {STRING_TOKEN(STR_EAP
), &gEfiEapProtocolGuid
, NULL
},
2197 {STRING_TOKEN(STR_EAP_MGMT
), &gEfiEapManagementProtocolGuid
, NULL
},
2198 {STRING_TOKEN(STR_FTP4_SB
), &gEfiFtp4ServiceBindingProtocolGuid
, NULL
},
2199 {STRING_TOKEN(STR_FTP4
), &gEfiFtp4ProtocolGuid
, NULL
},
2200 {STRING_TOKEN(STR_IP_SEC_CONFIG
), &gEfiIpSecConfigProtocolGuid
, NULL
},
2201 {STRING_TOKEN(STR_DH
), &gEfiDriverHealthProtocolGuid
, NULL
},
2202 {STRING_TOKEN(STR_DEF_IMG_LOAD
), &gEfiDeferredImageLoadProtocolGuid
, NULL
},
2203 {STRING_TOKEN(STR_USER_CRED
), &gEfiUserCredentialProtocolGuid
, NULL
},
2204 {STRING_TOKEN(STR_USER_MNGR
), &gEfiUserManagerProtocolGuid
, NULL
},
2205 {STRING_TOKEN(STR_ATA_PASS_THRU
), &gEfiAtaPassThruProtocolGuid
, NULL
},
2210 {STRING_TOKEN(STR_FW_MGMT
), &gEfiFirmwareManagementProtocolGuid
, FirmwareManagementDumpInformation
},
2211 {STRING_TOKEN(STR_IP_SEC
), &gEfiIpSecProtocolGuid
, NULL
},
2212 {STRING_TOKEN(STR_IP_SEC2
), &gEfiIpSec2ProtocolGuid
, NULL
},
2217 {STRING_TOKEN(STR_KMS
), &gEfiKmsProtocolGuid
, NULL
},
2218 {STRING_TOKEN(STR_BLK_IO2
), &gEfiBlockIo2ProtocolGuid
, NULL
},
2219 {STRING_TOKEN(STR_SSC
), &gEfiStorageSecurityCommandProtocolGuid
, NULL
},
2220 {STRING_TOKEN(STR_UCRED2
), &gEfiUserCredential2ProtocolGuid
, NULL
},
2225 {STRING_TOKEN(STR_DISK_IO2
), &gEfiDiskIo2ProtocolGuid
, NULL
},
2226 {STRING_TOKEN(STR_ADAPTER_INFO
), &gEfiAdapterInformationProtocolGuid
, AdapterInformationDumpInformation
},
2231 {STRING_TOKEN(STR_TLS_SB
), &gEfiTlsServiceBindingProtocolGuid
, NULL
},
2232 {STRING_TOKEN(STR_TLS
), &gEfiTlsProtocolGuid
, NULL
},
2233 {STRING_TOKEN(STR_TLS_CONFIG
), &gEfiTlsConfigurationProtocolGuid
, NULL
},
2234 {STRING_TOKEN(STR_SUPPLICANT_SB
), &gEfiSupplicantServiceBindingProtocolGuid
, NULL
},
2235 {STRING_TOKEN(STR_SUPPLICANT
), &gEfiSupplicantProtocolGuid
, NULL
},
2240 {STRING_TOKEN(STR_WIFI2
), &gEfiWiFi2ProtocolGuid
, NULL
},
2241 {STRING_TOKEN(STR_RAMDISK
), &gEfiRamDiskProtocolGuid
, NULL
},
2242 {STRING_TOKEN(STR_HII_ID
), &gEfiHiiImageDecoderProtocolGuid
, NULL
},
2243 {STRING_TOKEN(STR_HII_IE
), &gEfiHiiImageExProtocolGuid
, NULL
},
2244 {STRING_TOKEN(STR_SD_MPT
), &gEfiSdMmcPassThruProtocolGuid
, NULL
},
2245 {STRING_TOKEN(STR_ERASE_BLOCK
), &gEfiEraseBlockProtocolGuid
, NULL
},
2250 {STRING_TOKEN(STR_BLUETOOTH_ATTR
), &gEfiBluetoothAttributeProtocolGuid
, NULL
},
2251 {STRING_TOKEN(STR_BLUETOOTH_ATTR_SB
), &gEfiBluetoothAttributeServiceBindingProtocolGuid
, NULL
},
2252 {STRING_TOKEN(STR_BLUETOOTH_LE_CONFIG
), &gEfiBluetoothLeConfigProtocolGuid
, NULL
},
2253 {STRING_TOKEN(STR_UFS_DEV_CONFIG
), &gEfiUfsDeviceConfigProtocolGuid
, NULL
},
2254 {STRING_TOKEN(STR_HTTP_BOOT_CALL
), &gEfiHttpBootCallbackProtocolGuid
, NULL
},
2255 {STRING_TOKEN(STR_RESET_NOTI
), &gEfiResetNotificationProtocolGuid
, NULL
},
2256 {STRING_TOKEN(STR_PARTITION_INFO
), &gEfiPartitionInfoProtocolGuid
, PartitionInfoProtocolDumpInformation
},
2257 {STRING_TOKEN(STR_HII_POPUP
), &gEfiHiiPopupProtocolGuid
, NULL
},
2262 {STRING_TOKEN(STR_IDE_CONT_INIT
), &gEfiIdeControllerInitProtocolGuid
, NULL
},
2263 {STRING_TOKEN(STR_DISK_INFO
), &gEfiDiskInfoProtocolGuid
, NULL
},
2268 {STRING_TOKEN(STR_BDS_ARCH
), &gEfiBdsArchProtocolGuid
, NULL
},
2269 {STRING_TOKEN(STR_CPU_ARCH
), &gEfiCpuArchProtocolGuid
, NULL
},
2270 {STRING_TOKEN(STR_MET_ARCH
), &gEfiMetronomeArchProtocolGuid
, NULL
},
2271 {STRING_TOKEN(STR_MON_ARCH
), &gEfiMonotonicCounterArchProtocolGuid
, NULL
},
2272 {STRING_TOKEN(STR_RTC_ARCH
), &gEfiRealTimeClockArchProtocolGuid
, NULL
},
2273 {STRING_TOKEN(STR_RESET_ARCH
), &gEfiResetArchProtocolGuid
, NULL
},
2274 {STRING_TOKEN(STR_RT_ARCH
), &gEfiRuntimeArchProtocolGuid
, NULL
},
2275 {STRING_TOKEN(STR_SEC_ARCH
), &gEfiSecurityArchProtocolGuid
, NULL
},
2276 {STRING_TOKEN(STR_TIMER_ARCH
), &gEfiTimerArchProtocolGuid
, NULL
},
2277 {STRING_TOKEN(STR_VAR_ARCH
), &gEfiVariableWriteArchProtocolGuid
, NULL
},
2278 {STRING_TOKEN(STR_V_ARCH
), &gEfiVariableArchProtocolGuid
, NULL
},
2279 {STRING_TOKEN(STR_SECP
), &gEfiSecurityPolicyProtocolGuid
, NULL
},
2280 {STRING_TOKEN(STR_WDT_ARCH
), &gEfiWatchdogTimerArchProtocolGuid
, NULL
},
2281 {STRING_TOKEN(STR_SCR
), &gEfiStatusCodeRuntimeProtocolGuid
, NULL
},
2282 {STRING_TOKEN(STR_SMB_HC
), &gEfiSmbusHcProtocolGuid
, NULL
},
2283 {STRING_TOKEN(STR_FV_2
), &gEfiFirmwareVolume2ProtocolGuid
, NULL
},
2284 {STRING_TOKEN(STR_FV_BLOCK
), &gEfiFirmwareVolumeBlockProtocolGuid
, NULL
},
2285 {STRING_TOKEN(STR_CAP_ARCH
), &gEfiCapsuleArchProtocolGuid
, NULL
},
2286 {STRING_TOKEN(STR_MP_SERVICE
), &gEfiMpServiceProtocolGuid
, NULL
},
2287 {STRING_TOKEN(STR_HBRAP
), &gEfiPciHostBridgeResourceAllocationProtocolGuid
, NULL
},
2288 {STRING_TOKEN(STR_PCIP
), &gEfiPciPlatformProtocolGuid
, NULL
},
2289 {STRING_TOKEN(STR_PCIO
), &gEfiPciOverrideProtocolGuid
, NULL
},
2290 {STRING_TOKEN(STR_PCIE
), &gEfiPciEnumerationCompleteProtocolGuid
, NULL
},
2291 {STRING_TOKEN(STR_IPCID
), &gEfiIncompatiblePciDeviceSupportProtocolGuid
, NULL
},
2292 {STRING_TOKEN(STR_PCIHPI
), &gEfiPciHotPlugInitProtocolGuid
, NULL
},
2293 {STRING_TOKEN(STR_PCIHPR
), &gEfiPciHotPlugRequestProtocolGuid
, NULL
},
2294 {STRING_TOKEN(STR_SMBIOS
), &gEfiSmbiosProtocolGuid
, NULL
},
2295 {STRING_TOKEN(STR_S3_SAVE
), &gEfiS3SaveStateProtocolGuid
, NULL
},
2296 {STRING_TOKEN(STR_S3_S_SMM
), &gEfiS3SmmSaveStateProtocolGuid
, NULL
},
2297 {STRING_TOKEN(STR_RSC
), &gEfiRscHandlerProtocolGuid
, NULL
},
2298 {STRING_TOKEN(STR_S_RSC
), &gEfiSmmRscHandlerProtocolGuid
, NULL
},
2299 {STRING_TOKEN(STR_ACPI_SDT
), &gEfiAcpiSdtProtocolGuid
, NULL
},
2300 {STRING_TOKEN(STR_SIO
), &gEfiSioProtocolGuid
, NULL
},
2301 {STRING_TOKEN(STR_S_CPU2
), &gEfiSmmCpuIo2ProtocolGuid
, NULL
},
2302 {STRING_TOKEN(STR_S_BASE2
), &gEfiSmmBase2ProtocolGuid
, NULL
},
2303 {STRING_TOKEN(STR_S_ACC_2
), &gEfiSmmAccess2ProtocolGuid
, NULL
},
2304 {STRING_TOKEN(STR_S_CON_2
), &gEfiSmmControl2ProtocolGuid
, NULL
},
2305 {STRING_TOKEN(STR_S_CONFIG
), &gEfiSmmConfigurationProtocolGuid
, NULL
},
2306 {STRING_TOKEN(STR_S_RTL
), &gEfiSmmReadyToLockProtocolGuid
, NULL
},
2307 {STRING_TOKEN(STR_DS_RTL
), &gEfiDxeSmmReadyToLockProtocolGuid
, NULL
},
2308 {STRING_TOKEN(STR_S_COMM
), &gEfiSmmCommunicationProtocolGuid
, NULL
},
2309 {STRING_TOKEN(STR_S_STAT
), &gEfiSmmStatusCodeProtocolGuid
, NULL
},
2310 {STRING_TOKEN(STR_S_CPU
), &gEfiSmmCpuProtocolGuid
, NULL
},
2311 {STRING_TOKEN(STR_S_PCIRBIO
), &gEfiSmmPciRootBridgeIoProtocolGuid
, NULL
},
2312 {STRING_TOKEN(STR_S_SWD
), &gEfiSmmSwDispatch2ProtocolGuid
, NULL
},
2313 {STRING_TOKEN(STR_S_SXD
), &gEfiSmmSxDispatch2ProtocolGuid
, NULL
},
2314 {STRING_TOKEN(STR_S_PTD2
), &gEfiSmmPeriodicTimerDispatch2ProtocolGuid
, NULL
},
2315 {STRING_TOKEN(STR_S_UD2
), &gEfiSmmUsbDispatch2ProtocolGuid
, NULL
},
2316 {STRING_TOKEN(STR_S_GD2
), &gEfiSmmGpiDispatch2ProtocolGuid
, NULL
},
2317 {STRING_TOKEN(STR_S_SBD2
), &gEfiSmmStandbyButtonDispatch2ProtocolGuid
, NULL
},
2318 {STRING_TOKEN(STR_S_PBD2
), &gEfiSmmPowerButtonDispatch2ProtocolGuid
, NULL
},
2319 {STRING_TOKEN(STR_S_ITD2
), &gEfiSmmIoTrapDispatch2ProtocolGuid
, NULL
},
2320 {STRING_TOKEN(STR_PCD
), &gEfiPcdProtocolGuid
, NULL
},
2321 {STRING_TOKEN(STR_FVB2
), &gEfiFirmwareVolumeBlock2ProtocolGuid
, NULL
},
2322 {STRING_TOKEN(STR_CPUIO2
), &gEfiCpuIo2ProtocolGuid
, NULL
},
2323 {STRING_TOKEN(STR_LEGACY_R2
), &gEfiLegacyRegion2ProtocolGuid
, NULL
},
2324 {STRING_TOKEN(STR_SAL_MIP
), &gEfiSalMcaInitPmiProtocolGuid
, NULL
},
2325 {STRING_TOKEN(STR_ES_BS
), &gEfiExtendedSalBootServiceProtocolGuid
, NULL
},
2326 {STRING_TOKEN(STR_ES_BIO
), &gEfiExtendedSalBaseIoServicesProtocolGuid
, NULL
},
2327 {STRING_TOKEN(STR_ES_STALL
), &gEfiExtendedSalStallServicesProtocolGuid
, NULL
},
2328 {STRING_TOKEN(STR_ES_RTC
), &gEfiExtendedSalRtcServicesProtocolGuid
, NULL
},
2329 {STRING_TOKEN(STR_ES_VS
), &gEfiExtendedSalVariableServicesProtocolGuid
, NULL
},
2330 {STRING_TOKEN(STR_ES_MTC
), &gEfiExtendedSalMtcServicesProtocolGuid
, NULL
},
2331 {STRING_TOKEN(STR_ES_RESET
), &gEfiExtendedSalResetServicesProtocolGuid
, NULL
},
2332 {STRING_TOKEN(STR_ES_SC
), &gEfiExtendedSalStatusCodeServicesProtocolGuid
, NULL
},
2333 {STRING_TOKEN(STR_ES_FBS
), &gEfiExtendedSalFvBlockServicesProtocolGuid
, NULL
},
2334 {STRING_TOKEN(STR_ES_MP
), &gEfiExtendedSalMpServicesProtocolGuid
, NULL
},
2335 {STRING_TOKEN(STR_ES_PAL
), &gEfiExtendedSalPalServicesProtocolGuid
, NULL
},
2336 {STRING_TOKEN(STR_ES_BASE
), &gEfiExtendedSalBaseServicesProtocolGuid
, NULL
},
2337 {STRING_TOKEN(STR_ES_MCA
), &gEfiExtendedSalMcaServicesProtocolGuid
, NULL
},
2338 {STRING_TOKEN(STR_ES_PCI
), &gEfiExtendedSalPciServicesProtocolGuid
, NULL
},
2339 {STRING_TOKEN(STR_ES_CACHE
), &gEfiExtendedSalCacheServicesProtocolGuid
, NULL
},
2340 {STRING_TOKEN(STR_ES_MCA_LOG
), &gEfiExtendedSalMcaLogServicesProtocolGuid
, NULL
},
2341 {STRING_TOKEN(STR_S2ARCH
), &gEfiSecurity2ArchProtocolGuid
, NULL
},
2342 {STRING_TOKEN(STR_EODXE
), &gEfiSmmEndOfDxeProtocolGuid
, NULL
},
2343 {STRING_TOKEN(STR_ISAHC
), &gEfiIsaHcProtocolGuid
, NULL
},
2344 {STRING_TOKEN(STR_ISAHC_B
), &gEfiIsaHcServiceBindingProtocolGuid
, NULL
},
2345 {STRING_TOKEN(STR_SIO_C
), &gEfiSioControlProtocolGuid
, NULL
},
2346 {STRING_TOKEN(STR_GET_PCD
), &gEfiGetPcdInfoProtocolGuid
, NULL
},
2347 {STRING_TOKEN(STR_I2C_M
), &gEfiI2cMasterProtocolGuid
, NULL
},
2348 {STRING_TOKEN(STR_I2CIO
), &gEfiI2cIoProtocolGuid
, NULL
},
2349 {STRING_TOKEN(STR_I2CEN
), &gEfiI2cEnumerateProtocolGuid
, NULL
},
2350 {STRING_TOKEN(STR_I2C_H
), &gEfiI2cHostProtocolGuid
, NULL
},
2351 {STRING_TOKEN(STR_I2C_BCM
), &gEfiI2cBusConfigurationManagementProtocolGuid
, NULL
},
2352 {STRING_TOKEN(STR_TCG2
), &gEfiTcg2ProtocolGuid
, NULL
},
2353 {STRING_TOKEN(STR_TIMESTAMP
), &gEfiTimestampProtocolGuid
, NULL
},
2354 {STRING_TOKEN(STR_RNG
), &gEfiRngProtocolGuid
, NULL
},
2355 {STRING_TOKEN(STR_NVMEPT
), &gEfiNvmExpressPassThruProtocolGuid
, NULL
},
2356 {STRING_TOKEN(STR_H2_SB
), &gEfiHash2ServiceBindingProtocolGuid
, NULL
},
2357 {STRING_TOKEN(STR_HASH2
), &gEfiHash2ProtocolGuid
, NULL
},
2358 {STRING_TOKEN(STR_BIO_C
), &gEfiBlockIoCryptoProtocolGuid
, NULL
},
2359 {STRING_TOKEN(STR_SCR
), &gEfiSmartCardReaderProtocolGuid
, NULL
},
2360 {STRING_TOKEN(STR_SCE
), &gEfiSmartCardEdgeProtocolGuid
, NULL
},
2361 {STRING_TOKEN(STR_USB_FIO
), &gEfiUsbFunctionIoProtocolGuid
, NULL
},
2362 {STRING_TOKEN(STR_BC_HC
), &gEfiBluetoothHcProtocolGuid
, NULL
},
2363 {STRING_TOKEN(STR_BC_IO_SB
), &gEfiBluetoothIoServiceBindingProtocolGuid
, NULL
},
2364 {STRING_TOKEN(STR_BC_IO
), &gEfiBluetoothIoProtocolGuid
, NULL
},
2365 {STRING_TOKEN(STR_BC_C
), &gEfiBluetoothConfigProtocolGuid
, NULL
},
2366 {STRING_TOKEN(STR_REG_EXP
), &gEfiRegularExpressionProtocolGuid
, NULL
},
2367 {STRING_TOKEN(STR_B_MGR_P
), &gEfiBootManagerPolicyProtocolGuid
, NULL
},
2368 {STRING_TOKEN(STR_CKH
), &gEfiConfigKeywordHandlerProtocolGuid
, NULL
},
2369 {STRING_TOKEN(STR_WIFI
), &gEfiWiFiProtocolGuid
, NULL
},
2370 {STRING_TOKEN(STR_EAP_M
), &gEfiEapManagement2ProtocolGuid
, NULL
},
2371 {STRING_TOKEN(STR_EAP_C
), &gEfiEapConfigurationProtocolGuid
, NULL
},
2372 {STRING_TOKEN(STR_PKCS7
), &gEfiPkcs7VerifyProtocolGuid
, NULL
},
2373 {STRING_TOKEN(STR_NET_DNS4_SB
), &gEfiDns4ServiceBindingProtocolGuid
, NULL
},
2374 {STRING_TOKEN(STR_NET_DNS4
), &gEfiDns4ProtocolGuid
, NULL
},
2375 {STRING_TOKEN(STR_NET_DNS6_SB
), &gEfiDns6ServiceBindingProtocolGuid
, NULL
},
2376 {STRING_TOKEN(STR_NET_DNS6
), &gEfiDns6ProtocolGuid
, NULL
},
2377 {STRING_TOKEN(STR_NET_HTTP_SB
), &gEfiHttpServiceBindingProtocolGuid
, NULL
},
2378 {STRING_TOKEN(STR_NET_HTTP
), &gEfiHttpProtocolGuid
, NULL
},
2379 {STRING_TOKEN(STR_NET_HTTP_U
), &gEfiHttpUtilitiesProtocolGuid
, NULL
},
2380 {STRING_TOKEN(STR_REST
), &gEfiRestProtocolGuid
, NULL
},
2385 {STRING_TOKEN(STR_MM_EOD
), &gEfiMmEndOfDxeProtocolGuid
, NULL
},
2386 {STRING_TOKEN(STR_MM_ITD
), &gEfiMmIoTrapDispatchProtocolGuid
, NULL
},
2387 {STRING_TOKEN(STR_MM_PBD
), &gEfiMmPowerButtonDispatchProtocolGuid
, NULL
},
2388 {STRING_TOKEN(STR_MM_SBD
), &gEfiMmStandbyButtonDispatchProtocolGuid
, NULL
},
2389 {STRING_TOKEN(STR_MM_GD
), &gEfiMmGpiDispatchProtocolGuid
, NULL
},
2390 {STRING_TOKEN(STR_MM_UD
), &gEfiMmUsbDispatchProtocolGuid
, NULL
},
2391 {STRING_TOKEN(STR_MM_PTD
), &gEfiMmPeriodicTimerDispatchProtocolGuid
, NULL
},
2392 {STRING_TOKEN(STR_MM_SXD
), &gEfiMmSxDispatchProtocolGuid
, NULL
},
2393 {STRING_TOKEN(STR_MM_SWD
), &gEfiMmSwDispatchProtocolGuid
, NULL
},
2394 {STRING_TOKEN(STR_MM_PRBI
), &gEfiMmPciRootBridgeIoProtocolGuid
, NULL
},
2395 {STRING_TOKEN(STR_MM_CPU
), &gEfiMmCpuProtocolGuid
, NULL
},
2396 {STRING_TOKEN(STR_MM_STACODE
), &gEfiMmStatusCodeProtocolGuid
, NULL
},
2397 {STRING_TOKEN(STR_DXEMM_RTL
), &gEfiDxeMmReadyToLockProtocolGuid
, NULL
},
2398 {STRING_TOKEN(STR_MM_CONFIG
), &gEfiMmConfigurationProtocolGuid
, NULL
},
2399 {STRING_TOKEN(STR_MM_RTL
), &gEfiMmReadyToLockProtocolGuid
, NULL
},
2400 {STRING_TOKEN(STR_MM_CONTROL
), &gEfiMmControlProtocolGuid
, NULL
},
2401 {STRING_TOKEN(STR_MM_ACCESS
), &gEfiMmAccessProtocolGuid
, NULL
},
2402 {STRING_TOKEN(STR_MM_BASE
), &gEfiMmBaseProtocolGuid
, NULL
},
2403 {STRING_TOKEN(STR_MM_CPUIO
), &gEfiMmCpuIoProtocolGuid
, NULL
},
2404 {STRING_TOKEN(STR_MM_RH
), &gEfiMmRscHandlerProtocolGuid
, NULL
},
2405 {STRING_TOKEN(STR_MM_COM
), &gEfiMmCommunicationProtocolGuid
, NULL
},
2408 // UEFI Shell Spec 2.0
2410 {STRING_TOKEN(STR_SHELL_PARAMETERS
), &gEfiShellParametersProtocolGuid
, NULL
},
2411 {STRING_TOKEN(STR_SHELL
), &gEfiShellProtocolGuid
, NULL
},
2414 // UEFI Shell Spec 2.1
2416 {STRING_TOKEN(STR_SHELL_DYNAMIC
), &gEfiShellDynamicCommandProtocolGuid
, NULL
},
2421 {STRING_TOKEN(STR_PCDINFOPROT
), &gGetPcdInfoProtocolGuid
, NULL
},
2430 Function to get the node for a protocol or struct from it's GUID.
2432 if Guid is NULL, then ASSERT.
2434 @param[in] Guid The GUID to look for the name of.
2438 CONST GUID_INFO_BLOCK
*
2439 InternalShellGetNodeFromGuid(
2440 IN CONST EFI_GUID
* Guid
2443 CONST GUID_INFO_BLOCK
*ListWalker
;
2446 ASSERT(Guid
!= NULL
);
2448 for (LoopCount
= 0, ListWalker
= mGuidList
; mGuidList
!= NULL
&& LoopCount
< mGuidListCount
; LoopCount
++, ListWalker
++) {
2449 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
2450 return (ListWalker
);
2454 if (PcdGetBool(PcdShellIncludeNtGuids
)) {
2455 for (ListWalker
= mGuidStringListNT
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
2456 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
2457 return (ListWalker
);
2461 for (ListWalker
= mGuidStringList
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
2462 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
2463 return (ListWalker
);
2470 Function to add a new GUID/Name mapping.
2472 @param[in] Guid The Guid
2473 @param[in] NameID The STRING id of the HII string to use
2474 @param[in] DumpFunc The pointer to the dump function
2477 @retval EFI_SUCCESS The operation was sucessful
2478 @retval EFI_OUT_OF_RESOURCES A memory allocation failed
2479 @retval EFI_INVALID_PARAMETER Guid NameId was invalid
2482 InsertNewGuidNameMapping(
2483 IN CONST EFI_GUID
*Guid
,
2484 IN CONST EFI_STRING_ID NameID
,
2485 IN CONST DUMP_PROTOCOL_INFO DumpFunc OPTIONAL
2488 ASSERT(Guid
!= NULL
);
2489 ASSERT(NameID
!= 0);
2491 mGuidList
= ReallocatePool(mGuidListCount
* sizeof(GUID_INFO_BLOCK
), mGuidListCount
+1 * sizeof(GUID_INFO_BLOCK
), mGuidList
);
2492 if (mGuidList
== NULL
) {
2494 return (EFI_OUT_OF_RESOURCES
);
2498 mGuidList
[mGuidListCount
- 1].GuidId
= AllocateCopyPool(sizeof(EFI_GUID
), Guid
);
2499 mGuidList
[mGuidListCount
- 1].StringId
= NameID
;
2500 mGuidList
[mGuidListCount
- 1].DumpInfo
= DumpFunc
;
2502 if (mGuidList
[mGuidListCount
- 1].GuidId
== NULL
) {
2503 return (EFI_OUT_OF_RESOURCES
);
2506 return (EFI_SUCCESS
);
2510 Function to add a new GUID/Name mapping.
2512 This cannot overwrite an existing mapping.
2514 @param[in] Guid The Guid
2515 @param[in] TheName The Guid's name
2516 @param[in] Lang RFC4646 language code list or NULL
2518 @retval EFI_SUCCESS The operation was sucessful
2519 @retval EFI_ACCESS_DENIED There was a duplicate
2520 @retval EFI_OUT_OF_RESOURCES A memory allocation failed
2521 @retval EFI_INVALID_PARAMETER Guid or TheName was NULL
2525 AddNewGuidNameMapping(
2526 IN CONST EFI_GUID
*Guid
,
2527 IN CONST CHAR16
*TheName
,
2528 IN CONST CHAR8
*Lang OPTIONAL
2531 EFI_STRING_ID NameID
;
2533 HandleParsingHiiInit();
2535 if (Guid
== NULL
|| TheName
== NULL
){
2536 return (EFI_INVALID_PARAMETER
);
2539 if ((InternalShellGetNodeFromGuid(Guid
)) != NULL
) {
2540 return (EFI_ACCESS_DENIED
);
2543 NameID
= HiiSetString(mHandleParsingHiiHandle
, 0, (CHAR16
*)TheName
, Lang
);
2545 return (EFI_OUT_OF_RESOURCES
);
2548 return (InsertNewGuidNameMapping(Guid
, NameID
, NULL
));
2552 Function to get the name of a protocol or struct from it's GUID.
2554 if Guid is NULL, then ASSERT.
2556 @param[in] Guid The GUID to look for the name of.
2557 @param[in] Lang The language to use.
2559 @return pointer to string of the name. The caller
2560 is responsible to free this memory.
2564 GetStringNameFromGuid(
2565 IN CONST EFI_GUID
*Guid
,
2566 IN CONST CHAR8
*Lang OPTIONAL
2569 CONST GUID_INFO_BLOCK
*Id
;
2571 HandleParsingHiiInit();
2573 Id
= InternalShellGetNodeFromGuid(Guid
);
2577 return HiiGetString (mHandleParsingHiiHandle
, Id
->StringId
, Lang
);
2581 Function to dump protocol information from a handle.
2583 This function will return a allocated string buffer containing the
2584 information. The caller is responsible for freeing the memory.
2586 If Guid is NULL, ASSERT().
2587 If TheHandle is NULL, ASSERT().
2589 @param[in] TheHandle The handle to dump information from.
2590 @param[in] Guid The GUID of the protocol to dump.
2591 @param[in] Verbose TRUE for extra info. FALSE otherwise.
2593 @return The pointer to string.
2594 @retval NULL An error was encountered.
2598 GetProtocolInformationDump(
2599 IN CONST EFI_HANDLE TheHandle
,
2600 IN CONST EFI_GUID
*Guid
,
2601 IN CONST BOOLEAN Verbose
2604 CONST GUID_INFO_BLOCK
*Id
;
2606 ASSERT(TheHandle
!= NULL
);
2607 ASSERT(Guid
!= NULL
);
2609 if (TheHandle
== NULL
|| Guid
== NULL
) {
2613 Id
= InternalShellGetNodeFromGuid(Guid
);
2614 if (Id
!= NULL
&& Id
->DumpInfo
!= NULL
) {
2615 return (Id
->DumpInfo(TheHandle
, Verbose
));
2621 Function to get the Guid for a protocol or struct based on it's string name.
2623 do not modify the returned Guid.
2625 @param[in] Name The pointer to the string name.
2626 @param[in] Lang The pointer to the language code.
2627 @param[out] Guid The pointer to the Guid.
2629 @retval EFI_SUCCESS The operation was sucessful.
2633 GetGuidFromStringName(
2634 IN CONST CHAR16
*Name
,
2635 IN CONST CHAR8
*Lang OPTIONAL
,
2639 CONST GUID_INFO_BLOCK
*ListWalker
;
2643 HandleParsingHiiInit();
2645 ASSERT(Guid
!= NULL
);
2647 return (EFI_INVALID_PARAMETER
);
2651 if (PcdGetBool(PcdShellIncludeNtGuids
)) {
2652 for (ListWalker
= mGuidStringListNT
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
2653 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
2654 if (Name
!= NULL
&& String
!= NULL
&& StringNoCaseCompare (&Name
, &String
) == 0) {
2655 *Guid
= ListWalker
->GuidId
;
2657 SHELL_FREE_NON_NULL(String
);
2658 if (*Guid
!= NULL
) {
2659 return (EFI_SUCCESS
);
2663 for (ListWalker
= mGuidStringList
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
2664 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
2665 if (Name
!= NULL
&& String
!= NULL
&& StringNoCaseCompare (&Name
, &String
) == 0) {
2666 *Guid
= ListWalker
->GuidId
;
2668 SHELL_FREE_NON_NULL(String
);
2669 if (*Guid
!= NULL
) {
2670 return (EFI_SUCCESS
);
2674 for (LoopCount
= 0, ListWalker
= mGuidList
; mGuidList
!= NULL
&& LoopCount
< mGuidListCount
; LoopCount
++, ListWalker
++) {
2675 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
2676 if (Name
!= NULL
&& String
!= NULL
&& StringNoCaseCompare (&Name
, &String
) == 0) {
2677 *Guid
= ListWalker
->GuidId
;
2679 SHELL_FREE_NON_NULL(String
);
2680 if (*Guid
!= NULL
) {
2681 return (EFI_SUCCESS
);
2685 return (EFI_NOT_FOUND
);
2689 Get best support language for this driver.
2691 First base on the user input language to search, second base on the current
2692 platform used language to search, third get the first language from the
2693 support language list. The caller need to free the buffer of the best language.
2695 @param[in] SupportedLanguages The support languages for this driver.
2696 @param[in] InputLanguage The user input language.
2697 @param[in] Iso639Language Whether get language for ISO639.
2699 @return The best support language for this driver.
2703 GetBestLanguageForDriver (
2704 IN CONST CHAR8
*SupportedLanguages
,
2705 IN CONST CHAR8
*InputLanguage
,
2706 IN BOOLEAN Iso639Language
2709 CHAR8
*LanguageVariable
;
2710 CHAR8
*BestLanguage
;
2712 GetVariable2 (Iso639Language
? L
"Lang" : L
"PlatformLang", &gEfiGlobalVariableGuid
, (VOID
**)&LanguageVariable
, NULL
);
2714 BestLanguage
= GetBestLanguage(
2717 (InputLanguage
!= NULL
) ? InputLanguage
: "",
2718 (LanguageVariable
!= NULL
) ? LanguageVariable
: "",
2723 if (LanguageVariable
!= NULL
) {
2724 FreePool (LanguageVariable
);
2727 return BestLanguage
;
2731 Function to retrieve the driver name (if possible) from the ComponentName or
2732 ComponentName2 protocol
2734 @param[in] TheHandle The driver handle to get the name of.
2735 @param[in] Language The language to use.
2737 @retval NULL The name could not be found.
2738 @return A pointer to the string name. Do not de-allocate the memory.
2742 GetStringNameFromHandle(
2743 IN CONST EFI_HANDLE TheHandle
,
2744 IN CONST CHAR8
*Language
2747 EFI_COMPONENT_NAME2_PROTOCOL
*CompNameStruct
;
2754 Status
= gBS
->OpenProtocol(
2756 &gEfiComponentName2ProtocolGuid
,
2757 (VOID
**)&CompNameStruct
,
2760 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
2761 if (!EFI_ERROR(Status
)) {
2762 BestLang
= GetBestLanguageForDriver (CompNameStruct
->SupportedLanguages
, Language
, FALSE
);
2763 Status
= CompNameStruct
->GetDriverName(CompNameStruct
, BestLang
, &RetVal
);
2764 if (BestLang
!= NULL
) {
2765 FreePool (BestLang
);
2768 if (!EFI_ERROR(Status
)) {
2772 Status
= gBS
->OpenProtocol(
2774 &gEfiComponentNameProtocolGuid
,
2775 (VOID
**)&CompNameStruct
,
2778 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
2779 if (!EFI_ERROR(Status
)) {
2780 BestLang
= GetBestLanguageForDriver (CompNameStruct
->SupportedLanguages
, Language
, FALSE
);
2781 Status
= CompNameStruct
->GetDriverName(CompNameStruct
, BestLang
, &RetVal
);
2782 if (BestLang
!= NULL
) {
2783 FreePool (BestLang
);
2785 if (!EFI_ERROR(Status
)) {
2793 Function to initialize the file global mHandleList object for use in
2794 vonverting handles to index and index to handle.
2796 @retval EFI_SUCCESS The operation was successful.
2799 InternalShellInitHandleList(
2804 EFI_HANDLE
*HandleBuffer
;
2806 HANDLE_LIST
*ListWalker
;
2808 if (mHandleList
.NextIndex
!= 0) {
2811 InitializeListHead(&mHandleList
.List
.Link
);
2812 mHandleList
.NextIndex
= 1;
2813 Status
= gBS
->LocateHandleBuffer (
2820 ASSERT_EFI_ERROR(Status
);
2821 if (EFI_ERROR(Status
)) {
2824 for (mHandleList
.NextIndex
= 1 ; mHandleList
.NextIndex
<= HandleCount
; mHandleList
.NextIndex
++){
2825 ListWalker
= AllocateZeroPool(sizeof(HANDLE_LIST
));
2826 if (ListWalker
!= NULL
) {
2827 ListWalker
->TheHandle
= HandleBuffer
[mHandleList
.NextIndex
- 1];
2828 ListWalker
->TheIndex
= mHandleList
.NextIndex
;
2829 InsertTailList (&mHandleList
.List
.Link
, &ListWalker
->Link
);
2832 FreePool(HandleBuffer
);
2833 return (EFI_SUCCESS
);
2837 Function to retrieve the human-friendly index of a given handle. If the handle
2838 does not have a index one will be automatically assigned. The index value is valid
2839 until the termination of the shell application.
2841 @param[in] TheHandle The handle to retrieve an index for.
2843 @retval 0 A memory allocation failed.
2844 @return The index of the handle.
2849 ConvertHandleToHandleIndex(
2850 IN CONST EFI_HANDLE TheHandle
2854 EFI_GUID
**ProtocolBuffer
;
2855 UINTN ProtocolCount
;
2856 HANDLE_LIST
*ListWalker
;
2858 if (TheHandle
== NULL
) {
2862 InternalShellInitHandleList();
2864 for (ListWalker
= (HANDLE_LIST
*)GetFirstNode(&mHandleList
.List
.Link
)
2865 ; !IsNull(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2866 ; ListWalker
= (HANDLE_LIST
*)GetNextNode(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2868 if (ListWalker
->TheHandle
== TheHandle
) {
2870 // Verify that TheHandle is still present in the Handle Database
2872 Status
= gBS
->ProtocolsPerHandle(TheHandle
, &ProtocolBuffer
, &ProtocolCount
);
2873 if (EFI_ERROR (Status
)) {
2875 // TheHandle is not present in the Handle Database, so delete from the handle list
2877 RemoveEntryList (&ListWalker
->Link
);
2880 FreePool (ProtocolBuffer
);
2881 return (ListWalker
->TheIndex
);
2886 // Verify that TheHandle is valid handle
2888 Status
= gBS
->ProtocolsPerHandle(TheHandle
, &ProtocolBuffer
, &ProtocolCount
);
2889 if (EFI_ERROR (Status
)) {
2891 // TheHandle is not valid, so do not add to handle list
2895 FreePool (ProtocolBuffer
);
2897 ListWalker
= AllocateZeroPool(sizeof(HANDLE_LIST
));
2898 if (ListWalker
== NULL
) {
2901 ListWalker
->TheHandle
= TheHandle
;
2902 ListWalker
->TheIndex
= mHandleList
.NextIndex
++;
2903 InsertTailList(&mHandleList
.List
.Link
,&ListWalker
->Link
);
2904 return (ListWalker
->TheIndex
);
2910 Function to retrieve the EFI_HANDLE from the human-friendly index.
2912 @param[in] TheIndex The index to retrieve the EFI_HANDLE for.
2914 @retval NULL The index was invalid.
2915 @return The EFI_HANDLE that index represents.
2920 ConvertHandleIndexToHandle(
2921 IN CONST UINTN TheIndex
2925 EFI_GUID
**ProtocolBuffer
;
2926 UINTN ProtocolCount
;
2927 HANDLE_LIST
*ListWalker
;
2929 InternalShellInitHandleList();
2931 if (TheIndex
>= mHandleList
.NextIndex
) {
2935 for (ListWalker
= (HANDLE_LIST
*)GetFirstNode(&mHandleList
.List
.Link
)
2936 ; !IsNull(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2937 ; ListWalker
= (HANDLE_LIST
*)GetNextNode(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2939 if (ListWalker
->TheIndex
== TheIndex
&& ListWalker
->TheHandle
!= NULL
) {
2941 // Verify that LinkWalker->TheHandle is valid handle
2943 Status
= gBS
->ProtocolsPerHandle(ListWalker
->TheHandle
, &ProtocolBuffer
, &ProtocolCount
);
2944 if (!EFI_ERROR (Status
)) {
2945 FreePool (ProtocolBuffer
);
2948 // TheHandle is not valid, so do not add to handle list
2950 ListWalker
->TheHandle
= NULL
;
2952 return (ListWalker
->TheHandle
);
2959 Gets all the related EFI_HANDLEs based on the mask supplied.
2961 This function scans all EFI_HANDLES in the UEFI environment's handle database
2962 and returns the ones with the specified relationship (Mask) to the specified
2965 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
2966 If MatchingHandleCount is NULL, then ASSERT.
2968 If MatchingHandleBuffer is not NULL upon a successful return the memory must be
2971 @param[in] DriverBindingHandle The handle with Driver Binding protocol on it.
2972 @param[in] ControllerHandle The handle with Device Path protocol on it.
2973 @param[in] MatchingHandleCount The pointer to UINTN that specifies the number of HANDLES in
2974 MatchingHandleBuffer.
2975 @param[out] MatchingHandleBuffer On a successful return, a buffer of MatchingHandleCount
2976 EFI_HANDLEs with a terminating NULL EFI_HANDLE.
2977 @param[out] HandleType An array of type information.
2979 @retval EFI_SUCCESS The operation was successful, and any related handles
2980 are in MatchingHandleBuffer.
2981 @retval EFI_NOT_FOUND No matching handles were found.
2982 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.
2986 ParseHandleDatabaseByRelationshipWithType (
2987 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL
,
2988 IN CONST EFI_HANDLE ControllerHandle OPTIONAL
,
2989 IN UINTN
*HandleCount
,
2990 OUT EFI_HANDLE
**HandleBuffer
,
2991 OUT UINTN
**HandleType
2996 EFI_GUID
**ProtocolGuidArray
;
2998 UINTN ProtocolIndex
;
2999 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY
*OpenInfo
;
3000 UINTN OpenInfoCount
;
3001 UINTN OpenInfoIndex
;
3003 INTN DriverBindingHandleIndex
;
3005 ASSERT(HandleCount
!= NULL
);
3006 ASSERT(HandleBuffer
!= NULL
);
3007 ASSERT(HandleType
!= NULL
);
3008 ASSERT(DriverBindingHandle
!= NULL
|| ControllerHandle
!= NULL
);
3011 *HandleBuffer
= NULL
;
3015 // Retrieve the list of all handles from the handle database
3017 Status
= gBS
->LocateHandleBuffer (
3024 if (EFI_ERROR (Status
)) {
3028 *HandleType
= AllocateZeroPool (*HandleCount
* sizeof (UINTN
));
3029 if (*HandleType
== NULL
) {
3030 SHELL_FREE_NON_NULL (*HandleBuffer
);
3032 return EFI_OUT_OF_RESOURCES
;
3035 DriverBindingHandleIndex
= -1;
3036 for (HandleIndex
= 0; HandleIndex
< *HandleCount
; HandleIndex
++) {
3037 if (DriverBindingHandle
!= NULL
&& (*HandleBuffer
)[HandleIndex
] == DriverBindingHandle
) {
3038 DriverBindingHandleIndex
= (INTN
)HandleIndex
;
3042 for (HandleIndex
= 0; HandleIndex
< *HandleCount
; HandleIndex
++) {
3044 // Retrieve the list of all the protocols on each handle
3046 Status
= gBS
->ProtocolsPerHandle (
3047 (*HandleBuffer
)[HandleIndex
],
3051 if (EFI_ERROR (Status
)) {
3055 for (ProtocolIndex
= 0; ProtocolIndex
< ArrayCount
; ProtocolIndex
++) {
3058 // Set the bit describing what this handle has
3060 if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiLoadedImageProtocolGuid
) ) {
3061 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_IMAGE_HANDLE
;
3062 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverBindingProtocolGuid
) ) {
3063 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_BINDING_HANDLE
;
3064 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverConfiguration2ProtocolGuid
)) {
3065 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_CONFIGURATION_HANDLE
;
3066 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverConfigurationProtocolGuid
) ) {
3067 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_CONFIGURATION_HANDLE
;
3068 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverDiagnostics2ProtocolGuid
) ) {
3069 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_DIAGNOSTICS_HANDLE
;
3070 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverDiagnosticsProtocolGuid
) ) {
3071 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_DIAGNOSTICS_HANDLE
;
3072 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiComponentName2ProtocolGuid
) ) {
3073 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_COMPONENT_NAME_HANDLE
;
3074 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiComponentNameProtocolGuid
) ) {
3075 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_COMPONENT_NAME_HANDLE
;
3076 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDevicePathProtocolGuid
) ) {
3077 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DEVICE_HANDLE
;
3080 // Retrieve the list of agents that have opened each protocol
3082 Status
= gBS
->OpenProtocolInformation (
3083 (*HandleBuffer
)[HandleIndex
],
3084 ProtocolGuidArray
[ProtocolIndex
],
3088 if (EFI_ERROR (Status
)) {
3092 if (ControllerHandle
== NULL
) {
3094 // ControllerHandle == NULL and DriverBindingHandle != NULL.
3095 // Return information on all the controller handles that the driver specified by DriverBindingHandle is managing
3097 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
3098 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
&& (OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) != 0) {
3099 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
3100 if (DriverBindingHandleIndex
!= -1) {
3101 (*HandleType
)[DriverBindingHandleIndex
] |= (UINTN
)HR_DEVICE_DRIVER
;
3104 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
&& (OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
3105 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
3106 if (DriverBindingHandleIndex
!= -1) {
3107 (*HandleType
)[DriverBindingHandleIndex
] |= (UINTN
)(HR_BUS_DRIVER
| HR_DEVICE_DRIVER
);
3109 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
3110 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== (*HandleBuffer
)[ChildIndex
]) {
3111 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
3117 if (DriverBindingHandle
== NULL
&& ControllerHandle
!= NULL
) {
3118 if (ControllerHandle
== (*HandleBuffer
)[HandleIndex
]) {
3119 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
3120 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
3121 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) != 0) {
3122 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
3123 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== (*HandleBuffer
)[ChildIndex
]) {
3124 (*HandleType
)[ChildIndex
] |= (UINTN
)HR_DEVICE_DRIVER
;
3128 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
3129 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
3130 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== (*HandleBuffer
)[ChildIndex
]) {
3131 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_BUS_DRIVER
| HR_DEVICE_DRIVER
);
3133 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== (*HandleBuffer
)[ChildIndex
]) {
3134 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
3140 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
3141 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
3142 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== ControllerHandle
) {
3143 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_PARENT_HANDLE
);
3149 if (DriverBindingHandle
!= NULL
&& ControllerHandle
!= NULL
) {
3150 if (ControllerHandle
== (*HandleBuffer
)[HandleIndex
]) {
3151 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
3152 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
3153 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) != 0) {
3154 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
) {
3155 if (DriverBindingHandleIndex
!= -1) {
3156 (*HandleType
)[DriverBindingHandleIndex
] |= (UINTN
)HR_DEVICE_DRIVER
;
3160 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
3161 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
) {
3162 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
3163 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== (*HandleBuffer
)[ChildIndex
]) {
3164 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
3169 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
3170 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== (*HandleBuffer
)[ChildIndex
]) {
3171 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_BUS_DRIVER
| HR_DEVICE_DRIVER
);
3177 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
3178 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
3179 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== ControllerHandle
) {
3180 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_PARENT_HANDLE
);
3186 FreePool (OpenInfo
);
3188 FreePool (ProtocolGuidArray
);
3194 Gets all the related EFI_HANDLEs based on the single EFI_HANDLE and the mask
3197 This function will scan all EFI_HANDLES in the UEFI environment's handle database
3198 and return all the ones with the specified relationship (Mask) to the specified
3201 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
3202 If MatchingHandleCount is NULL, then ASSERT.
3204 If MatchingHandleBuffer is not NULL upon a sucessful return the memory must be
3207 @param[in] DriverBindingHandle Handle to a object with Driver Binding protocol
3209 @param[in] ControllerHandle Handle to a device with Device Path protocol on it.
3210 @param[in] Mask Mask of what relationship(s) is desired.
3211 @param[in] MatchingHandleCount Poitner to UINTN specifying number of HANDLES in
3212 MatchingHandleBuffer.
3213 @param[out] MatchingHandleBuffer On a sucessful return a buffer of MatchingHandleCount
3214 EFI_HANDLEs and a terminating NULL EFI_HANDLE.
3216 @retval EFI_SUCCESS The operation was sucessful and any related handles
3217 are in MatchingHandleBuffer;
3218 @retval EFI_NOT_FOUND No matching handles were found.
3219 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.
3223 ParseHandleDatabaseByRelationship (
3224 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL
,
3225 IN CONST EFI_HANDLE ControllerHandle OPTIONAL
,
3226 IN CONST UINTN Mask
,
3227 IN UINTN
*MatchingHandleCount
,
3228 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
3233 EFI_HANDLE
*HandleBuffer
;
3237 ASSERT(MatchingHandleCount
!= NULL
);
3238 ASSERT(DriverBindingHandle
!= NULL
|| ControllerHandle
!= NULL
);
3240 if ((Mask
& HR_VALID_MASK
) != Mask
) {
3241 return (EFI_INVALID_PARAMETER
);
3244 if ((Mask
& HR_CHILD_HANDLE
) != 0 && DriverBindingHandle
== NULL
) {
3245 return (EFI_INVALID_PARAMETER
);
3248 *MatchingHandleCount
= 0;
3249 if (MatchingHandleBuffer
!= NULL
) {
3250 *MatchingHandleBuffer
= NULL
;
3253 HandleBuffer
= NULL
;
3256 Status
= ParseHandleDatabaseByRelationshipWithType (
3257 DriverBindingHandle
,
3263 if (!EFI_ERROR (Status
)) {
3265 // Count the number of handles that match the attributes in Mask
3267 for (HandleIndex
= 0; HandleIndex
< HandleCount
; HandleIndex
++) {
3268 if ((HandleType
[HandleIndex
] & Mask
) == Mask
) {
3269 (*MatchingHandleCount
)++;
3273 // If no handles match the attributes in Mask then return EFI_NOT_FOUND
3275 if (*MatchingHandleCount
== 0) {
3276 Status
= EFI_NOT_FOUND
;
3279 if (MatchingHandleBuffer
== NULL
) {
3281 // Someone just wanted the count...
3283 Status
= EFI_SUCCESS
;
3286 // Allocate a handle buffer for the number of handles that matched the attributes in Mask
3288 *MatchingHandleBuffer
= AllocateZeroPool ((*MatchingHandleCount
+1)* sizeof (EFI_HANDLE
));
3289 if (*MatchingHandleBuffer
== NULL
) {
3290 Status
= EFI_OUT_OF_RESOURCES
;
3292 for (HandleIndex
= 0, *MatchingHandleCount
= 0
3293 ; HandleIndex
< HandleCount
3297 // Fill the allocated buffer with the handles that matched the attributes in Mask
3299 if ((HandleType
[HandleIndex
] & Mask
) == Mask
) {
3300 (*MatchingHandleBuffer
)[(*MatchingHandleCount
)++] = HandleBuffer
[HandleIndex
];
3305 // Make the last one NULL
3307 (*MatchingHandleBuffer
)[*MatchingHandleCount
] = NULL
;
3309 Status
= EFI_SUCCESS
;
3310 } // *MatchingHandleBuffer == NULL (ELSE)
3311 } // MacthingHandleBuffer == NULL (ELSE)
3312 } // *MatchingHandleCount == 0 (ELSE)
3313 } // no error on ParseHandleDatabaseByRelationshipWithType
3315 if (HandleBuffer
!= NULL
) {
3316 FreePool (HandleBuffer
);
3319 if (HandleType
!= NULL
) {
3320 FreePool (HandleType
);
3323 ASSERT ((MatchingHandleBuffer
== NULL
) ||
3324 (*MatchingHandleCount
== 0 && *MatchingHandleBuffer
== NULL
) ||
3325 (*MatchingHandleCount
!= 0 && *MatchingHandleBuffer
!= NULL
));
3330 Gets handles for any child controllers of the passed in controller.
3332 @param[in] ControllerHandle The handle of the "parent controller"
3333 @param[out] MatchingHandleCount Pointer to the number of handles in
3334 MatchingHandleBuffer on return.
3335 @param[out] MatchingHandleBuffer Buffer containing handles on a successful
3339 @retval EFI_SUCCESS The operation was sucessful.
3343 ParseHandleDatabaseForChildControllers(
3344 IN CONST EFI_HANDLE ControllerHandle
,
3345 OUT UINTN
*MatchingHandleCount
,
3346 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
3351 UINTN DriverBindingHandleCount
;
3352 EFI_HANDLE
*DriverBindingHandleBuffer
;
3353 UINTN DriverBindingHandleIndex
;
3354 UINTN ChildControllerHandleCount
;
3355 EFI_HANDLE
*ChildControllerHandleBuffer
;
3356 UINTN ChildControllerHandleIndex
;
3357 EFI_HANDLE
*HandleBufferForReturn
;
3359 if (MatchingHandleCount
== NULL
) {
3360 return (EFI_INVALID_PARAMETER
);
3362 *MatchingHandleCount
= 0;
3364 Status
= PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
3366 &DriverBindingHandleCount
,
3367 &DriverBindingHandleBuffer
3369 if (EFI_ERROR (Status
)) {
3374 // Get a buffer big enough for all the controllers.
3376 HandleBufferForReturn
= GetHandleListByProtocol(NULL
);
3377 if (HandleBufferForReturn
== NULL
) {
3378 FreePool (DriverBindingHandleBuffer
);
3379 return (EFI_NOT_FOUND
);
3382 for (DriverBindingHandleIndex
= 0; DriverBindingHandleIndex
< DriverBindingHandleCount
; DriverBindingHandleIndex
++) {
3383 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
3384 DriverBindingHandleBuffer
[DriverBindingHandleIndex
],
3386 &ChildControllerHandleCount
,
3387 &ChildControllerHandleBuffer
3389 if (EFI_ERROR (Status
)) {
3393 for (ChildControllerHandleIndex
= 0;
3394 ChildControllerHandleIndex
< ChildControllerHandleCount
;
3395 ChildControllerHandleIndex
++
3397 for (HandleIndex
= 0; HandleIndex
< *MatchingHandleCount
; HandleIndex
++) {
3398 if (HandleBufferForReturn
[HandleIndex
] == ChildControllerHandleBuffer
[ChildControllerHandleIndex
]) {
3402 if (HandleIndex
>= *MatchingHandleCount
) {
3403 HandleBufferForReturn
[(*MatchingHandleCount
)++] = ChildControllerHandleBuffer
[ChildControllerHandleIndex
];
3407 FreePool (ChildControllerHandleBuffer
);
3410 FreePool (DriverBindingHandleBuffer
);
3412 if (MatchingHandleBuffer
== NULL
|| *MatchingHandleCount
== 0) {
3414 // The caller is not interested in the actual handles, or we've found none.
3416 FreePool (HandleBufferForReturn
);
3417 HandleBufferForReturn
= NULL
;
3420 if (MatchingHandleBuffer
!= NULL
) {
3421 *MatchingHandleBuffer
= HandleBufferForReturn
;
3424 ASSERT ((MatchingHandleBuffer
== NULL
) ||
3425 (*MatchingHandleCount
== 0 && *MatchingHandleBuffer
== NULL
) ||
3426 (*MatchingHandleCount
!= 0 && *MatchingHandleBuffer
!= NULL
));
3428 return (EFI_SUCCESS
);
3432 Appends 1 buffer to another buffer. This will re-allocate the destination buffer
3433 if necessary to fit all of the data.
3435 If DestinationBuffer is NULL, then ASSERT().
3437 @param[in, out] DestinationBuffer The pointer to the pointer to the buffer to append onto.
3438 @param[in, out] DestinationSize The pointer to the size of DestinationBuffer.
3439 @param[in] SourceBuffer The pointer to the buffer to append onto DestinationBuffer.
3440 @param[in] SourceSize The number of bytes of SourceBuffer to append.
3442 @retval NULL A memory allocation failed.
3443 @retval NULL A parameter was invalid.
3444 @return A pointer to (*DestinationBuffer).
3448 IN OUT VOID
**DestinationBuffer
,
3449 IN OUT UINTN
*DestinationSize
,
3450 IN VOID
*SourceBuffer
,
3454 UINTN LocalDestinationSize
;
3455 UINTN LocalDestinationFinalSize
;
3457 ASSERT(DestinationBuffer
!= NULL
);
3459 if (SourceSize
== 0 || SourceBuffer
== NULL
) {
3460 return (*DestinationBuffer
);
3463 if (DestinationSize
== NULL
) {
3464 LocalDestinationSize
= 0;
3466 LocalDestinationSize
= *DestinationSize
;
3469 LocalDestinationFinalSize
= LocalDestinationSize
+ SourceSize
;
3471 if (DestinationSize
!= NULL
) {
3472 *DestinationSize
= LocalDestinationSize
;
3475 if (LocalDestinationSize
== 0) {
3477 *DestinationBuffer
= AllocateZeroPool(LocalDestinationFinalSize
);
3480 *DestinationBuffer
= ReallocatePool(LocalDestinationSize
, LocalDestinationFinalSize
, *DestinationBuffer
);
3483 ASSERT(*DestinationBuffer
!= NULL
);
3486 return (CopyMem(((UINT8
*)(*DestinationBuffer
)) + LocalDestinationSize
, SourceBuffer
, SourceSize
));
3490 Gets handles for any child devices produced by the passed in driver.
3492 @param[in] DriverHandle The handle of the driver.
3493 @param[in] MatchingHandleCount Pointer to the number of handles in
3494 MatchingHandleBuffer on return.
3495 @param[out] MatchingHandleBuffer Buffer containing handles on a successful
3497 @retval EFI_SUCCESS The operation was sucessful.
3498 @sa ParseHandleDatabaseByRelationship
3502 ParseHandleDatabaseForChildDevices(
3503 IN CONST EFI_HANDLE DriverHandle
,
3504 IN UINTN
*MatchingHandleCount
,
3505 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
3509 EFI_HANDLE
*Buffer2
;
3514 UINTN HandleBufferSize
;
3516 ASSERT(MatchingHandleCount
!= NULL
);
3518 HandleBufferSize
= 0;
3521 *MatchingHandleCount
= 0;
3523 Status
= PARSE_HANDLE_DATABASE_DEVICES (
3528 if (!EFI_ERROR (Status
)) {
3529 for (HandleIndex
= 0; HandleIndex
< Count1
; HandleIndex
++) {
3531 // now find the children
3533 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
3535 Buffer
[HandleIndex
],
3539 if (EFI_ERROR(Status
)) {
3543 // save out required and optional data elements
3545 *MatchingHandleCount
+= Count2
;
3546 if (MatchingHandleBuffer
!= NULL
) {
3547 *MatchingHandleBuffer
= BuffernCatGrow((VOID
**)MatchingHandleBuffer
, &HandleBufferSize
, Buffer2
, Count2
* sizeof(Buffer2
[0]));
3553 if (Buffer2
!= NULL
) {
3559 if (Buffer
!= NULL
) {
3566 Function to get all handles that support a given protocol or all handles.
3568 @param[in] ProtocolGuid The guid of the protocol to get handles for. If NULL
3569 then the function will return all handles.
3571 @retval NULL A memory allocation failed.
3572 @return A NULL terminated list of handles.
3576 GetHandleListByProtocol (
3577 IN CONST EFI_GUID
*ProtocolGuid OPTIONAL
3580 EFI_HANDLE
*HandleList
;
3588 // We cannot use LocateHandleBuffer since we need that NULL item on the ends of the list!
3590 if (ProtocolGuid
== NULL
) {
3591 Status
= gBS
->LocateHandle(AllHandles
, NULL
, NULL
, &Size
, HandleList
);
3592 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3593 HandleList
= AllocateZeroPool(Size
+ sizeof(EFI_HANDLE
));
3594 if (HandleList
== NULL
) {
3597 Status
= gBS
->LocateHandle(AllHandles
, NULL
, NULL
, &Size
, HandleList
);
3598 HandleList
[Size
/sizeof(EFI_HANDLE
)] = NULL
;
3601 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)ProtocolGuid
, NULL
, &Size
, HandleList
);
3602 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3603 HandleList
= AllocateZeroPool(Size
+ sizeof(EFI_HANDLE
));
3604 if (HandleList
== NULL
) {
3607 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)ProtocolGuid
, NULL
, &Size
, HandleList
);
3608 HandleList
[Size
/sizeof(EFI_HANDLE
)] = NULL
;
3611 if (EFI_ERROR(Status
)) {
3612 if (HandleList
!= NULL
) {
3613 FreePool(HandleList
);
3617 return (HandleList
);
3621 Function to get all handles that support some protocols.
3623 @param[in] ProtocolGuids A NULL terminated list of protocol GUIDs.
3625 @retval NULL A memory allocation failed.
3626 @retval NULL ProtocolGuids was NULL.
3627 @return A NULL terminated list of EFI_HANDLEs.
3631 GetHandleListByProtocolList (
3632 IN CONST EFI_GUID
**ProtocolGuids
3635 EFI_HANDLE
*HandleList
;
3640 CONST EFI_GUID
**GuidWalker
;
3641 EFI_HANDLE
*HandleWalker1
;
3642 EFI_HANDLE
*HandleWalker2
;
3646 TotalSize
= sizeof(EFI_HANDLE
);
3648 for (GuidWalker
= ProtocolGuids
; GuidWalker
!= NULL
&& *GuidWalker
!= NULL
; GuidWalker
++,Size
= 0){
3649 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)(*GuidWalker
), NULL
, &Size
, NULL
);
3650 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3656 // No handles were found...
3658 if (TotalSize
== sizeof(EFI_HANDLE
)) {
3662 HandleList
= AllocateZeroPool(TotalSize
);
3663 if (HandleList
== NULL
) {
3668 for (GuidWalker
= ProtocolGuids
; GuidWalker
!= NULL
&& *GuidWalker
!= NULL
; GuidWalker
++){
3669 TempSize
= TotalSize
- Size
;
3670 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)(*GuidWalker
), NULL
, &TempSize
, HandleList
+(Size
/sizeof(EFI_HANDLE
)));
3673 // Allow for missing protocols... Only update the 'used' size upon success.
3675 if (!EFI_ERROR(Status
)) {
3679 ASSERT(HandleList
[(TotalSize
/sizeof(EFI_HANDLE
))-1] == NULL
);
3681 for (HandleWalker1
= HandleList
; HandleWalker1
!= NULL
&& *HandleWalker1
!= NULL
; HandleWalker1
++) {
3682 for (HandleWalker2
= HandleWalker1
+ 1; HandleWalker2
!= NULL
&& *HandleWalker2
!= NULL
; HandleWalker2
++) {
3683 if (*HandleWalker1
== *HandleWalker2
) {
3685 // copy memory back 1 handle width.
3687 CopyMem(HandleWalker2
, HandleWalker2
+ 1, TotalSize
- ((HandleWalker2
-HandleList
+1)*sizeof(EFI_HANDLE
)));
3692 return (HandleList
);
3696 Return all supported GUIDs.
3698 @param[out] Guids The buffer to return all supported GUIDs.
3699 @param[in, out] Count On input, the count of GUIDs the buffer can hold,
3700 On output, the count of GUIDs to return.
3702 @retval EFI_INVALID_PARAMETER Count is NULL.
3703 @retval EFI_BUFFER_TOO_SMALL Buffer is not enough to hold all GUIDs.
3704 @retval EFI_SUCCESS GUIDs are returned successfully.
3708 GetAllMappingGuids (
3709 OUT EFI_GUID
*Guids
,
3717 if (Count
== NULL
) {
3718 return EFI_INVALID_PARAMETER
;
3722 if (PcdGetBool (PcdShellIncludeNtGuids
)) {
3723 NtGuidCount
= ARRAY_SIZE (mGuidStringListNT
) - 1;
3725 GuidCount
= ARRAY_SIZE (mGuidStringList
) - 1;
3727 if (*Count
< NtGuidCount
+ GuidCount
+ mGuidListCount
) {
3728 *Count
= NtGuidCount
+ GuidCount
+ mGuidListCount
;
3729 return EFI_BUFFER_TOO_SMALL
;
3732 for (Index
= 0; Index
< NtGuidCount
; Index
++) {
3733 CopyGuid (&Guids
[Index
], mGuidStringListNT
[Index
].GuidId
);
3736 for (Index
= 0; Index
< GuidCount
; Index
++) {
3737 CopyGuid (&Guids
[NtGuidCount
+ Index
], mGuidStringList
[Index
].GuidId
);
3740 for (Index
= 0; Index
< mGuidListCount
; Index
++) {
3741 CopyGuid (&Guids
[NtGuidCount
+ GuidCount
+ Index
], mGuidList
[Index
].GuidId
);