2 Provides interface to advanced shell functionality for parsing both handle and protocol database.
4 Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 #include "UefiHandleParsingLib.h"
16 #include "IndustryStandard/Acpi10.h"
18 EFI_HANDLE mHandleParsingHiiHandle
;
19 HANDLE_INDEX_LIST mHandleList
= {{{NULL
,NULL
},0,0},0};
22 Constructor for the library.
24 @param[in] ImageHandle Ignored.
25 @param[in] SystemTable Ignored.
27 @retval EFI_SUCCESS The operation was successful.
31 HandleParsingLibConstructor (
32 IN EFI_HANDLE ImageHandle
,
33 IN EFI_SYSTEM_TABLE
*SystemTable
36 mHandleParsingHiiHandle
= HiiAddPackages (&gHandleParsingHiiGuid
, gImageHandle
, UefiHandleParsingLibStrings
, NULL
);
37 if (mHandleParsingHiiHandle
== NULL
) {
38 return (EFI_DEVICE_ERROR
);
45 Destructor for the library. free any resources.
47 @param[in] ImageHandle Ignored.
48 @param[in] SystemTable Ignored.
50 @retval EFI_SUCCESS The operation was successful.
54 HandleParsingLibDestructor (
55 IN EFI_HANDLE ImageHandle
,
56 IN EFI_SYSTEM_TABLE
*SystemTable
59 if (mHandleParsingHiiHandle
!= NULL
) {
60 HiiRemovePackages(mHandleParsingHiiHandle
);
68 LoadedImageProtocolDumpInformation(
69 IN CONST EFI_HANDLE TheHandle,
70 IN CONST BOOLEAN Verbose
73 EFI_LOADED_IMAGE_PROTOCOL *Image;
75 EFI_DEVICE_PATH_PROTOCOL *DevPath;
76 EFI_DEVICE_PATH_PROTOCOL *DevPathNode;
79 UINT32 AuthenticationStatus;
81 EFI_FIRMWARE_VOLUME_PROTOCOL *FV;
82 EFI_FIRMWARE_VOLUME2_PROTOCOL *FV2;
89 Status = HandleProtocol (
91 &gEfiLoadedImageProtocolGuid,
93 ASSERT_EFI_ERROR(Status);
95 DevPath = UnpackDevicePath (Image->FilePath);
97 if (DevPath == NULL) {
101 DevPathNode = DevPath;
103 while (!IsDevicePathEnd (DevPathNode)) {
105 // Find the Fv File path
107 NameGuid = GetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)DevPathNode);
108 if (NameGuid != NULL) {
109 Status = BS->HandleProtocol (
111 &gEfiFirmwareVolumeProtocolGuid,
114 if (!EFI_ERROR (Status)) {
115 Status = FV->ReadSection (
118 EFI_SECTION_USER_INTERFACE,
122 &AuthenticationStatus
124 if (!EFI_ERROR (Status)) {
130 Status = BS->HandleProtocol (
132 &gEfiFirmwareVolume2ProtocolGuid,
135 if (!EFI_ERROR (Status)) {
136 Status = FV2->ReadSection (
139 EFI_SECTION_USER_INTERFACE,
143 &AuthenticationStatus
145 if (!EFI_ERROR (Status)) {
154 // Next device path node
156 DevPathNode = NextDevicePathNode (DevPathNode);
165 Function to dump information about PciRootBridgeIo.
167 This will allocate the return buffer from boot services pool.
169 @param[in] TheHandle The handle that has PciRootBridgeIo installed.
170 @param[in] Verbose TRUE for additional information, FALSE otherwise.
172 @retval A poitner to a string containing the information.
176 PciRootBridgeIoDumpInformation(
177 IN CONST EFI_HANDLE TheHandle
,
178 IN CONST BOOLEAN Verbose
181 EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL
*PciRootBridgeIo
;
182 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR
*Configuration
;
193 return (CatSPrint(NULL
, L
"PciRootBridgeIo"));
196 Status
= gBS
->HandleProtocol(
198 &gEfiPciRootBridgeIoProtocolGuid
,
199 (VOID
**)&PciRootBridgeIo
);
201 if (EFI_ERROR(Status
)) {
205 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_PH
), NULL
);
206 Temp2
= CatSPrint(L
"\r\n", Temp
, PciRootBridgeIo
->ParentHandle
);
211 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_SEG
), NULL
);
212 Temp2
= CatSPrint(RetVal
, Temp
, PciRootBridgeIo
->SegmentNumber
);
220 Status
= PciRootBridgeIo
->GetAttributes (PciRootBridgeIo
, &Supports
, &Attributes
);
221 if (!EFI_ERROR(Status
)) {
222 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_ATT
), NULL
);
223 Temp2
= CatSPrint(RetVal
, Temp
, Attributes
);
229 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_SUPPORTS
), NULL
);
230 Temp2
= CatSPrint(RetVal
, Temp
, Supports
);
237 Configuration
= NULL
;
238 Status
= PciRootBridgeIo
->Configuration (PciRootBridgeIo
, (VOID
**) &Configuration
);
239 if (!EFI_ERROR(Status
) && Configuration
!= NULL
) {
240 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_TITLE
), NULL
);
241 Temp2
= CatSPrint(RetVal
, Temp
, Supports
);
246 while (Configuration
->Desc
== ACPI_ADDRESS_SPACE_DESCRIPTOR
) {
248 switch (Configuration
->ResType
) {
249 case ACPI_ADDRESS_SPACE_TYPE_MEM
:
250 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_MEM
), NULL
);
252 case ACPI_ADDRESS_SPACE_TYPE_IO
:
253 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_IO
), NULL
);
255 case ACPI_ADDRESS_SPACE_TYPE_BUS
:
256 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_BUS
), NULL
);
260 Temp2
= CatSPrint(RetVal
, L
"%s", Temp
);
267 Temp2
= CatSPrint(RetVal
,
268 L
"%H%02x %016lx %016lx %02x%N\r\n",
269 Configuration
->SpecificFlag
,
270 Configuration
->AddrRangeMin
,
271 Configuration
->AddrRangeMax
,
272 Configuration
->AddrSpaceGranularity
284 Function to dump information about SimpleTextOut.
286 This will allocate the return buffer from boot services pool.
288 @param[in] TheHandle The handle that has SimpleTextOut installed.
289 @param[in] Verbose TRUE for additional information, FALSE otherwise.
291 @retval A poitner to a string containing the information.
295 TxtOutProtocolDumpInformation(
296 IN CONST EFI_HANDLE TheHandle
,
297 IN CONST BOOLEAN Verbose
300 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL
*Dev
;
317 Status
= gBS
->HandleProtocol(
319 &gEfiSimpleTextOutProtocolGuid
,
322 ASSERT_EFI_ERROR(Status
);
323 ASSERT (Dev
!= NULL
&& Dev
->Mode
!= NULL
);
325 Size
= (Dev
->Mode
->MaxMode
+ 1) * 80;
326 RetVal
= AllocateZeroPool(Size
);
328 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_TXT_OUT_DUMP_HEADER
), NULL
);
330 UnicodeSPrint(RetVal
, Size
, Temp
, Dev
, Dev
->Mode
->Attribute
);
337 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_TXT_OUT_DUMP_LINE
), NULL
);
338 for (Index
= 0; Index
< Dev
->Mode
->MaxMode
; Index
++) {
339 Status
= Dev
->QueryMode (Dev
, Index
, &Col
, &Row
);
340 NewSize
= Size
- StrSize(RetVal
);
342 RetVal
+ StrLen(RetVal
),
344 Temp
== NULL
?L
"":Temp
,
345 Index
== Dev
->Mode
->Mode
? L
'*' : L
' ',
347 !EFI_ERROR(Status
)?Col
:-1,
348 !EFI_ERROR(Status
)?Row
:-1
355 STATIC CONST UINTN VersionStringSize
= 60;
358 Function to dump information about EfiDriverSupportedEfiVersion protocol.
360 This will allocate the return buffer from boot services pool.
362 @param[in] TheHandle The handle that has the protocol installed.
363 @param[in] Verbose TRUE for additional information, FALSE otherwise.
365 @retval A poitner to a string containing the information.
369 DriverEfiVersionProtocolDumpInformation(
370 IN CONST EFI_HANDLE TheHandle
,
371 IN CONST BOOLEAN Verbose
374 EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL
*DriverEfiVersion
;
378 Status
= gBS
->HandleProtocol(
380 &gEfiDriverSupportedEfiVersionProtocolGuid
,
381 (VOID
**)&DriverEfiVersion
);
383 ASSERT_EFI_ERROR(Status
);
385 RetVal
= AllocateZeroPool(VersionStringSize
);
386 ASSERT(RetVal
!= NULL
);
387 UnicodeSPrint(RetVal
, VersionStringSize
, L
"0x%08x", DriverEfiVersion
->FirmwareVersion
);
392 Function to dump information about DevicePath protocol.
394 This will allocate the return buffer from boot services pool.
396 @param[in] TheHandle The handle that has the protocol installed.
397 @param[in] Verbose TRUE for additional information, FALSE otherwise.
399 @retval A poitner to a string containing the information.
403 DevicePathProtocolDumpInformation(
404 IN CONST EFI_HANDLE TheHandle
,
405 IN CONST BOOLEAN Verbose
408 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
412 EFI_DEVICE_PATH_TO_TEXT_PROTOCOL
*DevPathToText
;
415 Status
= gBS
->LocateProtocol(&gEfiDevicePathToTextProtocolGuid
, NULL
, (VOID
**)&DevPathToText
);
416 if (!EFI_ERROR(Status
)) {
417 Status
= gBS
->OpenProtocol(TheHandle
, &gEfiDevicePathProtocolGuid
, (VOID
**)&DevPath
, gImageHandle
, NULL
, EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
418 if (!EFI_ERROR(Status
)) {
420 // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)
422 Temp
= DevPathToText
->ConvertDevicePathToText(DevPath
, TRUE
, TRUE
);
423 gBS
->CloseProtocol(TheHandle
, &gEfiDevicePathProtocolGuid
, gImageHandle
, NULL
);
426 if (!Verbose
&& Temp
!= NULL
&& StrLen(Temp
) > 30) {
428 Temp2
= StrnCatGrow(&Temp2
, NULL
, Temp
+(StrLen(Temp
) - 30), 30);
436 // Put the information on the NT32 protocol GUIDs here so we are not dependant on the Nt32Pkg
438 #define LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID \
440 0x58c518b1, 0x76f3, 0x11d4, 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 \
443 #define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \
445 0x96eb4ad6, 0xa32a, 0x11d4, 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 \
448 #define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \
450 0xc95a93d, 0xa006, 0x11d4, 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 \
452 STATIC CONST EFI_GUID WinNtThunkProtocolGuid
= LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID
;
453 STATIC CONST EFI_GUID WinNtIoProtocolGuid
= LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID
;
454 STATIC CONST EFI_GUID WinNtSerialPortGuid
= LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID
;
456 STATIC CONST GUID_INFO_BLOCK mGuidStringListNT
[] = {
457 {STRING_TOKEN(STR_WINNT_THUNK
), (EFI_GUID
*)&WinNtThunkProtocolGuid
, NULL
},
458 {STRING_TOKEN(STR_WINNT_DRIVER_IO
), (EFI_GUID
*)&WinNtIoProtocolGuid
, NULL
},
459 {STRING_TOKEN(STR_WINNT_SERIAL_PORT
), (EFI_GUID
*)&WinNtSerialPortGuid
, NULL
},
460 {STRING_TOKEN(STR_UNKNOWN_DEVICE
), NULL
, NULL
},
463 STATIC CONST GUID_INFO_BLOCK mGuidStringList
[] = {
464 {STRING_TOKEN(STR_LOADED_IMAGE
), &gEfiLoadedImageProtocolGuid
, NULL
},
465 {STRING_TOKEN(STR_DEVICE_PATH
), &gEfiDevicePathProtocolGuid
, DevicePathProtocolDumpInformation
},
466 {STRING_TOKEN(STR_IMAGE_PATH
), &gEfiLoadedImageDevicePathProtocolGuid
, DevicePathProtocolDumpInformation
},
467 {STRING_TOKEN(STR_DEVICE_PATH_UTIL
), &gEfiDevicePathUtilitiesProtocolGuid
, NULL
},
468 {STRING_TOKEN(STR_DEVICE_PATH_TXT
), &gEfiDevicePathToTextProtocolGuid
, NULL
},
469 {STRING_TOKEN(STR_DEVICE_PATH_FTXT
), &gEfiDevicePathFromTextProtocolGuid
, NULL
},
470 {STRING_TOKEN(STR_DEVICE_PATH_PC
), &gEfiPcAnsiGuid
, NULL
},
471 {STRING_TOKEN(STR_DEVICE_PATH_VT100
), &gEfiVT100Guid
, NULL
},
472 {STRING_TOKEN(STR_DEVICE_PATH_VT100P
), &gEfiVT100PlusGuid
, NULL
},
473 {STRING_TOKEN(STR_DEVICE_PATH_VTUTF8
), &gEfiVTUTF8Guid
, NULL
},
474 {STRING_TOKEN(STR_DRIVER_BINDING
), &gEfiDriverBindingProtocolGuid
, NULL
},
475 {STRING_TOKEN(STR_PLATFORM_OVERRIDE
), &gEfiPlatformDriverOverrideProtocolGuid
, NULL
},
476 {STRING_TOKEN(STR_BUS_OVERRIDE
), &gEfiBusSpecificDriverOverrideProtocolGuid
, NULL
},
477 {STRING_TOKEN(STR_DRIVER_DIAG
), &gEfiDriverDiagnosticsProtocolGuid
, NULL
},
478 {STRING_TOKEN(STR_DRIVER_DIAG2
), &gEfiDriverDiagnostics2ProtocolGuid
, NULL
},
479 {STRING_TOKEN(STR_DRIVER_CN
), &gEfiComponentNameProtocolGuid
, NULL
},
480 {STRING_TOKEN(STR_DRIVER_CN2
), &gEfiComponentName2ProtocolGuid
, NULL
},
481 {STRING_TOKEN(STR_PLAT_DRV_CFG
), &gEfiPlatformToDriverConfigurationProtocolGuid
, NULL
},
482 {STRING_TOKEN(STR_DRIVER_VERSION
), &gEfiDriverSupportedEfiVersionProtocolGuid
, DriverEfiVersionProtocolDumpInformation
},
483 {STRING_TOKEN(STR_TXT_IN
), &gEfiSimpleTextInProtocolGuid
, NULL
},
484 {STRING_TOKEN(STR_TXT_IN_EX
), &gEfiSimpleTextInputExProtocolGuid
, NULL
},
485 {STRING_TOKEN(STR_TXT_OUT
), &gEfiSimpleTextOutProtocolGuid
, TxtOutProtocolDumpInformation
},
486 {STRING_TOKEN(STR_SIM_POINTER
), &gEfiSimplePointerProtocolGuid
, NULL
},
487 {STRING_TOKEN(STR_ABS_POINTER
), &gEfiAbsolutePointerProtocolGuid
, NULL
},
488 {STRING_TOKEN(STR_SERIAL_IO
), &gEfiSerialIoProtocolGuid
, NULL
},
489 {STRING_TOKEN(STR_GRAPHICS_OUTPUT
), &gEfiGraphicsOutputProtocolGuid
, NULL
},
490 {STRING_TOKEN(STR_EDID_DISCOVERED
), &gEfiEdidDiscoveredProtocolGuid
, NULL
},
491 {STRING_TOKEN(STR_EDID_ACTIVE
), &gEfiEdidActiveProtocolGuid
, NULL
},
492 {STRING_TOKEN(STR_EDID_OVERRIDE
), &gEfiEdidOverrideProtocolGuid
, NULL
},
493 {STRING_TOKEN(STR_CON_IN
), &gEfiConsoleInDeviceGuid
, NULL
},
494 {STRING_TOKEN(STR_CON_OUT
), &gEfiConsoleOutDeviceGuid
, NULL
},
495 {STRING_TOKEN(STR_STD_ERR
), &gEfiStandardErrorDeviceGuid
, NULL
},
496 {STRING_TOKEN(STR_LOAD_FILE
), &gEfiLoadFileProtocolGuid
, NULL
},
497 {STRING_TOKEN(STR_LOAD_FILE2
), &gEfiLoadFile2ProtocolGuid
, NULL
},
498 {STRING_TOKEN(STR_SIMPLE_FILE_SYS
), &gEfiSimpleFileSystemProtocolGuid
, NULL
},
499 {STRING_TOKEN(STR_TAPE_IO
), &gEfiTapeIoProtocolGuid
, NULL
},
500 {STRING_TOKEN(STR_DISK_IO
), &gEfiDiskIoProtocolGuid
, NULL
},
501 {STRING_TOKEN(STR_BLK_IO
), &gEfiBlockIoProtocolGuid
, NULL
},
502 {STRING_TOKEN(STR_UC
), &gEfiUnicodeCollationProtocolGuid
, NULL
},
503 {STRING_TOKEN(STR_UC2
), &gEfiUnicodeCollation2ProtocolGuid
, NULL
},
504 {STRING_TOKEN(STR_PCIRB_IO
), &gEfiPciRootBridgeIoProtocolGuid
, PciRootBridgeIoDumpInformation
},
505 {STRING_TOKEN(STR_PCI_IO
), &gEfiPciIoProtocolGuid
, NULL
},
506 {STRING_TOKEN(STR_SCSI_PT
), &gEfiScsiPassThruProtocolGuid
, NULL
},
507 {STRING_TOKEN(STR_SCSI_IO
), &gEfiScsiIoProtocolGuid
, NULL
},
508 {STRING_TOKEN(STR_SCSI_PT_EXT
), &gEfiExtScsiPassThruProtocolGuid
, NULL
},
509 {STRING_TOKEN(STR_ISCSI
), &gEfiIScsiInitiatorNameProtocolGuid
, NULL
},
510 {STRING_TOKEN(STR_USB_IO
), &gEfiUsbIoProtocolGuid
, NULL
},
511 {STRING_TOKEN(STR_USB_HC
), &gEfiUsbHcProtocolGuid
, NULL
},
512 {STRING_TOKEN(STR_USB_HC2
), &gEfiUsb2HcProtocolGuid
, NULL
},
513 {STRING_TOKEN(STR_DEBUG_SUPPORT
), &gEfiDebugSupportProtocolGuid
, NULL
},
514 {STRING_TOKEN(STR_DEBUG_PORT
), &gEfiDebugPortProtocolGuid
, NULL
},
515 {STRING_TOKEN(STR_DECOMPRESS
), &gEfiDecompressProtocolGuid
, NULL
},
516 {STRING_TOKEN(STR_ACPI_TABLE
), &gEfiAcpiTableProtocolGuid
, NULL
},
517 {STRING_TOKEN(STR_EBC_INTERPRETER
), &gEfiEbcProtocolGuid
, NULL
},
518 {STRING_TOKEN(STR_SNP
), &gEfiSimpleNetworkProtocolGuid
, NULL
},
519 {STRING_TOKEN(STR_NII
), &gEfiNetworkInterfaceIdentifierProtocolGuid
, NULL
},
520 {STRING_TOKEN(STR_NII_31
), &gEfiNetworkInterfaceIdentifierProtocolGuid_31
, NULL
},
521 {STRING_TOKEN(STR_PXE_BC
), &gEfiPxeBaseCodeProtocolGuid
, NULL
},
522 {STRING_TOKEN(STR_PXE_CB
), &gEfiPxeBaseCodeCallbackProtocolGuid
, NULL
},
523 {STRING_TOKEN(STR_BIS
), &gEfiBisProtocolGuid
, NULL
},
524 {STRING_TOKEN(STR_MNP_SB
), &gEfiManagedNetworkServiceBindingProtocolGuid
, NULL
},
525 {STRING_TOKEN(STR_MNP
), &gEfiManagedNetworkProtocolGuid
, NULL
},
526 {STRING_TOKEN(STR_ARP_SB
), &gEfiArpServiceBindingProtocolGuid
, NULL
},
527 {STRING_TOKEN(STR_ARP
), &gEfiArpProtocolGuid
, NULL
},
528 {STRING_TOKEN(STR_DHCPV4_SB
), &gEfiDhcp4ServiceBindingProtocolGuid
, NULL
},
529 {STRING_TOKEN(STR_DHCPV4
), &gEfiDhcp4ProtocolGuid
, NULL
},
530 {STRING_TOKEN(STR_TCPV4_SB
), &gEfiTcp4ServiceBindingProtocolGuid
, NULL
},
531 {STRING_TOKEN(STR_TCPV4
), &gEfiTcp4ProtocolGuid
, NULL
},
532 {STRING_TOKEN(STR_IPV4_SB
), &gEfiIp4ServiceBindingProtocolGuid
, NULL
},
533 {STRING_TOKEN(STR_IPV4
), &gEfiIp4ProtocolGuid
, NULL
},
534 {STRING_TOKEN(STR_IPV4_CFG
), &gEfiIp4ConfigProtocolGuid
, NULL
},
535 {STRING_TOKEN(STR_SHELL_PARAMETERS
), &gEfiShellParametersProtocolGuid
, NULL
},
536 {STRING_TOKEN(STR_SHELL
), &gEfiShellProtocolGuid
, NULL
},
537 {STRING_TOKEN(STR_UDPV4_SB
), &gEfiUdp4ServiceBindingProtocolGuid
, NULL
},
538 {STRING_TOKEN(STR_UDPV4
), &gEfiUdp4ProtocolGuid
, NULL
},
539 {STRING_TOKEN(STR_MTFTPV4_SB
), &gEfiMtftp4ServiceBindingProtocolGuid
, NULL
},
540 {STRING_TOKEN(STR_MTFTPV4
), &gEfiMtftp4ProtocolGuid
, NULL
},
541 {STRING_TOKEN(STR_AUTH_INFO
), &gEfiAuthenticationInfoProtocolGuid
, NULL
},
542 {STRING_TOKEN(STR_HASH_SB
), &gEfiHashServiceBindingProtocolGuid
, NULL
},
543 {STRING_TOKEN(STR_HASH
), &gEfiHashProtocolGuid
, NULL
},
544 {STRING_TOKEN(STR_HII_FONT
), &gEfiHiiFontProtocolGuid
, NULL
},
545 {STRING_TOKEN(STR_HII_STRING
), &gEfiHiiStringProtocolGuid
, NULL
},
546 {STRING_TOKEN(STR_HII_IMAGE
), &gEfiHiiImageProtocolGuid
, NULL
},
547 {STRING_TOKEN(STR_HII_DATABASE
), &gEfiHiiDatabaseProtocolGuid
, NULL
},
548 {STRING_TOKEN(STR_HII_CONFIG_ROUT
), &gEfiHiiConfigRoutingProtocolGuid
, NULL
},
549 {STRING_TOKEN(STR_HII_CONFIG_ACC
), &gEfiHiiConfigAccessProtocolGuid
, NULL
},
550 {STRING_TOKEN(STR_HII_FORM_BROWSER2
), &gEfiFormBrowser2ProtocolGuid
, NULL
},
551 {STRING_TOKEN(STR_DRIVER_FAM_OVERRIDE
), &gEfiDriverFamilyOverrideProtocolGuid
, NULL
},
552 {STRING_TOKEN(STR_PCD
), &gPcdProtocolGuid
, NULL
},
553 {STRING_TOKEN(STR_TCG
), &gEfiTcgProtocolGuid
, NULL
},
554 {STRING_TOKEN(STR_HII_PACKAGE_LIST
), &gEfiHiiPackageListProtocolGuid
, NULL
},
557 // the ones under this are deprecated by the current UEFI Spec, but may be found anyways...
559 {STRING_TOKEN(STR_SHELL_INTERFACE
), &gEfiShellInterfaceGuid
, NULL
},
560 {STRING_TOKEN(STR_SHELL_ENV2
), &gEfiShellEnvironment2Guid
, NULL
},
561 {STRING_TOKEN(STR_SHELL_ENV
), &gEfiShellEnvironment2Guid
, NULL
},
562 {STRING_TOKEN(STR_DEVICE_IO
), &gEfiDeviceIoProtocolGuid
, NULL
},
563 {STRING_TOKEN(STR_UGA_DRAW
), &gEfiUgaDrawProtocolGuid
, NULL
},
564 {STRING_TOKEN(STR_UGA_IO
), &gEfiUgaIoProtocolGuid
, NULL
},
565 {STRING_TOKEN(STR_ESP
), &gEfiPartTypeSystemPartGuid
, NULL
},
566 {STRING_TOKEN(STR_GPT_NBR
), &gEfiPartTypeLegacyMbrGuid
, NULL
},
567 {STRING_TOKEN(STR_DRIVER_CONFIG
), &gEfiDriverConfigurationProtocolGuid
, NULL
},
568 {STRING_TOKEN(STR_DRIVER_CONFIG2
), &gEfiDriverConfiguration2ProtocolGuid
, NULL
},
571 // the ones under this are GUID identified structs, not protocols
573 {STRING_TOKEN(STR_FILE_INFO
), &gEfiFileInfoGuid
, NULL
},
574 {STRING_TOKEN(STR_FILE_SYS_INFO
), &gEfiFileSystemInfoGuid
, NULL
},
577 // the ones under this are misc GUIDS.
579 {STRING_TOKEN(STR_EFI_GLOBAL_VARIABLE
), &gEfiGlobalVariableGuid
, NULL
},
584 {STRING_TOKEN(STR_IP6_SB
), &gEfiIp6ServiceBindingProtocolGuid
, NULL
},
585 {STRING_TOKEN(STR_IP6
), &gEfiIp6ProtocolGuid
, NULL
},
586 {STRING_TOKEN(STR_IP6_CONFIG
), &gEfiIp6ConfigProtocolGuid
, NULL
},
587 {STRING_TOKEN(STR_MTFTP6_SB
), &gEfiMtftp6ServiceBindingProtocolGuid
, NULL
},
588 {STRING_TOKEN(STR_MTFTP6
), &gEfiMtftp6ProtocolGuid
, NULL
},
589 {STRING_TOKEN(STR_DHCP6_SB
), &gEfiDhcp6ServiceBindingProtocolGuid
, NULL
},
590 {STRING_TOKEN(STR_DHCP6
), &gEfiDhcp6ProtocolGuid
, NULL
},
591 {STRING_TOKEN(STR_UDP6_SB
), &gEfiUdp6ServiceBindingProtocolGuid
, NULL
},
592 {STRING_TOKEN(STR_UDP6
), &gEfiUdp6ProtocolGuid
, NULL
},
593 {STRING_TOKEN(STR_TCP6_SB
), &gEfiTcp6ServiceBindingProtocolGuid
, NULL
},
594 {STRING_TOKEN(STR_TCP6
), &gEfiTcp6ProtocolGuid
, NULL
},
595 {STRING_TOKEN(STR_VLAN_CONFIG
), &gEfiVlanConfigProtocolGuid
, NULL
},
596 {STRING_TOKEN(STR_EAP
), &gEfiEapProtocolGuid
, NULL
},
597 {STRING_TOKEN(STR_EAP_MGMT
), &gEfiEapManagementProtocolGuid
, NULL
},
598 {STRING_TOKEN(STR_FTP4_SB
), &gEfiFtp4ServiceBindingProtocolGuid
, NULL
},
599 {STRING_TOKEN(STR_FTP4
), &gEfiFtp4ProtocolGuid
, NULL
},
600 {STRING_TOKEN(STR_IP_SEC_CONFIG
), &gEfiIpSecConfigProtocolGuid
, NULL
},
601 {STRING_TOKEN(STR_DH
), &gEfiDriverHealthProtocolGuid
, NULL
},
602 {STRING_TOKEN(STR_DEF_IMG_LOAD
), &gEfiDeferredImageLoadProtocolGuid
, NULL
},
603 {STRING_TOKEN(STR_USER_CRED
), &gEfiUserCredentialProtocolGuid
, NULL
},
604 {STRING_TOKEN(STR_USER_MNGR
), &gEfiUserManagerProtocolGuid
, NULL
},
605 {STRING_TOKEN(STR_ATA_PASS_THRU
), &gEfiAtaPassThruProtocolGuid
, NULL
},
610 {STRING_TOKEN(STR_FW_MGMT
), &gEfiFirmwareManagementProtocolGuid
, NULL
},
611 {STRING_TOKEN(STR_IP_SEC
), &gEfiIpSecProtocolGuid
, NULL
},
612 {STRING_TOKEN(STR_IP_SEC2
), &gEfiIpSec2ProtocolGuid
, NULL
},
617 {STRING_TOKEN(STR_KMS
), &gEfiKmsProtocolGuid
, NULL
},
618 {STRING_TOKEN(STR_BLK_IO2
), &gEfiBlockIo2ProtocolGuid
, NULL
},
619 {STRING_TOKEN(STR_SSC
), &gEfiStorageSecurityCommandProtocolGuid
, NULL
},
620 {STRING_TOKEN(STR_UC2
), &gEfiUserCredential2ProtocolGuid
, NULL
},
625 {STRING_TOKEN(STR_UNKNOWN_DEVICE
), NULL
, NULL
},
629 Function to get the node for a protocol or struct from it's GUID.
631 if Guid is NULL, then ASSERT.
633 @param[in] Guid The GUID to look for the name of.
637 CONST GUID_INFO_BLOCK
*
639 InternalShellGetNodeFromGuid(
640 IN CONST EFI_GUID
* Guid
643 CONST GUID_INFO_BLOCK
*ListWalker
;
645 ASSERT(Guid
!= NULL
);
647 if (PcdGetBool(PcdShellIncludeNtGuids
)) {
648 for (ListWalker
= mGuidStringListNT
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
649 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
654 for (ListWalker
= mGuidStringList
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
655 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
663 Function to get the name of a protocol or struct from it's GUID.
665 if Guid is NULL, then ASSERT.
667 @param[in] Guid The GUID to look for the name of.
668 @param[in] Lang The language to use.
670 @return pointer to string of the name. The caller
671 is responsible to free this memory.
675 GetStringNameFromGuid(
676 IN CONST EFI_GUID
*Guid
,
677 IN CONST CHAR8
*Lang OPTIONAL
680 CONST GUID_INFO_BLOCK
*Id
;
682 Id
= InternalShellGetNodeFromGuid(Guid
);
683 return (HiiGetString(mHandleParsingHiiHandle
, Id
->StringId
, Lang
));
687 Function to dump protocol information from a handle.
689 This function will return a allocated string buffer containing the
690 information. The caller is responsible for freeing the memory.
692 If Guid is NULL, ASSERT().
693 If TheHandle is NULL, ASSERT().
695 @param[in] TheHandle The handle to dump information from.
696 @param[in] Guid The GUID of the protocol to dump.
697 @param[in] Verbose TRUE for extra info. FALSE otherwise.
699 @return The pointer to string.
700 @retval NULL An error was encountered.
704 GetProtocolInformationDump(
705 IN CONST EFI_HANDLE TheHandle
,
706 IN CONST EFI_GUID
*Guid
,
707 IN CONST BOOLEAN Verbose
710 CONST GUID_INFO_BLOCK
*Id
;
712 ASSERT(TheHandle
!= NULL
);
713 ASSERT(Guid
!= NULL
);
715 if (TheHandle
== NULL
|| Guid
== NULL
) {
719 Id
= InternalShellGetNodeFromGuid(Guid
);
720 if (Id
!= NULL
&& Id
->DumpInfo
!= NULL
) {
721 return (Id
->DumpInfo(TheHandle
, Verbose
));
727 Function to get the Guid for a protocol or struct based on it's string name.
729 @param[in] Name The pointer to the string name.
730 @param[in] Lang The pointer to the language code.
731 @param[in] Guid The pointer to the Guid.
733 @retval EFI_SUCCESS The operation was sucessful.
737 GetGuidFromStringName(
738 IN CONST CHAR16
*Name
,
739 IN CONST CHAR8
*Lang OPTIONAL
,
743 CONST GUID_INFO_BLOCK
*ListWalker
;
746 ASSERT(Guid
!= NULL
);
748 return (EFI_INVALID_PARAMETER
);
752 if (PcdGetBool(PcdShellIncludeNtGuids
)) {
753 for (ListWalker
= mGuidStringListNT
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
754 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
755 if (Name
!= NULL
&& String
!= NULL
&& StrCmp(Name
, String
)==0) {
756 *Guid
= ListWalker
->GuidId
;
758 SHELL_FREE_NON_NULL(String
);
760 return (EFI_SUCCESS
);
764 for (ListWalker
= mGuidStringList
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
765 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
766 if (Name
!= NULL
&& String
!= NULL
&& StrCmp(Name
, String
)==0) {
767 *Guid
= ListWalker
->GuidId
;
769 SHELL_FREE_NON_NULL(String
);
771 return (EFI_SUCCESS
);
774 return (EFI_NOT_FOUND
);
778 Function to retrieve the driver name (if possible) from the ComponentName or
779 ComponentName2 protocol
781 @param[in] TheHandle The driver handle to get the name of.
782 @param[in] Language The language to use.
784 @retval NULL The name could not be found.
785 @return A pointer to the string name. Do not de-allocate the memory.
789 GetStringNameFromHandle(
790 IN CONST EFI_HANDLE TheHandle
,
791 IN CONST CHAR8
*Language
794 EFI_COMPONENT_NAME2_PROTOCOL
*CompNameStruct
;
798 Status
= gBS
->OpenProtocol(
800 &gEfiComponentName2ProtocolGuid
,
801 (VOID
**)&CompNameStruct
,
804 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
805 if (!EFI_ERROR(Status
)) {
806 Status
= CompNameStruct
->GetDriverName(CompNameStruct
, (CHAR8
*)Language
, &RetVal
);
807 if (!EFI_ERROR(Status
)) {
811 Status
= gBS
->OpenProtocol(
813 &gEfiComponentNameProtocolGuid
,
814 (VOID
**)&CompNameStruct
,
817 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
818 if (!EFI_ERROR(Status
)) {
819 Status
= CompNameStruct
->GetDriverName(CompNameStruct
, (CHAR8
*)Language
, &RetVal
);
820 if (!EFI_ERROR(Status
)) {
828 Function to initialize the file global mHandleList object for use in
829 vonverting handles to index and index to handle.
831 @retval EFI_SUCCESS The operation was successful.
835 InternalShellInitHandleList(
840 EFI_HANDLE
*HandleBuffer
;
842 HANDLE_LIST
*ListWalker
;
844 if (mHandleList
.NextIndex
!= 0) {
847 InitializeListHead(&mHandleList
.List
.Link
);
848 mHandleList
.NextIndex
= 1;
849 Status
= gBS
->LocateHandleBuffer (
856 ASSERT_EFI_ERROR(Status
);
857 if (EFI_ERROR(Status
)) {
860 for (mHandleList
.NextIndex
= 1 ; mHandleList
.NextIndex
<= HandleCount
; mHandleList
.NextIndex
++){
861 ListWalker
= AllocateZeroPool(sizeof(HANDLE_LIST
));
862 ASSERT(ListWalker
!= NULL
);
863 ListWalker
->TheHandle
= HandleBuffer
[mHandleList
.NextIndex
-1];
864 ListWalker
->TheIndex
= mHandleList
.NextIndex
;
865 InsertTailList(&mHandleList
.List
.Link
,&ListWalker
->Link
);
867 FreePool(HandleBuffer
);
868 return (EFI_SUCCESS
);
872 Function to retrieve the human-friendly index of a given handle. If the handle
873 does not have a index one will be automatically assigned. The index value is valid
874 until the termination of the shell application.
876 @param[in] TheHandle The handle to retrieve an index for.
878 @retval 0 A memory allocation failed.
879 @return The index of the handle.
884 ConvertHandleToHandleIndex(
885 IN CONST EFI_HANDLE TheHandle
888 HANDLE_LIST
*ListWalker
;
889 if (TheHandle
== NULL
) {
893 InternalShellInitHandleList();
895 for (ListWalker
= (HANDLE_LIST
*)GetFirstNode(&mHandleList
.List
.Link
)
896 ; !IsNull(&mHandleList
.List
.Link
,&ListWalker
->Link
)
897 ; ListWalker
= (HANDLE_LIST
*)GetNextNode(&mHandleList
.List
.Link
,&ListWalker
->Link
)
899 if (ListWalker
->TheHandle
== TheHandle
) {
900 return (ListWalker
->TheIndex
);
903 ListWalker
= AllocateZeroPool(sizeof(HANDLE_LIST
));
904 ASSERT(ListWalker
!= NULL
);
905 ListWalker
->TheHandle
= TheHandle
;
906 ListWalker
->TheIndex
= mHandleList
.NextIndex
++;
907 InsertTailList(&mHandleList
.List
.Link
,&ListWalker
->Link
);
908 return (ListWalker
->TheIndex
);
914 Function to retrieve the EFI_HANDLE from the human-friendly index.
916 @param[in] TheIndex The index to retrieve the EFI_HANDLE for.
918 @retval NULL The index was invalid.
919 @return The EFI_HANDLE that index represents.
924 ConvertHandleIndexToHandle(
925 IN CONST UINTN TheIndex
928 HANDLE_LIST
*ListWalker
;
930 InternalShellInitHandleList();
932 if (TheIndex
>= mHandleList
.NextIndex
) {
936 for (ListWalker
= (HANDLE_LIST
*)GetFirstNode(&mHandleList
.List
.Link
)
937 ; !IsNull(&mHandleList
.List
.Link
,&ListWalker
->Link
)
938 ; ListWalker
= (HANDLE_LIST
*)GetNextNode(&mHandleList
.List
.Link
,&ListWalker
->Link
)
940 if (ListWalker
->TheIndex
== TheIndex
) {
941 return (ListWalker
->TheHandle
);
948 Gets all the related EFI_HANDLEs based on the mask supplied.
950 This function scans all EFI_HANDLES in the UEFI environment's handle database
951 and returns the ones with the specified relationship (Mask) to the specified
954 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
955 If MatchingHandleCount is NULL, then ASSERT.
957 If MatchingHandleBuffer is not NULL upon a successful return the memory must be
960 @param[in] DriverBindingHandle The handle with Driver Binding protocol on it.
961 @param[in] ControllerHandle The handle with Device Path protocol on it.
962 @param[in] MatchingHandleCount The pointer to UINTN that specifies the number of HANDLES in
963 MatchingHandleBuffer.
964 @param[out] MatchingHandleBuffer On a successful return, a buffer of MatchingHandleCount
965 EFI_HANDLEs with a terminating NULL EFI_HANDLE.
966 @param[out] HandleType An array of type information.
968 @retval EFI_SUCCESS The operation was successful, and any related handles
969 are in MatchingHandleBuffer.
970 @retval EFI_NOT_FOUND No matching handles were found.
971 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.
975 ParseHandleDatabaseByRelationshipWithType (
976 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL
,
977 IN CONST EFI_HANDLE ControllerHandle OPTIONAL
,
978 IN UINTN
*HandleCount
,
979 OUT EFI_HANDLE
**HandleBuffer
,
980 OUT UINTN
**HandleType
985 EFI_GUID
**ProtocolGuidArray
;
988 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY
*OpenInfo
;
993 ASSERT(HandleCount
!= NULL
);
994 ASSERT(HandleBuffer
!= NULL
);
995 ASSERT(HandleType
!= NULL
);
996 ASSERT(DriverBindingHandle
!= NULL
|| ControllerHandle
!= NULL
);
999 *HandleBuffer
= NULL
;
1003 // Retrieve the list of all handles from the handle database
1005 Status
= gBS
->LocateHandleBuffer (
1012 if (EFI_ERROR (Status
)) {
1016 *HandleType
= AllocateZeroPool (*HandleCount
* sizeof (UINTN
));
1017 ASSERT(*HandleType
!= NULL
);
1019 for (HandleIndex
= 0; HandleIndex
< *HandleCount
; HandleIndex
++) {
1021 // Retrieve the list of all the protocols on each handle
1023 Status
= gBS
->ProtocolsPerHandle (
1024 (*HandleBuffer
)[HandleIndex
],
1028 if (!EFI_ERROR (Status
)) {
1030 for (ProtocolIndex
= 0; ProtocolIndex
< ArrayCount
; ProtocolIndex
++) {
1033 // Set the bit describing what this handle has
1035 if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiLoadedImageProtocolGuid
) ) {
1036 (*HandleType
)[HandleIndex
] |= HR_IMAGE_HANDLE
;
1037 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverBindingProtocolGuid
) ) {
1038 (*HandleType
)[HandleIndex
] |= HR_DRIVER_BINDING_HANDLE
;
1039 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverConfiguration2ProtocolGuid
)) {
1040 (*HandleType
)[HandleIndex
] |= HR_DRIVER_CONFIGURATION_HANDLE
;
1041 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverConfigurationProtocolGuid
) ) {
1042 (*HandleType
)[HandleIndex
] |= HR_DRIVER_CONFIGURATION_HANDLE
;
1043 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverDiagnostics2ProtocolGuid
) ) {
1044 (*HandleType
)[HandleIndex
] |= HR_DRIVER_DIAGNOSTICS_HANDLE
;
1045 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverDiagnosticsProtocolGuid
) ) {
1046 (*HandleType
)[HandleIndex
] |= HR_DRIVER_DIAGNOSTICS_HANDLE
;
1047 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiComponentName2ProtocolGuid
) ) {
1048 (*HandleType
)[HandleIndex
] |= HR_COMPONENT_NAME_HANDLE
;
1049 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiComponentNameProtocolGuid
) ) {
1050 (*HandleType
)[HandleIndex
] |= HR_COMPONENT_NAME_HANDLE
;
1051 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDevicePathProtocolGuid
) ) {
1052 (*HandleType
)[HandleIndex
] |= HR_DEVICE_HANDLE
;
1055 ASSERT((*HandleType
)[HandleIndex
] == (*HandleType
)[HandleIndex
]);
1059 // Retrieve the list of agents that have opened each protocol
1061 Status
= gBS
->OpenProtocolInformation (
1062 (*HandleBuffer
)[HandleIndex
],
1063 ProtocolGuidArray
[ProtocolIndex
],
1067 if (!EFI_ERROR (Status
)) {
1068 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
1069 if (DriverBindingHandle
!= NULL
&& OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
) {
1070 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) == EFI_OPEN_PROTOCOL_BY_DRIVER
) {
1071 (*HandleType
)[HandleIndex
] |= (HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
1073 if (ControllerHandle
!= NULL
&& (*HandleBuffer
)[HandleIndex
] == ControllerHandle
) {
1074 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) == EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) {
1075 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
1076 if ((*HandleBuffer
)[ChildIndex
] == OpenInfo
[OpenInfoIndex
].ControllerHandle
) {
1077 (*HandleType
)[ChildIndex
] |= (HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
1083 if (DriverBindingHandle
== NULL
&& OpenInfo
[OpenInfoIndex
].ControllerHandle
== ControllerHandle
) {
1084 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) == EFI_OPEN_PROTOCOL_BY_DRIVER
) {
1085 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
1086 if ((*HandleBuffer
)[ChildIndex
] == OpenInfo
[OpenInfoIndex
].AgentHandle
) {
1087 (*HandleType
)[ChildIndex
] |= HR_DEVICE_DRIVER
;
1091 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) == EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) {
1092 (*HandleType
)[HandleIndex
] |= HR_PARENT_HANDLE
;
1093 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
1094 if ((*HandleBuffer
)[ChildIndex
] == OpenInfo
[OpenInfoIndex
].AgentHandle
) {
1095 (*HandleType
)[ChildIndex
] |= HR_BUS_DRIVER
;
1102 FreePool (OpenInfo
);
1106 FreePool (ProtocolGuidArray
);
1110 if (EFI_ERROR(Status
)) {
1111 if (*HandleType
!= NULL
) {
1112 FreePool (*HandleType
);
1114 if (*HandleBuffer
!= NULL
) {
1115 FreePool (*HandleBuffer
);
1119 *HandleBuffer
= NULL
;
1127 Gets all the related EFI_HANDLEs based on the single EFI_HANDLE and the mask
1130 This function will scan all EFI_HANDLES in the UEFI environment's handle database
1131 and return all the ones with the specified relationship (Mask) to the specified
1134 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
1135 If MatchingHandleCount is NULL, then ASSERT.
1137 If MatchingHandleBuffer is not NULL upon a sucessful return the memory must be
1140 @param[in] DriverBindingHandle Handle to a object with Driver Binding protocol
1142 @param[in] ControllerHandle Handle to a device with Device Path protocol on it.
1143 @param[in] Mask Mask of what relationship(s) is desired.
1144 @param[in] MatchingHandleCount Poitner to UINTN specifying number of HANDLES in
1145 MatchingHandleBuffer.
1146 @param[out] MatchingHandleBuffer On a sucessful return a buffer of MatchingHandleCount
1147 EFI_HANDLEs and a terminating NULL EFI_HANDLE.
1149 @retval EFI_SUCCESS The operation was sucessful and any related handles
1150 are in MatchingHandleBuffer;
1151 @retval EFI_NOT_FOUND No matching handles were found.
1152 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.
1156 ParseHandleDatabaseByRelationship (
1157 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL
,
1158 IN CONST EFI_HANDLE ControllerHandle OPTIONAL
,
1159 IN CONST UINTN Mask
,
1160 IN UINTN
*MatchingHandleCount
,
1161 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
1166 EFI_HANDLE
*HandleBuffer
;
1170 ASSERT(MatchingHandleCount
!= NULL
);
1171 ASSERT(DriverBindingHandle
!= NULL
|| ControllerHandle
!= NULL
);
1173 if ((Mask
& HR_VALID_MASK
) != Mask
) {
1174 return (EFI_INVALID_PARAMETER
);
1177 if ((Mask
& HR_CHILD_HANDLE
) != 0 && DriverBindingHandle
== NULL
) {
1178 return (EFI_INVALID_PARAMETER
);
1181 *MatchingHandleCount
= 0;
1182 if (MatchingHandleBuffer
!= NULL
) {
1183 *MatchingHandleBuffer
= NULL
;
1186 HandleBuffer
= NULL
;
1189 Status
= ParseHandleDatabaseByRelationshipWithType (
1190 DriverBindingHandle
,
1196 if (!EFI_ERROR (Status
)) {
1198 // Count the number of handles that match the attributes in Mask
1200 for (HandleIndex
= 0; HandleIndex
< HandleCount
; HandleIndex
++) {
1201 if ((HandleType
[HandleIndex
] & Mask
) == Mask
) {
1202 (*MatchingHandleCount
)++;
1206 // If no handles match the attributes in Mask then return EFI_NOT_FOUND
1208 if (*MatchingHandleCount
== 0) {
1209 Status
= EFI_NOT_FOUND
;
1212 if (MatchingHandleBuffer
== NULL
) {
1214 // Someone just wanted the count...
1216 Status
= EFI_SUCCESS
;
1219 // Allocate a handle buffer for the number of handles that matched the attributes in Mask
1221 *MatchingHandleBuffer
= AllocateZeroPool ((*MatchingHandleCount
+1)* sizeof (EFI_HANDLE
));
1222 ASSERT(*MatchingHandleBuffer
!= NULL
);
1224 for (HandleIndex
= 0,*MatchingHandleCount
= 0
1225 ; HandleIndex
< HandleCount
1229 // Fill the allocated buffer with the handles that matched the attributes in Mask
1231 if ((HandleType
[HandleIndex
] & Mask
) == Mask
) {
1232 (*MatchingHandleBuffer
)[(*MatchingHandleCount
)++] = HandleBuffer
[HandleIndex
];
1237 // Make the last one NULL
1239 (*MatchingHandleBuffer
)[*MatchingHandleCount
] = NULL
;
1241 Status
= EFI_SUCCESS
;
1242 } // MacthingHandleBuffer == NULL (ELSE)
1243 } // *MatchingHandleCount == 0 (ELSE)
1244 } // no error on ParseHandleDatabaseByRelationshipWithType
1246 if (HandleBuffer
!= NULL
) {
1247 FreePool (HandleBuffer
);
1250 if (HandleType
!= NULL
) {
1251 FreePool (HandleType
);
1258 Gets handles for any child controllers of the passed in controller.
1260 @param[in] ControllerHandle The handle of the "parent controller"
1261 @param[in] MatchingHandleCount Pointer to the number of handles in
1262 MatchingHandleBuffer on return.
1263 @param[out] MatchingHandleBuffer Buffer containing handles on a successful
1267 @retval EFI_SUCCESS The operation was sucessful.
1271 ParseHandleDatabaseForChildControllers(
1272 IN CONST EFI_HANDLE ControllerHandle
,
1273 IN UINTN
*MatchingHandleCount
,
1274 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
1278 // UINTN HandleIndex;
1279 UINTN DriverBindingHandleCount
;
1280 EFI_HANDLE
*DriverBindingHandleBuffer
;
1281 UINTN DriverBindingHandleIndex
;
1282 UINTN ChildControllerHandleCount
;
1283 EFI_HANDLE
*ChildControllerHandleBuffer
;
1284 UINTN ChildControllerHandleIndex
;
1286 EFI_HANDLE
*HandleBufferForReturn
;
1288 if (MatchingHandleCount
== NULL
) {
1289 return (EFI_INVALID_PARAMETER
);
1291 *MatchingHandleCount
= 0;
1293 Status
= PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
1295 &DriverBindingHandleCount
,
1296 &DriverBindingHandleBuffer
1298 if (EFI_ERROR (Status
)) {
1303 // Get a buffer big enough for all the controllers.
1305 HandleBufferForReturn
= GetHandleListByProtocol(&gEfiDevicePathProtocolGuid
);
1306 if (HandleBufferForReturn
== NULL
) {
1307 FreePool (DriverBindingHandleBuffer
);
1308 return (EFI_NOT_FOUND
);
1311 for (DriverBindingHandleIndex
= 0; DriverBindingHandleIndex
< DriverBindingHandleCount
; DriverBindingHandleIndex
++) {
1312 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
1313 DriverBindingHandleBuffer
[DriverBindingHandleIndex
],
1315 &ChildControllerHandleCount
,
1316 &ChildControllerHandleBuffer
1318 if (EFI_ERROR (Status
)) {
1322 for (ChildControllerHandleIndex
= 0;
1323 ChildControllerHandleIndex
< ChildControllerHandleCount
;
1324 ChildControllerHandleIndex
++
1327 HandleBufferForReturn
[(*MatchingHandleCount
)++] = ChildControllerHandleBuffer
[ChildControllerHandleIndex
];
1328 // for (HandleIndex = 0; HandleBufferForReturn[HandleIndex] != NULL; HandleIndex++) {
1329 // if (HandleBufferForReturn[HandleIndex] == ChildControllerHandleBuffer[ChildControllerHandleIndex]) {
1336 // HandleBufferForReturn[(*MatchingHandleCount)++] = ChildControllerHandleBuffer[ChildControllerHandleIndex];
1340 FreePool (ChildControllerHandleBuffer
);
1343 FreePool (DriverBindingHandleBuffer
);
1345 if (MatchingHandleBuffer
!= NULL
) {
1346 *MatchingHandleBuffer
= HandleBufferForReturn
;
1348 FreePool(HandleBufferForReturn
);
1351 return (EFI_SUCCESS
);
1355 Appends 1 buffer to another buffer. This will re-allocate the destination buffer
1356 if necessary to fit all of the data.
1358 If DestinationBuffer is NULL, then ASSERT().
1360 @param[in, out] DestinationBuffer The pointer to the pointer to the buffer to append onto.
1361 @param[in, out] DestinationSize The pointer to the size of DestinationBuffer.
1362 @param[in] SourceBuffer The pointer to the buffer to append onto DestinationBuffer.
1363 @param[in] SourceSize The number of bytes of SourceBuffer to append.
1365 @retval NULL A memory allocation failed.
1366 @retval NULL A parameter was invalid.
1367 @return A pointer to (*DestinationBuffer).
1372 IN OUT VOID
**DestinationBuffer
,
1373 IN OUT UINTN
*DestinationSize
,
1374 IN VOID
*SourceBuffer
,
1378 UINTN LocalDestinationSize
;
1379 UINTN LocalDestinationFinalSize
;
1381 ASSERT(DestinationBuffer
!= NULL
);
1383 if (SourceSize
== 0 || SourceBuffer
== NULL
) {
1384 return (*DestinationBuffer
);
1387 if (DestinationSize
== NULL
) {
1388 LocalDestinationSize
= 0;
1390 LocalDestinationSize
= *DestinationSize
;
1393 LocalDestinationFinalSize
= LocalDestinationSize
+ SourceSize
;
1395 if (DestinationSize
!= NULL
) {
1396 *DestinationSize
= LocalDestinationSize
;
1399 if (LocalDestinationSize
== 0) {
1401 *DestinationBuffer
= AllocateZeroPool(LocalDestinationFinalSize
);
1404 *DestinationBuffer
= ReallocatePool(LocalDestinationSize
, LocalDestinationFinalSize
, *DestinationBuffer
);
1407 ASSERT(*DestinationBuffer
!= NULL
);
1410 return (CopyMem(((UINT8
*)(*DestinationBuffer
)) + LocalDestinationSize
, SourceBuffer
, SourceSize
));
1414 Gets handles for any child devices produced by the passed in driver.
1416 @param[in] DriverHandle The handle of the driver.
1417 @param[in] MatchingHandleCount Pointer to the number of handles in
1418 MatchingHandleBuffer on return.
1419 @param[out] MatchingHandleBuffer Buffer containing handles on a successful
1421 @retval EFI_SUCCESS The operation was sucessful.
1422 @sa ParseHandleDatabaseByRelationship
1426 ParseHandleDatabaseForChildDevices(
1427 IN CONST EFI_HANDLE DriverHandle
,
1428 IN UINTN
*MatchingHandleCount
,
1429 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
1433 EFI_HANDLE
*Buffer2
;
1438 UINTN HandleBufferSize
;
1440 ASSERT(MatchingHandleCount
!= NULL
);
1442 HandleBufferSize
= 0;
1445 *MatchingHandleCount
= 0;
1447 Status
= PARSE_HANDLE_DATABASE_DEVICES (
1452 if (!EFI_ERROR (Status
)) {
1453 for (HandleIndex
= 0; HandleIndex
< Count1
; HandleIndex
++) {
1455 // now find the children
1457 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
1459 Buffer
[HandleIndex
],
1463 if (EFI_ERROR(Status
)) {
1467 // save out required and optional data elements
1469 *MatchingHandleCount
+= Count2
;
1470 if (MatchingHandleBuffer
!= NULL
) {
1471 *MatchingHandleBuffer
= BuffernCatGrow((VOID
**)MatchingHandleBuffer
, &HandleBufferSize
, Buffer2
, Count2
* sizeof(Buffer2
[0]));
1477 if (Buffer2
!= NULL
) {
1483 if (Buffer
!= NULL
) {
1490 Function to get all handles that support a given protocol or all handles.
1492 @param[in] ProtocolGuid The guid of the protocol to get handles for. If NULL
1493 then the function will return all handles.
1495 @retval NULL A memory allocation failed.
1496 @return A NULL terminated list of handles.
1500 GetHandleListByProtocol (
1501 IN CONST EFI_GUID
*ProtocolGuid OPTIONAL
1504 EFI_HANDLE
*HandleList
;
1512 // We cannot use LocateHandleBuffer since we need that NULL item on the ends of the list!
1514 if (ProtocolGuid
== NULL
) {
1515 Status
= gBS
->LocateHandle(AllHandles
, NULL
, NULL
, &Size
, HandleList
);
1516 if (Status
== EFI_BUFFER_TOO_SMALL
) {
1517 HandleList
= AllocateZeroPool(Size
+ sizeof(EFI_HANDLE
));
1518 if (HandleList
== NULL
) {
1521 Status
= gBS
->LocateHandle(AllHandles
, NULL
, NULL
, &Size
, HandleList
);
1522 HandleList
[Size
/sizeof(EFI_HANDLE
)] = NULL
;
1525 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)ProtocolGuid
, NULL
, &Size
, HandleList
);
1526 if (Status
== EFI_BUFFER_TOO_SMALL
) {
1527 HandleList
= AllocateZeroPool(Size
+ sizeof(EFI_HANDLE
));
1528 if (HandleList
== NULL
) {
1531 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)ProtocolGuid
, NULL
, &Size
, HandleList
);
1532 HandleList
[Size
/sizeof(EFI_HANDLE
)] = NULL
;
1535 if (EFI_ERROR(Status
)) {
1536 if (HandleList
!= NULL
) {
1537 FreePool(HandleList
);
1541 return (HandleList
);
1545 Function to get all handles that support some protocols.
1547 @param[in] ProtocolGuids A NULL terminated list of protocol GUIDs.
1549 @retval NULL A memory allocation failed.
1550 @retval NULL ProtocolGuids was NULL.
1551 @return A NULL terminated list of EFI_HANDLEs.
1555 GetHandleListByProtocolList (
1556 IN CONST EFI_GUID
**ProtocolGuids
1559 EFI_HANDLE
*HandleList
;
1564 CONST EFI_GUID
**GuidWalker
;
1565 EFI_HANDLE
*HandleWalker1
;
1566 EFI_HANDLE
*HandleWalker2
;
1570 TotalSize
= sizeof(EFI_HANDLE
);
1572 for (GuidWalker
= ProtocolGuids
; GuidWalker
!= NULL
&& *GuidWalker
!= NULL
; GuidWalker
++,Size
= 0){
1573 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)(*GuidWalker
), NULL
, &Size
, NULL
);
1574 if (Status
== EFI_BUFFER_TOO_SMALL
) {
1580 // No handles were found...
1582 if (TotalSize
== sizeof(EFI_HANDLE
)) {
1586 HandleList
= AllocateZeroPool(TotalSize
);
1587 if (HandleList
== NULL
) {
1592 for (GuidWalker
= ProtocolGuids
; GuidWalker
!= NULL
&& *GuidWalker
!= NULL
; GuidWalker
++){
1593 TempSize
= TotalSize
- Size
;
1594 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)(*GuidWalker
), NULL
, &TempSize
, HandleList
+(Size
/sizeof(EFI_HANDLE
)));
1597 // Allow for missing protocols... Only update the 'used' size upon success.
1599 if (!EFI_ERROR(Status
)) {
1603 ASSERT(HandleList
[(TotalSize
/sizeof(EFI_HANDLE
))-1] == NULL
);
1605 for (HandleWalker1
= HandleList
; HandleWalker1
!= NULL
&& *HandleWalker1
!= NULL
; HandleWalker1
++) {
1606 for (HandleWalker2
= HandleWalker1
+ 1; HandleWalker2
!= NULL
&& *HandleWalker2
!= NULL
; HandleWalker2
++) {
1607 if (*HandleWalker1
== *HandleWalker2
) {
1609 // copy memory back 1 handle width.
1611 CopyMem(HandleWalker2
, HandleWalker2
+ 1, TotalSize
- ((HandleWalker2
-HandleList
+1)*sizeof(EFI_HANDLE
)));
1616 return (HandleList
);