2 Provides interface to advanced shell functionality for parsing both handle and protocol database.
4 Copyright (c) 2013 - 2014, Hewlett-Packard Development Company, L.P.
5 Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
16 #include "UefiHandleParsingLib.h"
17 #include "IndustryStandard/Acpi10.h"
19 EFI_HANDLE mHandleParsingHiiHandle
= NULL
;
20 HANDLE_INDEX_LIST mHandleList
= {{{NULL
,NULL
},0,0},0};
21 GUID_INFO_BLOCK
*GuidList
;
24 Function to translate the EFI_MEMORY_TYPE into a string.
26 @param[in] Memory The memory type.
28 @retval A string representation of the type allocated from BS Pool.
33 IN CONST EFI_MEMORY_TYPE Memory
40 case EfiReservedMemoryType
: StrnCatGrow(&RetVal
, NULL
, L
"EfiReservedMemoryType", 0); break;
41 case EfiLoaderCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiLoaderCode", 0); break;
42 case EfiLoaderData
: StrnCatGrow(&RetVal
, NULL
, L
"EfiLoaderData", 0); break;
43 case EfiBootServicesCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiBootServicesCode", 0); break;
44 case EfiBootServicesData
: StrnCatGrow(&RetVal
, NULL
, L
"EfiBootServicesData", 0); break;
45 case EfiRuntimeServicesCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiRuntimeServicesCode", 0); break;
46 case EfiRuntimeServicesData
: StrnCatGrow(&RetVal
, NULL
, L
"EfiRuntimeServicesData", 0); break;
47 case EfiConventionalMemory
: StrnCatGrow(&RetVal
, NULL
, L
"EfiConventionalMemory", 0); break;
48 case EfiUnusableMemory
: StrnCatGrow(&RetVal
, NULL
, L
"EfiUnusableMemory", 0); break;
49 case EfiACPIReclaimMemory
: StrnCatGrow(&RetVal
, NULL
, L
"EfiACPIReclaimMemory", 0); break;
50 case EfiACPIMemoryNVS
: StrnCatGrow(&RetVal
, NULL
, L
"EfiACPIMemoryNVS", 0); break;
51 case EfiMemoryMappedIO
: StrnCatGrow(&RetVal
, NULL
, L
"EfiMemoryMappedIO", 0); break;
52 case EfiMemoryMappedIOPortSpace
: StrnCatGrow(&RetVal
, NULL
, L
"EfiMemoryMappedIOPortSpace", 0); break;
53 case EfiPalCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiPalCode", 0); break;
54 case EfiMaxMemoryType
: StrnCatGrow(&RetVal
, NULL
, L
"EfiMaxMemoryType", 0); break;
55 default: ASSERT(FALSE
);
61 Function to translate the EFI_GRAPHICS_PIXEL_FORMAT into a string.
63 @param[in] Fmt The format type.
65 @retval A string representation of the type allocated from BS Pool.
70 IN CONST EFI_GRAPHICS_PIXEL_FORMAT Fmt
77 case PixelRedGreenBlueReserved8BitPerColor
: StrnCatGrow(&RetVal
, NULL
, L
"PixelRedGreenBlueReserved8BitPerColor", 0); break;
78 case PixelBlueGreenRedReserved8BitPerColor
: StrnCatGrow(&RetVal
, NULL
, L
"PixelBlueGreenRedReserved8BitPerColor", 0); break;
79 case PixelBitMask
: StrnCatGrow(&RetVal
, NULL
, L
"PixelBitMask", 0); break;
80 case PixelBltOnly
: StrnCatGrow(&RetVal
, NULL
, L
"PixelBltOnly", 0); break;
81 case PixelFormatMax
: StrnCatGrow(&RetVal
, NULL
, L
"PixelFormatMax", 0); break;
82 default: ASSERT(FALSE
);
88 Constructor for the library.
90 @param[in] ImageHandle Ignored.
91 @param[in] SystemTable Ignored.
93 @retval EFI_SUCCESS The operation was successful.
97 HandleParsingLibConstructor (
98 IN EFI_HANDLE ImageHandle
,
99 IN EFI_SYSTEM_TABLE
*SystemTable
106 // Do nothing with mHandleParsingHiiHandle. Initialize HII as needed.
108 return (EFI_SUCCESS
);
112 Initialization function for HII packages.
116 HandleParsingHiiInit (VOID
)
118 if (mHandleParsingHiiHandle
== NULL
) {
119 mHandleParsingHiiHandle
= HiiAddPackages (&gHandleParsingHiiGuid
, gImageHandle
, UefiHandleParsingLibStrings
, NULL
);
120 ASSERT (mHandleParsingHiiHandle
!= NULL
);
125 Destructor for the library. free any resources.
127 @param[in] ImageHandle Ignored.
128 @param[in] SystemTable Ignored.
130 @retval EFI_SUCCESS The operation was successful.
134 HandleParsingLibDestructor (
135 IN EFI_HANDLE ImageHandle
,
136 IN EFI_SYSTEM_TABLE
*SystemTable
141 for (LoopCount
= 0; GuidList
!= NULL
&& LoopCount
< GuidListCount
; LoopCount
++) {
142 SHELL_FREE_NON_NULL(GuidList
[LoopCount
].GuidId
);
145 SHELL_FREE_NON_NULL(GuidList
);
146 if (mHandleParsingHiiHandle
!= NULL
) {
147 HiiRemovePackages(mHandleParsingHiiHandle
);
149 return (EFI_SUCCESS
);
153 Function to dump information about LoadedImage.
155 This will allocate the return buffer from boot services pool.
157 @param[in] TheHandle The handle that has LoadedImage installed.
158 @param[in] Verbose TRUE for additional information, FALSE otherwise.
160 @retval A poitner to a string containing the information.
164 LoadedImageProtocolDumpInformation(
165 IN CONST EFI_HANDLE TheHandle
,
166 IN CONST BOOLEAN Verbose
169 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
177 return (CatSPrint(NULL
, L
"LoadedImage"));
180 HandleParsingHiiInit();
182 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_LI_DUMP_MAIN
), NULL
);
183 RetVal
= AllocateZeroPool (PcdGet16 (PcdShellPrintBufferSize
));
184 if (Temp
== NULL
|| RetVal
== NULL
) {
185 SHELL_FREE_NON_NULL(Temp
);
186 SHELL_FREE_NON_NULL(RetVal
);
190 Status
= gBS
->OpenProtocol (
192 &gEfiLoadedImageProtocolGuid
,
193 (VOID
**)&LoadedImage
,
196 EFI_OPEN_PROTOCOL_GET_PROTOCOL
199 if (EFI_ERROR (Status
)) {
200 SHELL_FREE_NON_NULL (Temp
);
201 SHELL_FREE_NON_NULL (RetVal
);
205 DataType
= ConvertMemoryType(LoadedImage
->ImageDataType
);
206 CodeType
= ConvertMemoryType(LoadedImage
->ImageCodeType
);
208 RetVal
= CatSPrint(RetVal
,
210 LoadedImage
->Revision
,
211 LoadedImage
->ParentHandle
,
212 LoadedImage
->SystemTable
,
213 LoadedImage
->DeviceHandle
,
214 LoadedImage
->FilePath
,
215 LoadedImage
->LoadOptionsSize
,
216 LoadedImage
->LoadOptions
,
217 LoadedImage
->ImageBase
,
218 LoadedImage
->ImageSize
,
221 LoadedImage
->Unload
);
224 SHELL_FREE_NON_NULL(Temp
);
225 SHELL_FREE_NON_NULL(CodeType
);
226 SHELL_FREE_NON_NULL(DataType
);
232 Function to dump information about GOP.
234 This will allocate the return buffer from boot services pool.
236 @param[in] TheHandle The handle that has LoadedImage installed.
237 @param[in] Verbose TRUE for additional information, FALSE otherwise.
239 @retval A poitner to a string containing the information.
243 GraphicsOutputProtocolDumpInformation(
244 IN CONST EFI_HANDLE TheHandle
,
245 IN CONST BOOLEAN Verbose
248 EFI_GRAPHICS_OUTPUT_PROTOCOL
*GraphicsOutput
;
255 return (CatSPrint(NULL
, L
"GraphicsOutput"));
258 HandleParsingHiiInit();
260 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_GOP_DUMP_MAIN
), NULL
);
261 RetVal
= AllocateZeroPool (PcdGet16 (PcdShellPrintBufferSize
));
262 if (Temp
== NULL
|| RetVal
== NULL
) {
263 SHELL_FREE_NON_NULL(Temp
);
264 SHELL_FREE_NON_NULL(RetVal
);
268 Status
= gBS
->OpenProtocol (
270 &gEfiGraphicsOutputProtocolGuid
,
271 (VOID
**)&GraphicsOutput
,
274 EFI_OPEN_PROTOCOL_GET_PROTOCOL
277 if (EFI_ERROR (Status
)) {
278 SHELL_FREE_NON_NULL (Temp
);
279 SHELL_FREE_NON_NULL (RetVal
);
283 Fmt
= ConvertPixelFormat(GraphicsOutput
->Mode
->Info
->PixelFormat
);
285 RetVal
= CatSPrint(RetVal
,
287 GraphicsOutput
->Mode
->MaxMode
,
288 GraphicsOutput
->Mode
->Mode
,
289 GraphicsOutput
->Mode
->FrameBufferBase
,
290 (UINT64
)GraphicsOutput
->Mode
->FrameBufferSize
,
291 (UINT64
)GraphicsOutput
->Mode
->SizeOfInfo
,
292 GraphicsOutput
->Mode
->Info
->Version
,
293 GraphicsOutput
->Mode
->Info
->HorizontalResolution
,
294 GraphicsOutput
->Mode
->Info
->VerticalResolution
,
296 GraphicsOutput
->Mode
->Info
->PixelsPerScanLine
,
297 GraphicsOutput
->Mode
->Info
->PixelFormat
!=PixelBitMask
?0:GraphicsOutput
->Mode
->Info
->PixelInformation
.RedMask
,
298 GraphicsOutput
->Mode
->Info
->PixelFormat
!=PixelBitMask
?0:GraphicsOutput
->Mode
->Info
->PixelInformation
.GreenMask
,
299 GraphicsOutput
->Mode
->Info
->PixelFormat
!=PixelBitMask
?0:GraphicsOutput
->Mode
->Info
->PixelInformation
.BlueMask
302 SHELL_FREE_NON_NULL(Temp
);
303 SHELL_FREE_NON_NULL(Fmt
);
309 Function to dump information about PciRootBridgeIo.
311 This will allocate the return buffer from boot services pool.
313 @param[in] TheHandle The handle that has PciRootBridgeIo installed.
314 @param[in] Verbose TRUE for additional information, FALSE otherwise.
316 @retval A poitner to a string containing the information.
320 PciRootBridgeIoDumpInformation(
321 IN CONST EFI_HANDLE TheHandle
,
322 IN CONST BOOLEAN Verbose
325 EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL
*PciRootBridgeIo
;
326 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR
*Configuration
;
337 return (CatSPrint(NULL
, L
"PciRootBridgeIo"));
340 HandleParsingHiiInit();
342 Status
= gBS
->HandleProtocol(
344 &gEfiPciRootBridgeIoProtocolGuid
,
345 (VOID
**)&PciRootBridgeIo
);
347 if (EFI_ERROR(Status
)) {
351 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_PH
), NULL
);
352 ASSERT (Temp
!= NULL
);
353 Temp2
= CatSPrint(L
"\r\n", Temp
, PciRootBridgeIo
->ParentHandle
);
358 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_SEG
), NULL
);
359 ASSERT (Temp
!= NULL
);
360 Temp2
= CatSPrint(RetVal
, Temp
, PciRootBridgeIo
->SegmentNumber
);
368 Status
= PciRootBridgeIo
->GetAttributes (PciRootBridgeIo
, &Supports
, &Attributes
);
369 if (!EFI_ERROR(Status
)) {
370 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_ATT
), NULL
);
371 ASSERT (Temp
!= NULL
);
372 Temp2
= CatSPrint(RetVal
, Temp
, Attributes
);
378 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_SUPPORTS
), NULL
);
379 ASSERT (Temp
!= NULL
);
380 Temp2
= CatSPrint(RetVal
, Temp
, Supports
);
387 Configuration
= NULL
;
388 Status
= PciRootBridgeIo
->Configuration (PciRootBridgeIo
, (VOID
**) &Configuration
);
389 if (!EFI_ERROR(Status
) && Configuration
!= NULL
) {
390 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_TITLE
), NULL
);
391 ASSERT (Temp
!= NULL
);
392 Temp2
= CatSPrint(RetVal
, Temp
, Supports
);
397 while (Configuration
->Desc
== ACPI_ADDRESS_SPACE_DESCRIPTOR
) {
399 switch (Configuration
->ResType
) {
400 case ACPI_ADDRESS_SPACE_TYPE_MEM
:
401 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_MEM
), NULL
);
403 case ACPI_ADDRESS_SPACE_TYPE_IO
:
404 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_IO
), NULL
);
406 case ACPI_ADDRESS_SPACE_TYPE_BUS
:
407 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_BUS
), NULL
);
411 Temp2
= CatSPrint(RetVal
, L
"%s", Temp
);
418 Temp2
= CatSPrint(RetVal
,
419 L
"%H%02x %016lx %016lx %02x%N\r\n",
420 Configuration
->SpecificFlag
,
421 Configuration
->AddrRangeMin
,
422 Configuration
->AddrRangeMax
,
423 Configuration
->AddrSpaceGranularity
435 Function to dump information about SimpleTextOut.
437 This will allocate the return buffer from boot services pool.
439 @param[in] TheHandle The handle that has SimpleTextOut installed.
440 @param[in] Verbose TRUE for additional information, FALSE otherwise.
442 @retval A poitner to a string containing the information.
446 TxtOutProtocolDumpInformation(
447 IN CONST EFI_HANDLE TheHandle
,
448 IN CONST BOOLEAN Verbose
451 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL
*Dev
;
465 HandleParsingHiiInit();
470 Status
= gBS
->HandleProtocol(
472 &gEfiSimpleTextOutProtocolGuid
,
475 ASSERT_EFI_ERROR(Status
);
476 ASSERT (Dev
!= NULL
&& Dev
->Mode
!= NULL
);
478 Size
= (Dev
->Mode
->MaxMode
+ 1) * 80;
479 RetVal
= AllocateZeroPool(Size
);
481 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_TXT_OUT_DUMP_HEADER
), NULL
);
483 UnicodeSPrint(RetVal
, Size
, Temp
, Dev
, Dev
->Mode
->Attribute
);
490 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_TXT_OUT_DUMP_LINE
), NULL
);
491 for (Index
= 0; Index
< Dev
->Mode
->MaxMode
; Index
++) {
492 Status
= Dev
->QueryMode (Dev
, Index
, &Col
, &Row
);
493 NewSize
= Size
- StrSize(RetVal
);
495 RetVal
+ StrLen(RetVal
),
497 Temp
== NULL
?L
"":Temp
,
498 Index
== Dev
->Mode
->Mode
? L
'*' : L
' ',
500 !EFI_ERROR(Status
)?(INTN
)Col
:-1,
501 !EFI_ERROR(Status
)?(INTN
)Row
:-1
508 STATIC CONST UINTN VersionStringSize
= 60;
511 Function to dump information about EfiDriverSupportedEfiVersion protocol.
513 This will allocate the return buffer from boot services pool.
515 @param[in] TheHandle The handle that has the protocol installed.
516 @param[in] Verbose TRUE for additional information, FALSE otherwise.
518 @retval A poitner to a string containing the information.
522 DriverEfiVersionProtocolDumpInformation(
523 IN CONST EFI_HANDLE TheHandle
,
524 IN CONST BOOLEAN Verbose
527 EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL
*DriverEfiVersion
;
531 Status
= gBS
->HandleProtocol(
533 &gEfiDriverSupportedEfiVersionProtocolGuid
,
534 (VOID
**)&DriverEfiVersion
);
536 ASSERT_EFI_ERROR(Status
);
538 RetVal
= AllocateZeroPool(VersionStringSize
);
539 ASSERT(RetVal
!= NULL
);
540 UnicodeSPrint(RetVal
, VersionStringSize
, L
"0x%08x", DriverEfiVersion
->FirmwareVersion
);
545 Function to dump information about DevicePath protocol.
547 This will allocate the return buffer from boot services pool.
549 @param[in] TheHandle The handle that has the protocol installed.
550 @param[in] Verbose TRUE for additional information, FALSE otherwise.
552 @retval A poitner to a string containing the information.
556 DevicePathProtocolDumpInformation(
557 IN CONST EFI_HANDLE TheHandle
,
558 IN CONST BOOLEAN Verbose
561 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
567 Status
= gBS
->OpenProtocol(TheHandle
, &gEfiDevicePathProtocolGuid
, (VOID
**)&DevPath
, gImageHandle
, NULL
, EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
568 if (!EFI_ERROR(Status
)) {
570 // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)
572 Temp
= ConvertDevicePathToText(DevPath
, TRUE
, TRUE
);
573 gBS
->CloseProtocol(TheHandle
, &gEfiDevicePathProtocolGuid
, gImageHandle
, NULL
);
575 if (!Verbose
&& Temp
!= NULL
&& StrLen(Temp
) > 30) {
577 Temp2
= StrnCatGrow(&Temp2
, NULL
, Temp
+(StrLen(Temp
) - 30), 30);
585 // Put the information on the NT32 protocol GUIDs here so we are not dependant on the Nt32Pkg
587 #define LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID \
589 0x58c518b1, 0x76f3, 0x11d4, { 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
592 #define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \
594 0x96eb4ad6, 0xa32a, 0x11d4, { 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
597 #define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \
599 0xc95a93d, 0xa006, 0x11d4, { 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
601 STATIC CONST EFI_GUID WinNtThunkProtocolGuid
= LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID
;
602 STATIC CONST EFI_GUID WinNtIoProtocolGuid
= LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID
;
603 STATIC CONST EFI_GUID WinNtSerialPortGuid
= LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID
;
605 STATIC CONST GUID_INFO_BLOCK mGuidStringListNT
[] = {
606 {STRING_TOKEN(STR_WINNT_THUNK
), (EFI_GUID
*)&WinNtThunkProtocolGuid
, NULL
},
607 {STRING_TOKEN(STR_WINNT_DRIVER_IO
), (EFI_GUID
*)&WinNtIoProtocolGuid
, NULL
},
608 {STRING_TOKEN(STR_WINNT_SERIAL_PORT
), (EFI_GUID
*)&WinNtSerialPortGuid
, NULL
},
609 {STRING_TOKEN(STR_UNKNOWN_DEVICE
), NULL
, NULL
},
612 STATIC CONST GUID_INFO_BLOCK mGuidStringList
[] = {
613 {STRING_TOKEN(STR_LOADED_IMAGE
), &gEfiLoadedImageProtocolGuid
, LoadedImageProtocolDumpInformation
},
614 {STRING_TOKEN(STR_DEVICE_PATH
), &gEfiDevicePathProtocolGuid
, DevicePathProtocolDumpInformation
},
615 {STRING_TOKEN(STR_IMAGE_PATH
), &gEfiLoadedImageDevicePathProtocolGuid
, DevicePathProtocolDumpInformation
},
616 {STRING_TOKEN(STR_DEVICE_PATH_UTIL
), &gEfiDevicePathUtilitiesProtocolGuid
, NULL
},
617 {STRING_TOKEN(STR_DEVICE_PATH_TXT
), &gEfiDevicePathToTextProtocolGuid
, NULL
},
618 {STRING_TOKEN(STR_DEVICE_PATH_FTXT
), &gEfiDevicePathFromTextProtocolGuid
, NULL
},
619 {STRING_TOKEN(STR_DEVICE_PATH_PC
), &gEfiPcAnsiGuid
, NULL
},
620 {STRING_TOKEN(STR_DEVICE_PATH_VT100
), &gEfiVT100Guid
, NULL
},
621 {STRING_TOKEN(STR_DEVICE_PATH_VT100P
), &gEfiVT100PlusGuid
, NULL
},
622 {STRING_TOKEN(STR_DEVICE_PATH_VTUTF8
), &gEfiVTUTF8Guid
, NULL
},
623 {STRING_TOKEN(STR_DRIVER_BINDING
), &gEfiDriverBindingProtocolGuid
, NULL
},
624 {STRING_TOKEN(STR_PLATFORM_OVERRIDE
), &gEfiPlatformDriverOverrideProtocolGuid
, NULL
},
625 {STRING_TOKEN(STR_BUS_OVERRIDE
), &gEfiBusSpecificDriverOverrideProtocolGuid
, NULL
},
626 {STRING_TOKEN(STR_DRIVER_DIAG
), &gEfiDriverDiagnosticsProtocolGuid
, NULL
},
627 {STRING_TOKEN(STR_DRIVER_DIAG2
), &gEfiDriverDiagnostics2ProtocolGuid
, NULL
},
628 {STRING_TOKEN(STR_DRIVER_CN
), &gEfiComponentNameProtocolGuid
, NULL
},
629 {STRING_TOKEN(STR_DRIVER_CN2
), &gEfiComponentName2ProtocolGuid
, NULL
},
630 {STRING_TOKEN(STR_PLAT_DRV_CFG
), &gEfiPlatformToDriverConfigurationProtocolGuid
, NULL
},
631 {STRING_TOKEN(STR_DRIVER_VERSION
), &gEfiDriverSupportedEfiVersionProtocolGuid
, DriverEfiVersionProtocolDumpInformation
},
632 {STRING_TOKEN(STR_TXT_IN
), &gEfiSimpleTextInProtocolGuid
, NULL
},
633 {STRING_TOKEN(STR_TXT_IN_EX
), &gEfiSimpleTextInputExProtocolGuid
, NULL
},
634 {STRING_TOKEN(STR_TXT_OUT
), &gEfiSimpleTextOutProtocolGuid
, TxtOutProtocolDumpInformation
},
635 {STRING_TOKEN(STR_SIM_POINTER
), &gEfiSimplePointerProtocolGuid
, NULL
},
636 {STRING_TOKEN(STR_ABS_POINTER
), &gEfiAbsolutePointerProtocolGuid
, NULL
},
637 {STRING_TOKEN(STR_SERIAL_IO
), &gEfiSerialIoProtocolGuid
, NULL
},
638 {STRING_TOKEN(STR_GRAPHICS_OUTPUT
), &gEfiGraphicsOutputProtocolGuid
, GraphicsOutputProtocolDumpInformation
},
639 {STRING_TOKEN(STR_EDID_DISCOVERED
), &gEfiEdidDiscoveredProtocolGuid
, NULL
},
640 {STRING_TOKEN(STR_EDID_ACTIVE
), &gEfiEdidActiveProtocolGuid
, NULL
},
641 {STRING_TOKEN(STR_EDID_OVERRIDE
), &gEfiEdidOverrideProtocolGuid
, NULL
},
642 {STRING_TOKEN(STR_CON_IN
), &gEfiConsoleInDeviceGuid
, NULL
},
643 {STRING_TOKEN(STR_CON_OUT
), &gEfiConsoleOutDeviceGuid
, NULL
},
644 {STRING_TOKEN(STR_STD_ERR
), &gEfiStandardErrorDeviceGuid
, NULL
},
645 {STRING_TOKEN(STR_LOAD_FILE
), &gEfiLoadFileProtocolGuid
, NULL
},
646 {STRING_TOKEN(STR_LOAD_FILE2
), &gEfiLoadFile2ProtocolGuid
, NULL
},
647 {STRING_TOKEN(STR_SIMPLE_FILE_SYS
), &gEfiSimpleFileSystemProtocolGuid
, NULL
},
648 {STRING_TOKEN(STR_TAPE_IO
), &gEfiTapeIoProtocolGuid
, NULL
},
649 {STRING_TOKEN(STR_DISK_IO
), &gEfiDiskIoProtocolGuid
, NULL
},
650 {STRING_TOKEN(STR_BLK_IO
), &gEfiBlockIoProtocolGuid
, NULL
},
651 {STRING_TOKEN(STR_UC
), &gEfiUnicodeCollationProtocolGuid
, NULL
},
652 {STRING_TOKEN(STR_UC2
), &gEfiUnicodeCollation2ProtocolGuid
, NULL
},
653 {STRING_TOKEN(STR_PCIRB_IO
), &gEfiPciRootBridgeIoProtocolGuid
, PciRootBridgeIoDumpInformation
},
654 {STRING_TOKEN(STR_PCI_IO
), &gEfiPciIoProtocolGuid
, NULL
},
655 {STRING_TOKEN(STR_SCSI_PT
), &gEfiScsiPassThruProtocolGuid
, NULL
},
656 {STRING_TOKEN(STR_SCSI_IO
), &gEfiScsiIoProtocolGuid
, NULL
},
657 {STRING_TOKEN(STR_SCSI_PT_EXT
), &gEfiExtScsiPassThruProtocolGuid
, NULL
},
658 {STRING_TOKEN(STR_ISCSI
), &gEfiIScsiInitiatorNameProtocolGuid
, NULL
},
659 {STRING_TOKEN(STR_USB_IO
), &gEfiUsbIoProtocolGuid
, NULL
},
660 {STRING_TOKEN(STR_USB_HC
), &gEfiUsbHcProtocolGuid
, NULL
},
661 {STRING_TOKEN(STR_USB_HC2
), &gEfiUsb2HcProtocolGuid
, NULL
},
662 {STRING_TOKEN(STR_DEBUG_SUPPORT
), &gEfiDebugSupportProtocolGuid
, NULL
},
663 {STRING_TOKEN(STR_DEBUG_PORT
), &gEfiDebugPortProtocolGuid
, NULL
},
664 {STRING_TOKEN(STR_DECOMPRESS
), &gEfiDecompressProtocolGuid
, NULL
},
665 {STRING_TOKEN(STR_ACPI_TABLE
), &gEfiAcpiTableProtocolGuid
, NULL
},
666 {STRING_TOKEN(STR_EBC_INTERPRETER
), &gEfiEbcProtocolGuid
, NULL
},
667 {STRING_TOKEN(STR_SNP
), &gEfiSimpleNetworkProtocolGuid
, NULL
},
668 {STRING_TOKEN(STR_NII
), &gEfiNetworkInterfaceIdentifierProtocolGuid
, NULL
},
669 {STRING_TOKEN(STR_NII_31
), &gEfiNetworkInterfaceIdentifierProtocolGuid_31
, NULL
},
670 {STRING_TOKEN(STR_PXE_BC
), &gEfiPxeBaseCodeProtocolGuid
, NULL
},
671 {STRING_TOKEN(STR_PXE_CB
), &gEfiPxeBaseCodeCallbackProtocolGuid
, NULL
},
672 {STRING_TOKEN(STR_BIS
), &gEfiBisProtocolGuid
, NULL
},
673 {STRING_TOKEN(STR_MNP_SB
), &gEfiManagedNetworkServiceBindingProtocolGuid
, NULL
},
674 {STRING_TOKEN(STR_MNP
), &gEfiManagedNetworkProtocolGuid
, NULL
},
675 {STRING_TOKEN(STR_ARP_SB
), &gEfiArpServiceBindingProtocolGuid
, NULL
},
676 {STRING_TOKEN(STR_ARP
), &gEfiArpProtocolGuid
, NULL
},
677 {STRING_TOKEN(STR_DHCPV4_SB
), &gEfiDhcp4ServiceBindingProtocolGuid
, NULL
},
678 {STRING_TOKEN(STR_DHCPV4
), &gEfiDhcp4ProtocolGuid
, NULL
},
679 {STRING_TOKEN(STR_TCPV4_SB
), &gEfiTcp4ServiceBindingProtocolGuid
, NULL
},
680 {STRING_TOKEN(STR_TCPV4
), &gEfiTcp4ProtocolGuid
, NULL
},
681 {STRING_TOKEN(STR_IPV4_SB
), &gEfiIp4ServiceBindingProtocolGuid
, NULL
},
682 {STRING_TOKEN(STR_IPV4
), &gEfiIp4ProtocolGuid
, NULL
},
683 {STRING_TOKEN(STR_IPV4_CFG
), &gEfiIp4ConfigProtocolGuid
, NULL
},
684 {STRING_TOKEN(STR_UDPV4_SB
), &gEfiUdp4ServiceBindingProtocolGuid
, NULL
},
685 {STRING_TOKEN(STR_UDPV4
), &gEfiUdp4ProtocolGuid
, NULL
},
686 {STRING_TOKEN(STR_MTFTPV4_SB
), &gEfiMtftp4ServiceBindingProtocolGuid
, NULL
},
687 {STRING_TOKEN(STR_MTFTPV4
), &gEfiMtftp4ProtocolGuid
, NULL
},
688 {STRING_TOKEN(STR_AUTH_INFO
), &gEfiAuthenticationInfoProtocolGuid
, NULL
},
689 {STRING_TOKEN(STR_HASH_SB
), &gEfiHashServiceBindingProtocolGuid
, NULL
},
690 {STRING_TOKEN(STR_HASH
), &gEfiHashProtocolGuid
, NULL
},
691 {STRING_TOKEN(STR_HII_FONT
), &gEfiHiiFontProtocolGuid
, NULL
},
692 {STRING_TOKEN(STR_HII_STRING
), &gEfiHiiStringProtocolGuid
, NULL
},
693 {STRING_TOKEN(STR_HII_IMAGE
), &gEfiHiiImageProtocolGuid
, NULL
},
694 {STRING_TOKEN(STR_HII_DATABASE
), &gEfiHiiDatabaseProtocolGuid
, NULL
},
695 {STRING_TOKEN(STR_HII_CONFIG_ROUT
), &gEfiHiiConfigRoutingProtocolGuid
, NULL
},
696 {STRING_TOKEN(STR_HII_CONFIG_ACC
), &gEfiHiiConfigAccessProtocolGuid
, NULL
},
697 {STRING_TOKEN(STR_HII_FORM_BROWSER2
), &gEfiFormBrowser2ProtocolGuid
, NULL
},
698 {STRING_TOKEN(STR_DRIVER_FAM_OVERRIDE
), &gEfiDriverFamilyOverrideProtocolGuid
, NULL
},
699 {STRING_TOKEN(STR_PCD
), &gPcdProtocolGuid
, NULL
},
700 {STRING_TOKEN(STR_TCG
), &gEfiTcgProtocolGuid
, NULL
},
701 {STRING_TOKEN(STR_HII_PACKAGE_LIST
), &gEfiHiiPackageListProtocolGuid
, NULL
},
704 // the ones under this are deprecated by the current UEFI Spec, but may be found anyways...
706 {STRING_TOKEN(STR_SHELL_INTERFACE
), &gEfiShellInterfaceGuid
, NULL
},
707 {STRING_TOKEN(STR_SHELL_ENV2
), &gEfiShellEnvironment2Guid
, NULL
},
708 {STRING_TOKEN(STR_SHELL_ENV
), &gEfiShellEnvironment2Guid
, NULL
},
709 {STRING_TOKEN(STR_DEVICE_IO
), &gEfiDeviceIoProtocolGuid
, NULL
},
710 {STRING_TOKEN(STR_UGA_DRAW
), &gEfiUgaDrawProtocolGuid
, NULL
},
711 {STRING_TOKEN(STR_UGA_IO
), &gEfiUgaIoProtocolGuid
, NULL
},
712 {STRING_TOKEN(STR_ESP
), &gEfiPartTypeSystemPartGuid
, NULL
},
713 {STRING_TOKEN(STR_GPT_NBR
), &gEfiPartTypeLegacyMbrGuid
, NULL
},
714 {STRING_TOKEN(STR_DRIVER_CONFIG
), &gEfiDriverConfigurationProtocolGuid
, NULL
},
715 {STRING_TOKEN(STR_DRIVER_CONFIG2
), &gEfiDriverConfiguration2ProtocolGuid
, NULL
},
718 // the ones under this are GUID identified structs, not protocols
720 {STRING_TOKEN(STR_FILE_INFO
), &gEfiFileInfoGuid
, NULL
},
721 {STRING_TOKEN(STR_FILE_SYS_INFO
), &gEfiFileSystemInfoGuid
, NULL
},
724 // the ones under this are misc GUIDS.
726 {STRING_TOKEN(STR_EFI_GLOBAL_VARIABLE
), &gEfiGlobalVariableGuid
, NULL
},
731 {STRING_TOKEN(STR_IP6_SB
), &gEfiIp6ServiceBindingProtocolGuid
, NULL
},
732 {STRING_TOKEN(STR_IP6
), &gEfiIp6ProtocolGuid
, NULL
},
733 {STRING_TOKEN(STR_IP6_CONFIG
), &gEfiIp6ConfigProtocolGuid
, NULL
},
734 {STRING_TOKEN(STR_MTFTP6_SB
), &gEfiMtftp6ServiceBindingProtocolGuid
, NULL
},
735 {STRING_TOKEN(STR_MTFTP6
), &gEfiMtftp6ProtocolGuid
, NULL
},
736 {STRING_TOKEN(STR_DHCP6_SB
), &gEfiDhcp6ServiceBindingProtocolGuid
, NULL
},
737 {STRING_TOKEN(STR_DHCP6
), &gEfiDhcp6ProtocolGuid
, NULL
},
738 {STRING_TOKEN(STR_UDP6_SB
), &gEfiUdp6ServiceBindingProtocolGuid
, NULL
},
739 {STRING_TOKEN(STR_UDP6
), &gEfiUdp6ProtocolGuid
, NULL
},
740 {STRING_TOKEN(STR_TCP6_SB
), &gEfiTcp6ServiceBindingProtocolGuid
, NULL
},
741 {STRING_TOKEN(STR_TCP6
), &gEfiTcp6ProtocolGuid
, NULL
},
742 {STRING_TOKEN(STR_VLAN_CONFIG
), &gEfiVlanConfigProtocolGuid
, NULL
},
743 {STRING_TOKEN(STR_EAP
), &gEfiEapProtocolGuid
, NULL
},
744 {STRING_TOKEN(STR_EAP_MGMT
), &gEfiEapManagementProtocolGuid
, NULL
},
745 {STRING_TOKEN(STR_FTP4_SB
), &gEfiFtp4ServiceBindingProtocolGuid
, NULL
},
746 {STRING_TOKEN(STR_FTP4
), &gEfiFtp4ProtocolGuid
, NULL
},
747 {STRING_TOKEN(STR_IP_SEC_CONFIG
), &gEfiIpSecConfigProtocolGuid
, NULL
},
748 {STRING_TOKEN(STR_DH
), &gEfiDriverHealthProtocolGuid
, NULL
},
749 {STRING_TOKEN(STR_DEF_IMG_LOAD
), &gEfiDeferredImageLoadProtocolGuid
, NULL
},
750 {STRING_TOKEN(STR_USER_CRED
), &gEfiUserCredentialProtocolGuid
, NULL
},
751 {STRING_TOKEN(STR_USER_MNGR
), &gEfiUserManagerProtocolGuid
, NULL
},
752 {STRING_TOKEN(STR_ATA_PASS_THRU
), &gEfiAtaPassThruProtocolGuid
, NULL
},
757 {STRING_TOKEN(STR_FW_MGMT
), &gEfiFirmwareManagementProtocolGuid
, NULL
},
758 {STRING_TOKEN(STR_IP_SEC
), &gEfiIpSecProtocolGuid
, NULL
},
759 {STRING_TOKEN(STR_IP_SEC2
), &gEfiIpSec2ProtocolGuid
, NULL
},
764 {STRING_TOKEN(STR_KMS
), &gEfiKmsProtocolGuid
, NULL
},
765 {STRING_TOKEN(STR_BLK_IO2
), &gEfiBlockIo2ProtocolGuid
, NULL
},
766 {STRING_TOKEN(STR_SSC
), &gEfiStorageSecurityCommandProtocolGuid
, NULL
},
767 {STRING_TOKEN(STR_UCRED2
), &gEfiUserCredential2ProtocolGuid
, NULL
},
772 {STRING_TOKEN(STR_DISK_IO2
), &gEfiDiskIo2ProtocolGuid
, NULL
},
773 {STRING_TOKEN(STR_ADAPTER_INFO
), &gEfiAdapterInformationProtocolGuid
, NULL
},
778 {STRING_TOKEN(STR_IDE_CONT_INIT
), &gEfiIdeControllerInitProtocolGuid
, NULL
},
781 // UEFI Shell Spec 2.0
783 {STRING_TOKEN(STR_SHELL_PARAMETERS
), &gEfiShellParametersProtocolGuid
, NULL
},
784 {STRING_TOKEN(STR_SHELL
), &gEfiShellProtocolGuid
, NULL
},
787 // UEFI Shell Spec 2.1
789 {STRING_TOKEN(STR_SHELL_DYNAMIC
), &gEfiShellDynamicCommandProtocolGuid
, NULL
},
794 {STRING_TOKEN(STR_UNKNOWN_DEVICE
), NULL
, NULL
},
798 Function to get the node for a protocol or struct from it's GUID.
800 if Guid is NULL, then ASSERT.
802 @param[in] Guid The GUID to look for the name of.
806 CONST GUID_INFO_BLOCK
*
808 InternalShellGetNodeFromGuid(
809 IN CONST EFI_GUID
* Guid
812 CONST GUID_INFO_BLOCK
*ListWalker
;
815 ASSERT(Guid
!= NULL
);
817 for (LoopCount
= 0, ListWalker
= GuidList
; GuidList
!= NULL
&& LoopCount
< GuidListCount
; LoopCount
++, ListWalker
++) {
818 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
823 if (PcdGetBool(PcdShellIncludeNtGuids
)) {
824 for (ListWalker
= mGuidStringListNT
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
825 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
830 for (ListWalker
= mGuidStringList
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
831 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
839 Function to add a new GUID/Name mapping.
841 @param[in] Guid The Guid
842 @param[in] NameID The STRING id of the HII string to use
843 @param[in] DumpFunc The pointer to the dump function
846 @retval EFI_SUCCESS The operation was sucessful
847 @retval EFI_OUT_OF_RESOURCES A memory allocation failed
848 @retval EFI_INVALID_PARAMETER Guid NameId was invalid
852 InsertNewGuidNameMapping(
853 IN CONST EFI_GUID
*Guid
,
854 IN CONST EFI_STRING_ID NameID
,
855 IN CONST DUMP_PROTOCOL_INFO DumpFunc OPTIONAL
858 ASSERT(Guid
!= NULL
);
861 GuidList
= ReallocatePool(GuidListCount
* sizeof(GUID_INFO_BLOCK
), GuidListCount
+1 * sizeof(GUID_INFO_BLOCK
), GuidList
);
862 if (GuidList
== NULL
) {
864 return (EFI_OUT_OF_RESOURCES
);
868 GuidList
[GuidListCount
- 1].GuidId
= AllocateCopyPool(sizeof(EFI_GUID
), Guid
);
869 GuidList
[GuidListCount
- 1].StringId
= NameID
;
870 GuidList
[GuidListCount
- 1].DumpInfo
= DumpFunc
;
872 if (GuidList
[GuidListCount
- 1].GuidId
== NULL
) {
873 return (EFI_OUT_OF_RESOURCES
);
876 return (EFI_SUCCESS
);
880 Function to add a new GUID/Name mapping.
882 This cannot overwrite an existing mapping.
884 @param[in] Guid The Guid
885 @param[in] TheName The Guid's name
886 @param[in] Lang RFC4646 language code list or NULL
888 @retval EFI_SUCCESS The operation was sucessful
889 @retval EFI_ACCESS_DENIED There was a duplicate
890 @retval EFI_OUT_OF_RESOURCES A memory allocation failed
891 @retval EFI_INVALID_PARAMETER Guid or TheName was NULL
895 AddNewGuidNameMapping(
896 IN CONST EFI_GUID
*Guid
,
897 IN CONST CHAR16
*TheName
,
898 IN CONST CHAR8
*Lang OPTIONAL
901 CONST GUID_INFO_BLOCK
*Temp
;
902 EFI_STRING_ID NameID
;
904 HandleParsingHiiInit();
906 if (Guid
== NULL
|| TheName
== NULL
){
907 return (EFI_INVALID_PARAMETER
);
910 if ((Temp
= InternalShellGetNodeFromGuid(Guid
)) != NULL
) {
911 return (EFI_ACCESS_DENIED
);
914 NameID
= HiiSetString(mHandleParsingHiiHandle
, 0, (CHAR16
*)TheName
, Lang
);
916 return (EFI_OUT_OF_RESOURCES
);
919 return (InsertNewGuidNameMapping(Guid
, NameID
, NULL
));
923 Function to get the name of a protocol or struct from it's GUID.
925 if Guid is NULL, then ASSERT.
927 @param[in] Guid The GUID to look for the name of.
928 @param[in] Lang The language to use.
930 @return pointer to string of the name. The caller
931 is responsible to free this memory.
935 GetStringNameFromGuid(
936 IN CONST EFI_GUID
*Guid
,
937 IN CONST CHAR8
*Lang OPTIONAL
940 CONST GUID_INFO_BLOCK
*Id
;
942 HandleParsingHiiInit();
944 Id
= InternalShellGetNodeFromGuid(Guid
);
945 return (HiiGetString(mHandleParsingHiiHandle
, Id
==NULL
?STRING_TOKEN(STR_UNKNOWN_DEVICE
):Id
->StringId
, Lang
));
949 Function to dump protocol information from a handle.
951 This function will return a allocated string buffer containing the
952 information. The caller is responsible for freeing the memory.
954 If Guid is NULL, ASSERT().
955 If TheHandle is NULL, ASSERT().
957 @param[in] TheHandle The handle to dump information from.
958 @param[in] Guid The GUID of the protocol to dump.
959 @param[in] Verbose TRUE for extra info. FALSE otherwise.
961 @return The pointer to string.
962 @retval NULL An error was encountered.
966 GetProtocolInformationDump(
967 IN CONST EFI_HANDLE TheHandle
,
968 IN CONST EFI_GUID
*Guid
,
969 IN CONST BOOLEAN Verbose
972 CONST GUID_INFO_BLOCK
*Id
;
974 ASSERT(TheHandle
!= NULL
);
975 ASSERT(Guid
!= NULL
);
977 if (TheHandle
== NULL
|| Guid
== NULL
) {
981 Id
= InternalShellGetNodeFromGuid(Guid
);
982 if (Id
!= NULL
&& Id
->DumpInfo
!= NULL
) {
983 return (Id
->DumpInfo(TheHandle
, Verbose
));
989 Function to get the Guid for a protocol or struct based on it's string name.
991 do not modify the returned Guid.
993 @param[in] Name The pointer to the string name.
994 @param[in] Lang The pointer to the language code.
995 @param[out] Guid The pointer to the Guid.
997 @retval EFI_SUCCESS The operation was sucessful.
1001 GetGuidFromStringName(
1002 IN CONST CHAR16
*Name
,
1003 IN CONST CHAR8
*Lang OPTIONAL
,
1007 CONST GUID_INFO_BLOCK
*ListWalker
;
1011 HandleParsingHiiInit();
1013 ASSERT(Guid
!= NULL
);
1015 return (EFI_INVALID_PARAMETER
);
1019 if (PcdGetBool(PcdShellIncludeNtGuids
)) {
1020 for (ListWalker
= mGuidStringListNT
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
1021 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
1022 if (Name
!= NULL
&& String
!= NULL
&& StringNoCaseCompare (&Name
, &String
) == 0) {
1023 *Guid
= ListWalker
->GuidId
;
1025 SHELL_FREE_NON_NULL(String
);
1026 if (*Guid
!= NULL
) {
1027 return (EFI_SUCCESS
);
1031 for (ListWalker
= mGuidStringList
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
1032 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
1033 if (Name
!= NULL
&& String
!= NULL
&& StringNoCaseCompare (&Name
, &String
) == 0) {
1034 *Guid
= ListWalker
->GuidId
;
1036 SHELL_FREE_NON_NULL(String
);
1037 if (*Guid
!= NULL
) {
1038 return (EFI_SUCCESS
);
1042 for (LoopCount
= 0, ListWalker
= GuidList
; GuidList
!= NULL
&& LoopCount
< GuidListCount
; LoopCount
++, ListWalker
++) {
1043 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
1044 if (Name
!= NULL
&& String
!= NULL
&& StringNoCaseCompare (&Name
, &String
) == 0) {
1045 *Guid
= ListWalker
->GuidId
;
1047 SHELL_FREE_NON_NULL(String
);
1048 if (*Guid
!= NULL
) {
1049 return (EFI_SUCCESS
);
1053 return (EFI_NOT_FOUND
);
1057 Get best support language for this driver.
1059 First base on the user input language to search, second base on the current
1060 platform used language to search, third get the first language from the
1061 support language list. The caller need to free the buffer of the best language.
1063 @param[in] SupportedLanguages The support languages for this driver.
1064 @param[in] InputLanguage The user input language.
1065 @param[in] Iso639Language Whether get language for ISO639.
1067 @return The best support language for this driver.
1071 GetBestLanguageForDriver (
1072 IN CONST CHAR8
*SupportedLanguages
,
1073 IN CONST CHAR8
*InputLanguage
,
1074 IN BOOLEAN Iso639Language
1077 CHAR8
*LanguageVariable
;
1078 CHAR8
*BestLanguage
;
1080 LanguageVariable
= GetVariable (Iso639Language
? L
"Lang" : L
"PlatformLang", &gEfiGlobalVariableGuid
);
1082 BestLanguage
= GetBestLanguage(
1085 (InputLanguage
!= NULL
) ? InputLanguage
: "",
1086 (LanguageVariable
!= NULL
) ? LanguageVariable
: "",
1091 if (LanguageVariable
!= NULL
) {
1092 FreePool (LanguageVariable
);
1095 return BestLanguage
;
1099 Function to retrieve the driver name (if possible) from the ComponentName or
1100 ComponentName2 protocol
1102 @param[in] TheHandle The driver handle to get the name of.
1103 @param[in] Language The language to use.
1105 @retval NULL The name could not be found.
1106 @return A pointer to the string name. Do not de-allocate the memory.
1110 GetStringNameFromHandle(
1111 IN CONST EFI_HANDLE TheHandle
,
1112 IN CONST CHAR8
*Language
1115 EFI_COMPONENT_NAME2_PROTOCOL
*CompNameStruct
;
1122 Status
= gBS
->OpenProtocol(
1124 &gEfiComponentName2ProtocolGuid
,
1125 (VOID
**)&CompNameStruct
,
1128 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
1129 if (!EFI_ERROR(Status
)) {
1130 BestLang
= GetBestLanguageForDriver (CompNameStruct
->SupportedLanguages
, Language
, FALSE
);
1131 Status
= CompNameStruct
->GetDriverName(CompNameStruct
, BestLang
, &RetVal
);
1132 if (BestLang
!= NULL
) {
1133 FreePool (BestLang
);
1136 if (!EFI_ERROR(Status
)) {
1140 Status
= gBS
->OpenProtocol(
1142 &gEfiComponentNameProtocolGuid
,
1143 (VOID
**)&CompNameStruct
,
1146 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
1147 if (!EFI_ERROR(Status
)) {
1148 BestLang
= GetBestLanguageForDriver (CompNameStruct
->SupportedLanguages
, Language
, FALSE
);
1149 Status
= CompNameStruct
->GetDriverName(CompNameStruct
, BestLang
, &RetVal
);
1150 if (BestLang
!= NULL
) {
1151 FreePool (BestLang
);
1153 if (!EFI_ERROR(Status
)) {
1161 Function to initialize the file global mHandleList object for use in
1162 vonverting handles to index and index to handle.
1164 @retval EFI_SUCCESS The operation was successful.
1168 InternalShellInitHandleList(
1173 EFI_HANDLE
*HandleBuffer
;
1175 HANDLE_LIST
*ListWalker
;
1177 if (mHandleList
.NextIndex
!= 0) {
1180 InitializeListHead(&mHandleList
.List
.Link
);
1181 mHandleList
.NextIndex
= 1;
1182 Status
= gBS
->LocateHandleBuffer (
1189 ASSERT_EFI_ERROR(Status
);
1190 if (EFI_ERROR(Status
)) {
1193 for (mHandleList
.NextIndex
= 1 ; mHandleList
.NextIndex
<= HandleCount
; mHandleList
.NextIndex
++){
1194 ListWalker
= AllocateZeroPool(sizeof(HANDLE_LIST
));
1195 ASSERT(ListWalker
!= NULL
);
1196 ListWalker
->TheHandle
= HandleBuffer
[mHandleList
.NextIndex
-1];
1197 ListWalker
->TheIndex
= mHandleList
.NextIndex
;
1198 InsertTailList(&mHandleList
.List
.Link
,&ListWalker
->Link
);
1200 FreePool(HandleBuffer
);
1201 return (EFI_SUCCESS
);
1205 Function to retrieve the human-friendly index of a given handle. If the handle
1206 does not have a index one will be automatically assigned. The index value is valid
1207 until the termination of the shell application.
1209 @param[in] TheHandle The handle to retrieve an index for.
1211 @retval 0 A memory allocation failed.
1212 @return The index of the handle.
1217 ConvertHandleToHandleIndex(
1218 IN CONST EFI_HANDLE TheHandle
1222 EFI_GUID
**ProtocolBuffer
;
1223 UINTN ProtocolCount
;
1224 HANDLE_LIST
*ListWalker
;
1226 if (TheHandle
== NULL
) {
1230 InternalShellInitHandleList();
1232 for (ListWalker
= (HANDLE_LIST
*)GetFirstNode(&mHandleList
.List
.Link
)
1233 ; !IsNull(&mHandleList
.List
.Link
,&ListWalker
->Link
)
1234 ; ListWalker
= (HANDLE_LIST
*)GetNextNode(&mHandleList
.List
.Link
,&ListWalker
->Link
)
1236 if (ListWalker
->TheHandle
== TheHandle
) {
1238 // Verify that TheHandle is still present in the Handle Database
1240 Status
= gBS
->ProtocolsPerHandle(TheHandle
, &ProtocolBuffer
, &ProtocolCount
);
1241 if (EFI_ERROR (Status
)) {
1243 // TheHandle is not present in the Handle Database, so delete from the handle list
1245 RemoveEntryList (&ListWalker
->Link
);
1248 FreePool (ProtocolBuffer
);
1249 return (ListWalker
->TheIndex
);
1254 // Verify that TheHandle is valid handle
1256 Status
= gBS
->ProtocolsPerHandle(TheHandle
, &ProtocolBuffer
, &ProtocolCount
);
1257 if (EFI_ERROR (Status
)) {
1259 // TheHandle is not valid, so do not add to handle list
1263 FreePool (ProtocolBuffer
);
1265 ListWalker
= AllocateZeroPool(sizeof(HANDLE_LIST
));
1266 ASSERT(ListWalker
!= NULL
);
1267 ListWalker
->TheHandle
= TheHandle
;
1268 ListWalker
->TheIndex
= mHandleList
.NextIndex
++;
1269 InsertTailList(&mHandleList
.List
.Link
,&ListWalker
->Link
);
1270 return (ListWalker
->TheIndex
);
1276 Function to retrieve the EFI_HANDLE from the human-friendly index.
1278 @param[in] TheIndex The index to retrieve the EFI_HANDLE for.
1280 @retval NULL The index was invalid.
1281 @return The EFI_HANDLE that index represents.
1286 ConvertHandleIndexToHandle(
1287 IN CONST UINTN TheIndex
1291 EFI_GUID
**ProtocolBuffer
;
1292 UINTN ProtocolCount
;
1293 HANDLE_LIST
*ListWalker
;
1295 InternalShellInitHandleList();
1297 if (TheIndex
>= mHandleList
.NextIndex
) {
1301 for (ListWalker
= (HANDLE_LIST
*)GetFirstNode(&mHandleList
.List
.Link
)
1302 ; !IsNull(&mHandleList
.List
.Link
,&ListWalker
->Link
)
1303 ; ListWalker
= (HANDLE_LIST
*)GetNextNode(&mHandleList
.List
.Link
,&ListWalker
->Link
)
1305 if (ListWalker
->TheIndex
== TheIndex
&& ListWalker
->TheHandle
!= NULL
) {
1307 // Verify that LinkWalker->TheHandle is valid handle
1309 Status
= gBS
->ProtocolsPerHandle(ListWalker
->TheHandle
, &ProtocolBuffer
, &ProtocolCount
);
1310 if (EFI_ERROR (Status
)) {
1312 // TheHandle is not valid, so do not add to handle list
1314 ListWalker
->TheHandle
= NULL
;
1316 return (ListWalker
->TheHandle
);
1323 Gets all the related EFI_HANDLEs based on the mask supplied.
1325 This function scans all EFI_HANDLES in the UEFI environment's handle database
1326 and returns the ones with the specified relationship (Mask) to the specified
1329 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
1330 If MatchingHandleCount is NULL, then ASSERT.
1332 If MatchingHandleBuffer is not NULL upon a successful return the memory must be
1335 @param[in] DriverBindingHandle The handle with Driver Binding protocol on it.
1336 @param[in] ControllerHandle The handle with Device Path protocol on it.
1337 @param[in] MatchingHandleCount The pointer to UINTN that specifies the number of HANDLES in
1338 MatchingHandleBuffer.
1339 @param[out] MatchingHandleBuffer On a successful return, a buffer of MatchingHandleCount
1340 EFI_HANDLEs with a terminating NULL EFI_HANDLE.
1341 @param[out] HandleType An array of type information.
1343 @retval EFI_SUCCESS The operation was successful, and any related handles
1344 are in MatchingHandleBuffer.
1345 @retval EFI_NOT_FOUND No matching handles were found.
1346 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.
1350 ParseHandleDatabaseByRelationshipWithType (
1351 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL
,
1352 IN CONST EFI_HANDLE ControllerHandle OPTIONAL
,
1353 IN UINTN
*HandleCount
,
1354 OUT EFI_HANDLE
**HandleBuffer
,
1355 OUT UINTN
**HandleType
1360 EFI_GUID
**ProtocolGuidArray
;
1362 UINTN ProtocolIndex
;
1363 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY
*OpenInfo
;
1364 UINTN OpenInfoCount
;
1365 UINTN OpenInfoIndex
;
1367 INTN DriverBindingHandleIndex
;
1369 ASSERT(HandleCount
!= NULL
);
1370 ASSERT(HandleBuffer
!= NULL
);
1371 ASSERT(HandleType
!= NULL
);
1372 ASSERT(DriverBindingHandle
!= NULL
|| ControllerHandle
!= NULL
);
1375 *HandleBuffer
= NULL
;
1379 // Retrieve the list of all handles from the handle database
1381 Status
= gBS
->LocateHandleBuffer (
1388 if (EFI_ERROR (Status
)) {
1392 *HandleType
= AllocateZeroPool (*HandleCount
* sizeof (UINTN
));
1393 ASSERT(*HandleType
!= NULL
);
1395 DriverBindingHandleIndex
= -1;
1396 for (HandleIndex
= 0; HandleIndex
< *HandleCount
; HandleIndex
++) {
1397 if (DriverBindingHandle
!= NULL
&& (*HandleBuffer
)[HandleIndex
] == DriverBindingHandle
) {
1398 DriverBindingHandleIndex
= (INTN
)HandleIndex
;
1402 for (HandleIndex
= 0; HandleIndex
< *HandleCount
; HandleIndex
++) {
1404 // Retrieve the list of all the protocols on each handle
1406 Status
= gBS
->ProtocolsPerHandle (
1407 (*HandleBuffer
)[HandleIndex
],
1411 if (EFI_ERROR (Status
)) {
1415 for (ProtocolIndex
= 0; ProtocolIndex
< ArrayCount
; ProtocolIndex
++) {
1418 // Set the bit describing what this handle has
1420 if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiLoadedImageProtocolGuid
) ) {
1421 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_IMAGE_HANDLE
;
1422 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverBindingProtocolGuid
) ) {
1423 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_BINDING_HANDLE
;
1424 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverConfiguration2ProtocolGuid
)) {
1425 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_CONFIGURATION_HANDLE
;
1426 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverConfigurationProtocolGuid
) ) {
1427 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_CONFIGURATION_HANDLE
;
1428 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverDiagnostics2ProtocolGuid
) ) {
1429 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_DIAGNOSTICS_HANDLE
;
1430 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverDiagnosticsProtocolGuid
) ) {
1431 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_DIAGNOSTICS_HANDLE
;
1432 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiComponentName2ProtocolGuid
) ) {
1433 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_COMPONENT_NAME_HANDLE
;
1434 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiComponentNameProtocolGuid
) ) {
1435 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_COMPONENT_NAME_HANDLE
;
1436 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDevicePathProtocolGuid
) ) {
1437 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DEVICE_HANDLE
;
1440 ASSERT((*HandleType
)[HandleIndex
] == (*HandleType
)[HandleIndex
]);
1444 // Retrieve the list of agents that have opened each protocol
1446 Status
= gBS
->OpenProtocolInformation (
1447 (*HandleBuffer
)[HandleIndex
],
1448 ProtocolGuidArray
[ProtocolIndex
],
1452 if (EFI_ERROR (Status
)) {
1456 if (ControllerHandle
== NULL
) {
1458 // ControllerHandle == NULL and DriverBindingHandle != NULL.
1459 // Return information on all the controller handles that the driver specified by DriverBindingHandle is managing
1461 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
1462 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
&& (OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) != 0) {
1463 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
1464 if (DriverBindingHandleIndex
!= -1) {
1465 (*HandleType
)[DriverBindingHandleIndex
] |= (UINTN
)HR_DEVICE_DRIVER
;
1468 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
&& (OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
1469 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
1470 if (DriverBindingHandleIndex
!= -1) {
1471 (*HandleType
)[DriverBindingHandleIndex
] |= (UINTN
)(HR_BUS_DRIVER
| HR_DEVICE_DRIVER
);
1473 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
1474 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== (*HandleBuffer
)[ChildIndex
]) {
1475 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
1481 if (DriverBindingHandle
== NULL
&& ControllerHandle
!= NULL
) {
1482 if (ControllerHandle
== (*HandleBuffer
)[HandleIndex
]) {
1483 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
1484 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
1485 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) != 0) {
1486 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
1487 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== (*HandleBuffer
)[ChildIndex
]) {
1488 (*HandleType
)[ChildIndex
] |= (UINTN
)HR_DEVICE_DRIVER
;
1492 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
1493 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
1494 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== (*HandleBuffer
)[ChildIndex
]) {
1495 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_BUS_DRIVER
| HR_DEVICE_DRIVER
);
1497 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== (*HandleBuffer
)[ChildIndex
]) {
1498 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
1504 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
1505 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
1506 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== ControllerHandle
) {
1507 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_PARENT_HANDLE
);
1513 if (DriverBindingHandle
!= NULL
&& ControllerHandle
!= NULL
) {
1514 if (ControllerHandle
== (*HandleBuffer
)[HandleIndex
]) {
1515 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
1516 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
1517 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) != 0) {
1518 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
) {
1519 if (DriverBindingHandleIndex
!= -1) {
1520 (*HandleType
)[DriverBindingHandleIndex
] |= (UINTN
)HR_DEVICE_DRIVER
;
1524 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
1525 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
) {
1526 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
1527 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== (*HandleBuffer
)[ChildIndex
]) {
1528 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
1533 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
1534 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== (*HandleBuffer
)[ChildIndex
]) {
1535 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_BUS_DRIVER
| HR_DEVICE_DRIVER
);
1541 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
1542 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
1543 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== ControllerHandle
) {
1544 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_PARENT_HANDLE
);
1550 FreePool (OpenInfo
);
1552 FreePool (ProtocolGuidArray
);
1558 Gets all the related EFI_HANDLEs based on the single EFI_HANDLE and the mask
1561 This function will scan all EFI_HANDLES in the UEFI environment's handle database
1562 and return all the ones with the specified relationship (Mask) to the specified
1565 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
1566 If MatchingHandleCount is NULL, then ASSERT.
1568 If MatchingHandleBuffer is not NULL upon a sucessful return the memory must be
1571 @param[in] DriverBindingHandle Handle to a object with Driver Binding protocol
1573 @param[in] ControllerHandle Handle to a device with Device Path protocol on it.
1574 @param[in] Mask Mask of what relationship(s) is desired.
1575 @param[in] MatchingHandleCount Poitner to UINTN specifying number of HANDLES in
1576 MatchingHandleBuffer.
1577 @param[out] MatchingHandleBuffer On a sucessful return a buffer of MatchingHandleCount
1578 EFI_HANDLEs and a terminating NULL EFI_HANDLE.
1580 @retval EFI_SUCCESS The operation was sucessful and any related handles
1581 are in MatchingHandleBuffer;
1582 @retval EFI_NOT_FOUND No matching handles were found.
1583 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.
1587 ParseHandleDatabaseByRelationship (
1588 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL
,
1589 IN CONST EFI_HANDLE ControllerHandle OPTIONAL
,
1590 IN CONST UINTN Mask
,
1591 IN UINTN
*MatchingHandleCount
,
1592 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
1597 EFI_HANDLE
*HandleBuffer
;
1601 ASSERT(MatchingHandleCount
!= NULL
);
1602 ASSERT(DriverBindingHandle
!= NULL
|| ControllerHandle
!= NULL
);
1604 if ((Mask
& HR_VALID_MASK
) != Mask
) {
1605 return (EFI_INVALID_PARAMETER
);
1608 if ((Mask
& HR_CHILD_HANDLE
) != 0 && DriverBindingHandle
== NULL
) {
1609 return (EFI_INVALID_PARAMETER
);
1612 *MatchingHandleCount
= 0;
1613 if (MatchingHandleBuffer
!= NULL
) {
1614 *MatchingHandleBuffer
= NULL
;
1617 HandleBuffer
= NULL
;
1620 Status
= ParseHandleDatabaseByRelationshipWithType (
1621 DriverBindingHandle
,
1627 if (!EFI_ERROR (Status
)) {
1629 // Count the number of handles that match the attributes in Mask
1631 for (HandleIndex
= 0; HandleIndex
< HandleCount
; HandleIndex
++) {
1632 if ((HandleType
[HandleIndex
] & Mask
) == Mask
) {
1633 (*MatchingHandleCount
)++;
1637 // If no handles match the attributes in Mask then return EFI_NOT_FOUND
1639 if (*MatchingHandleCount
== 0) {
1640 Status
= EFI_NOT_FOUND
;
1643 if (MatchingHandleBuffer
== NULL
) {
1645 // Someone just wanted the count...
1647 Status
= EFI_SUCCESS
;
1650 // Allocate a handle buffer for the number of handles that matched the attributes in Mask
1652 *MatchingHandleBuffer
= AllocateZeroPool ((*MatchingHandleCount
+1)* sizeof (EFI_HANDLE
));
1653 ASSERT(*MatchingHandleBuffer
!= NULL
);
1655 for (HandleIndex
= 0,*MatchingHandleCount
= 0
1656 ; HandleIndex
< HandleCount
1660 // Fill the allocated buffer with the handles that matched the attributes in Mask
1662 if ((HandleType
[HandleIndex
] & Mask
) == Mask
) {
1663 (*MatchingHandleBuffer
)[(*MatchingHandleCount
)++] = HandleBuffer
[HandleIndex
];
1668 // Make the last one NULL
1670 (*MatchingHandleBuffer
)[*MatchingHandleCount
] = NULL
;
1672 Status
= EFI_SUCCESS
;
1673 } // MacthingHandleBuffer == NULL (ELSE)
1674 } // *MatchingHandleCount == 0 (ELSE)
1675 } // no error on ParseHandleDatabaseByRelationshipWithType
1677 if (HandleBuffer
!= NULL
) {
1678 FreePool (HandleBuffer
);
1681 if (HandleType
!= NULL
) {
1682 FreePool (HandleType
);
1689 Gets handles for any child controllers of the passed in controller.
1691 @param[in] ControllerHandle The handle of the "parent controller"
1692 @param[in] MatchingHandleCount Pointer to the number of handles in
1693 MatchingHandleBuffer on return.
1694 @param[out] MatchingHandleBuffer Buffer containing handles on a successful
1698 @retval EFI_SUCCESS The operation was sucessful.
1702 ParseHandleDatabaseForChildControllers(
1703 IN CONST EFI_HANDLE ControllerHandle
,
1704 IN UINTN
*MatchingHandleCount
,
1705 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
1710 UINTN DriverBindingHandleCount
;
1711 EFI_HANDLE
*DriverBindingHandleBuffer
;
1712 UINTN DriverBindingHandleIndex
;
1713 UINTN ChildControllerHandleCount
;
1714 EFI_HANDLE
*ChildControllerHandleBuffer
;
1715 UINTN ChildControllerHandleIndex
;
1716 EFI_HANDLE
*HandleBufferForReturn
;
1718 if (MatchingHandleCount
== NULL
) {
1719 return (EFI_INVALID_PARAMETER
);
1721 *MatchingHandleCount
= 0;
1723 Status
= PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
1725 &DriverBindingHandleCount
,
1726 &DriverBindingHandleBuffer
1728 if (EFI_ERROR (Status
)) {
1733 // Get a buffer big enough for all the controllers.
1735 HandleBufferForReturn
= GetHandleListByProtocol(NULL
);
1736 if (HandleBufferForReturn
== NULL
) {
1737 FreePool (DriverBindingHandleBuffer
);
1738 return (EFI_NOT_FOUND
);
1741 for (DriverBindingHandleIndex
= 0; DriverBindingHandleIndex
< DriverBindingHandleCount
; DriverBindingHandleIndex
++) {
1742 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
1743 DriverBindingHandleBuffer
[DriverBindingHandleIndex
],
1745 &ChildControllerHandleCount
,
1746 &ChildControllerHandleBuffer
1748 if (EFI_ERROR (Status
)) {
1752 for (ChildControllerHandleIndex
= 0;
1753 ChildControllerHandleIndex
< ChildControllerHandleCount
;
1754 ChildControllerHandleIndex
++
1756 for (HandleIndex
= 0; HandleIndex
< *MatchingHandleCount
; HandleIndex
++) {
1757 if (HandleBufferForReturn
[HandleIndex
] == ChildControllerHandleBuffer
[ChildControllerHandleIndex
]) {
1761 if (HandleIndex
>= *MatchingHandleCount
) {
1762 HandleBufferForReturn
[(*MatchingHandleCount
)++] = ChildControllerHandleBuffer
[ChildControllerHandleIndex
];
1766 FreePool (ChildControllerHandleBuffer
);
1769 FreePool (DriverBindingHandleBuffer
);
1771 if (MatchingHandleBuffer
!= NULL
) {
1772 *MatchingHandleBuffer
= HandleBufferForReturn
;
1774 FreePool(HandleBufferForReturn
);
1777 return (EFI_SUCCESS
);
1781 Appends 1 buffer to another buffer. This will re-allocate the destination buffer
1782 if necessary to fit all of the data.
1784 If DestinationBuffer is NULL, then ASSERT().
1786 @param[in, out] DestinationBuffer The pointer to the pointer to the buffer to append onto.
1787 @param[in, out] DestinationSize The pointer to the size of DestinationBuffer.
1788 @param[in] SourceBuffer The pointer to the buffer to append onto DestinationBuffer.
1789 @param[in] SourceSize The number of bytes of SourceBuffer to append.
1791 @retval NULL A memory allocation failed.
1792 @retval NULL A parameter was invalid.
1793 @return A pointer to (*DestinationBuffer).
1798 IN OUT VOID
**DestinationBuffer
,
1799 IN OUT UINTN
*DestinationSize
,
1800 IN VOID
*SourceBuffer
,
1804 UINTN LocalDestinationSize
;
1805 UINTN LocalDestinationFinalSize
;
1807 ASSERT(DestinationBuffer
!= NULL
);
1809 if (SourceSize
== 0 || SourceBuffer
== NULL
) {
1810 return (*DestinationBuffer
);
1813 if (DestinationSize
== NULL
) {
1814 LocalDestinationSize
= 0;
1816 LocalDestinationSize
= *DestinationSize
;
1819 LocalDestinationFinalSize
= LocalDestinationSize
+ SourceSize
;
1821 if (DestinationSize
!= NULL
) {
1822 *DestinationSize
= LocalDestinationSize
;
1825 if (LocalDestinationSize
== 0) {
1827 *DestinationBuffer
= AllocateZeroPool(LocalDestinationFinalSize
);
1830 *DestinationBuffer
= ReallocatePool(LocalDestinationSize
, LocalDestinationFinalSize
, *DestinationBuffer
);
1833 ASSERT(*DestinationBuffer
!= NULL
);
1836 return (CopyMem(((UINT8
*)(*DestinationBuffer
)) + LocalDestinationSize
, SourceBuffer
, SourceSize
));
1840 Gets handles for any child devices produced by the passed in driver.
1842 @param[in] DriverHandle The handle of the driver.
1843 @param[in] MatchingHandleCount Pointer to the number of handles in
1844 MatchingHandleBuffer on return.
1845 @param[out] MatchingHandleBuffer Buffer containing handles on a successful
1847 @retval EFI_SUCCESS The operation was sucessful.
1848 @sa ParseHandleDatabaseByRelationship
1852 ParseHandleDatabaseForChildDevices(
1853 IN CONST EFI_HANDLE DriverHandle
,
1854 IN UINTN
*MatchingHandleCount
,
1855 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
1859 EFI_HANDLE
*Buffer2
;
1864 UINTN HandleBufferSize
;
1866 ASSERT(MatchingHandleCount
!= NULL
);
1868 HandleBufferSize
= 0;
1871 *MatchingHandleCount
= 0;
1873 Status
= PARSE_HANDLE_DATABASE_DEVICES (
1878 if (!EFI_ERROR (Status
)) {
1879 for (HandleIndex
= 0; HandleIndex
< Count1
; HandleIndex
++) {
1881 // now find the children
1883 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
1885 Buffer
[HandleIndex
],
1889 if (EFI_ERROR(Status
)) {
1893 // save out required and optional data elements
1895 *MatchingHandleCount
+= Count2
;
1896 if (MatchingHandleBuffer
!= NULL
) {
1897 *MatchingHandleBuffer
= BuffernCatGrow((VOID
**)MatchingHandleBuffer
, &HandleBufferSize
, Buffer2
, Count2
* sizeof(Buffer2
[0]));
1903 if (Buffer2
!= NULL
) {
1909 if (Buffer
!= NULL
) {
1916 Function to get all handles that support a given protocol or all handles.
1918 @param[in] ProtocolGuid The guid of the protocol to get handles for. If NULL
1919 then the function will return all handles.
1921 @retval NULL A memory allocation failed.
1922 @return A NULL terminated list of handles.
1926 GetHandleListByProtocol (
1927 IN CONST EFI_GUID
*ProtocolGuid OPTIONAL
1930 EFI_HANDLE
*HandleList
;
1938 // We cannot use LocateHandleBuffer since we need that NULL item on the ends of the list!
1940 if (ProtocolGuid
== NULL
) {
1941 Status
= gBS
->LocateHandle(AllHandles
, NULL
, NULL
, &Size
, HandleList
);
1942 if (Status
== EFI_BUFFER_TOO_SMALL
) {
1943 HandleList
= AllocateZeroPool(Size
+ sizeof(EFI_HANDLE
));
1944 if (HandleList
== NULL
) {
1947 Status
= gBS
->LocateHandle(AllHandles
, NULL
, NULL
, &Size
, HandleList
);
1948 HandleList
[Size
/sizeof(EFI_HANDLE
)] = NULL
;
1951 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)ProtocolGuid
, NULL
, &Size
, HandleList
);
1952 if (Status
== EFI_BUFFER_TOO_SMALL
) {
1953 HandleList
= AllocateZeroPool(Size
+ sizeof(EFI_HANDLE
));
1954 if (HandleList
== NULL
) {
1957 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)ProtocolGuid
, NULL
, &Size
, HandleList
);
1958 HandleList
[Size
/sizeof(EFI_HANDLE
)] = NULL
;
1961 if (EFI_ERROR(Status
)) {
1962 if (HandleList
!= NULL
) {
1963 FreePool(HandleList
);
1967 return (HandleList
);
1971 Function to get all handles that support some protocols.
1973 @param[in] ProtocolGuids A NULL terminated list of protocol GUIDs.
1975 @retval NULL A memory allocation failed.
1976 @retval NULL ProtocolGuids was NULL.
1977 @return A NULL terminated list of EFI_HANDLEs.
1981 GetHandleListByProtocolList (
1982 IN CONST EFI_GUID
**ProtocolGuids
1985 EFI_HANDLE
*HandleList
;
1990 CONST EFI_GUID
**GuidWalker
;
1991 EFI_HANDLE
*HandleWalker1
;
1992 EFI_HANDLE
*HandleWalker2
;
1996 TotalSize
= sizeof(EFI_HANDLE
);
1998 for (GuidWalker
= ProtocolGuids
; GuidWalker
!= NULL
&& *GuidWalker
!= NULL
; GuidWalker
++,Size
= 0){
1999 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)(*GuidWalker
), NULL
, &Size
, NULL
);
2000 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2006 // No handles were found...
2008 if (TotalSize
== sizeof(EFI_HANDLE
)) {
2012 HandleList
= AllocateZeroPool(TotalSize
);
2013 if (HandleList
== NULL
) {
2018 for (GuidWalker
= ProtocolGuids
; GuidWalker
!= NULL
&& *GuidWalker
!= NULL
; GuidWalker
++){
2019 TempSize
= TotalSize
- Size
;
2020 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)(*GuidWalker
), NULL
, &TempSize
, HandleList
+(Size
/sizeof(EFI_HANDLE
)));
2023 // Allow for missing protocols... Only update the 'used' size upon success.
2025 if (!EFI_ERROR(Status
)) {
2029 ASSERT(HandleList
[(TotalSize
/sizeof(EFI_HANDLE
))-1] == NULL
);
2031 for (HandleWalker1
= HandleList
; HandleWalker1
!= NULL
&& *HandleWalker1
!= NULL
; HandleWalker1
++) {
2032 for (HandleWalker2
= HandleWalker1
+ 1; HandleWalker2
!= NULL
&& *HandleWalker2
!= NULL
; HandleWalker2
++) {
2033 if (*HandleWalker1
== *HandleWalker2
) {
2035 // copy memory back 1 handle width.
2037 CopyMem(HandleWalker2
, HandleWalker2
+ 1, TotalSize
- ((HandleWalker2
-HandleList
+1)*sizeof(EFI_HANDLE
)));
2042 return (HandleList
);