Upstream/CloverBootloader
1
0
Fork 0
mirror of https://github.com/CloverHackyColor/CloverBootloader.git synced 2024-11-27 12:15:19 +01:00
Code Issues Packages Projects Releases Wiki Activity
ade55d54a5
CloverBootloader/Protocols/DumpUefiCalls/Lib.c
Sergey Isakov 6a56c2951b refactoring, renaming, cleanup
2019-10-04 23:32:02 +03:00

1105 lines
50 KiB
C
Raw Blame History

/** @file
Various helper functions.
By dmazar, 26/09/2012
**/
#include <Library/UefiLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiRuntimeServicesTableLib.h>
#include <Library/DebugLib.h>
#include <Library/PrintLib.h>
#include <Library/DevicePathLib.h>
#include <Protocol/LoadedImage.h>
#include <Protocol/BlockIo.h>
#include <Protocol/BlockIo2.h>
#include <Protocol/DiskIo.h>
#include <Protocol/DiskIo2.h>
#include <Protocol/SimpleFileSystem.h>
#include <Include/Guid/FileInfo.h>
#include <Include/Guid/FileSystemInfo.h>
#include <Include/Guid/FileSystemVolumeLabelInfo.h>
#include <Include/Guid/Acpi.h>
#include <Include/Guid/DebugImageInfoTable.h>
#include <Include/Guid/DxeServices.h>
#include <Include/Guid/HobList.h>
#include <Include/Guid/Mps.h>
#include <Include/Guid/SmBios.h>
#include "Common.h"
/** Memory type to string conversion */
CHAR16 *EfiMemoryTypeDesc[EfiMaxMemoryType] = {
L"reserved",
L"LoaderCode",
L"LoaderData",
L"BS_code",
L"BS_data",
L"RT_code",
L"RT_data",
L"available",
L"Unusable",
L"ACPI_recl",
L"ACPI_NVS",
L"MemMapIO",
L"MemPortIO",
L"PAL_code"
};
/** Allocation type to string conversion */
CHAR16 *EfiAllocateTypeDesc[MaxAllocateType] = {
L"AllocateAnyPages",
L"AllocateMaxAddress",
L"AllocateAddress"
};
/** Locate search type to string conversion */
CHAR16 *EfiLocateSearchType[] = {
L"AllHandles",
L"ByRegisterNotify",
L"ByProtocol"
};
/** Reset type to string conversion */
CHAR16 *EfiResetType[] = {
L"EfiResetCold",
L"EfiResetWarm",
L"EfiResetShutdown"
};
//
// Some known guids
//
EFI_GUID mEfiConsoleControlProtocolGuid = {0xF42F7782, 0x012E, 0x4C12, {0x99, 0x56, 0x49, 0xF9, 0x43, 0x04, 0xF7, 0x21}};
EFI_GUID mAppleFirmwarePasswordProtocolGuid = {0x8FFEEB3A, 0x4C98, 0x4630, {0x80, 0x3F, 0x74, 0x0F, 0x95, 0x67, 0x09, 0x1D}};
EFI_GUID mEfiGlobalVariableGuid = {0x8BE4DF61, 0x93CA, 0x11D2, {0xAA, 0x0D, 0x00, 0xE0, 0x98, 0x03, 0x2B, 0x8C}};
EFI_GUID mAppleDevicePropertyProtocolGuid = {0x91BD12FE, 0xF6C3, 0x44FB, {0xA5, 0xB7, 0x51, 0x22, 0xAB, 0x30, 0x3A, 0xE0}};
EFI_GUID mEfiAppleBootGuid = {0x7C436110, 0xAB2A, 0x4BBB, {0xA8, 0x80, 0xFE, 0x41, 0x99, 0x5C, 0x9F, 0x82}};
EFI_GUID mEfiAppleNvramGuid = {0x4D1EDE05, 0x38C7, 0x4A6A, {0x9C, 0xC6, 0x4B, 0xCC, 0xA8, 0xB3, 0x8C, 0x14}};
EFI_GUID mAppleFramebufferInfoProtocolGuid = {0xE316E100, 0x0751, 0x4C49, {0x90, 0x56, 0x48, 0x6C, 0x7E, 0x47, 0x29, 0x03}};
EFI_GUID mAppleKeyStateProtocolGuid = {0x5B213447, 0x6E73, 0x4901, {0xA4, 0xF1, 0xB8, 0x64, 0xF3, 0xB7, 0xA1, 0x72}};
EFI_GUID mAppleNetBootProtocolGuid = {0x78EE99FB, 0x6A5E, 0x4186, {0x97, 0xDE, 0xCD, 0x0A, 0xBA, 0x34, 0x5A, 0x74}};
EFI_GUID mAppleImageCodecProtocolGuid = {0x0DFCE9F6, 0xC4E3, 0x45EE, {0xA0, 0x6A, 0xA8, 0x61, 0x3B, 0x98, 0xA5, 0x07}};
EFI_GUID mAppleEfiVendorGuid = {0xAC39C713, 0x7E50, 0x423D, {0x88, 0x9D, 0x27, 0x8F, 0xCC, 0x34, 0x22, 0xB6}};
EFI_GUID mAppleEFINVRAMTRBSecureGuid = {0xF68DA75E, 0x1B55, 0x4E70, {0xB4, 0x1B, 0xA7, 0xB7, 0xA5, 0xB7, 0x58, 0xEA}};
EFI_GUID mDataHubOptionsGuid = {0x0021001C, 0x3CE3, 0x41F8, {0x99, 0xC6, 0xEC, 0xF5, 0xDA, 0x75, 0x47, 0x31}};
EFI_GUID mRestartDataProtocolGiud = {0x03B99B90, 0xECCF, 0x451D, {0x80, 0x9E, 0x83, 0x41, 0xFC, 0xB8, 0x30, 0xAC}};
EFI_GUID mAppleUserInterfaceThemeProtocolGuid = {0xD5B0AC65, 0x9A2D, 0x4D2A, {0xBB, 0xD6, 0xE8, 0x71, 0xA9, 0x5E, 0x04, 0x35}};
EFI_GUID mApfsEfiBootRecordInfoProtocolGuid = {0x03B8D751, 0xA02F, 0x4FF8, {0x9B, 0x1A, 0x55, 0x24, 0xAF, 0xA3, 0x94, 0x5F}};
EFI_GUID mApplePlatformInfoDatabaseProtocolGuid = {0xAC5E4829, 0xA8FD, 0x440B, {0xAF, 0x33, 0x9F, 0xFE, 0x01, 0x3B, 0x12, 0xD8}};
EFI_GUID mNotifyMouseActivity = {0xF913C2C2, 0x5351, 0x4FDB, {0x93, 0x44, 0x70, 0xFF, 0xED, 0xB8, 0x42, 0x25}};
EFI_GUID mEfiDataHubProtocolGuid = {0xAE80D021, 0x618E, 0x11D4, {0xBC, 0xD7, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81}};
EFI_GUID mEfiMiscSubClassGuid = {0x772484B2, 0x7482, 0x4B91, {0x9F, 0x9A, 0xAD, 0x43, 0xF8, 0x1C, 0x58, 0x81}};
EFI_GUID mEfiProcessorSubClassGuid = {0x26FDEB7E, 0xB8AF, 0x4CCF, {0xAA, 0x97, 0x02, 0x63, 0x3C, 0xE4, 0x8C, 0xA7}};
EFI_GUID mEfiCacheSubClassGuid = {0x7f0013A7, 0xDC79, 0x4B22, {0x80, 0x99, 0x11, 0xF7, 0x5F, 0xDC, 0x82, 0x9D}};
EFI_GUID mEfiMemorySubClassGuid = {0x4E8F4EBB, 0x64B9, 0x4E05, {0x9B, 0x18, 0x4C, 0xFE, 0x49, 0x23, 0x50, 0x97}};
EFI_GUID mEfiDataHubStatusCodeRecordGuid = {0xD083E94C, 0x6560, 0x42E4, {0xB6, 0xD4, 0x2D, 0xF7, 0x5A, 0xDF, 0x6A, 0x2A}};
EFI_GUID mEfiStatusCodeRuntimeProtocolGuid = {0xD2B2B828, 0x0826, 0x48A7, {0xB3, 0xDF, 0x98, 0x3C, 0x00, 0x60, 0x24, 0xF0}};
EFI_GUID mEfiStatusCodeGuid = {0xD083E94C, 0x6560, 0x42E4, {0xB6, 0xD4, 0x2D, 0xF7, 0x5A, 0xDF, 0x6A, 0x2A}};
EFI_GUID mMsgLogProtocolGuid = {0x511CE018, 0x0018, 0x4002, {0x20, 0x12, 0x17, 0x38, 0x05, 0x01, 0x02, 0x03}};
EFI_GUID mEfiLegacy8259ProtocolGuid = {0x38321DBA, 0x4FE0, 0x4E17, {0x8A, 0xEC, 0x41, 0x30, 0x55, 0xEA, 0xED, 0xC1}};
EFI_GUID mEfiMemoryTypeInformationGuid = {0x4C19049F, 0x4137, 0x4DD3, {0x9C, 0x10, 0x8B, 0x97, 0xA8, 0x3F, 0xFD, 0xFA}};
EFI_GUID mEfiSimplePointerProtocolGuid = {0x31878C87, 0x0B75, 0x11D5, {0x9A, 0x4F, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D}};
EFI_GUID mEfiTimeVariableGuid = {0x9D0DA369, 0x540B, 0x46F8, {0x85, 0xA0, 0x2B, 0x5F, 0x2C, 0x30, 0x1E, 0x15}};
EFI_GUID mEfiLegacyRegionProtocolGuid = {0x0FC9013A, 0x0568, 0x4BA9, {0x9B, 0x7E, 0xC9, 0xC3, 0x90, 0xA6, 0x60, 0x9B}};
EFI_GUID mEfiCpuArchProtocolGuid = {0x26BACCB1, 0x6F42, 0x11D4, {0xBC, 0xE7, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81}};
EFI_GUID mEfiMpServiceProtocolGuid = {0xF33261E7, 0x23CB, 0x11D5, {0xBD, 0x5C, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81}};
EFI_GUID mEfiApplePlatformInfoGuid = {0x64517CC8, 0x6561, 0x4051, {0xB0, 0x3C, 0x59, 0x64, 0xB6, 0x0F, 0x4C, 0x7A}};
EFI_GUID mEfiOzmosisNvramGuid = {0x4D1FDA02, 0x38C7, 0x4A6A, {0x9C, 0xC6, 0x4B, 0xCC, 0xA8, 0xB3, 0x01, 0x02}};
EFI_GUID mEfiWdtPersistentDataGuid = {0x78CE2354, 0xCFBC, 0x4643, {0xAE, 0xBA, 0x07, 0xA2, 0x7F, 0xA8, 0x92, 0xBF}};
EFI_GUID mAmiDefaultsVariableGuid = {0x4599D26F, 0x1A11, 0x49B8, {0xB9, 0x1F, 0x85, 0x87, 0x45, 0xCF, 0xF8, 0x24}};
EFI_GUID mEfiRomImageAddressGuid = {0xDDE1BC72, 0xD45E, 0x4209, {0xAB, 0x85, 0x14, 0x46, 0x2D, 0x2F, 0x50, 0x74}};
EFI_GUID mAmiSetupGuid = {0xEC87D643, 0xEBA4, 0x4BB5, {0xA1, 0xE5, 0x3F, 0x3E, 0x36, 0xB2, 0x0D, 0xA9}};
EFI_GUID mEfiPciIoProtocolGuid = {0x4CF5B200, 0x68B8, 0x4CA5, {0x9E, 0xEC, 0xB2, 0x3E, 0x3F, 0x50, 0x02, 0x9A}};
EFI_GUID mEfiFirmwareVolumeProtocolGuid = {0x389F751F, 0x1838, 0x4388, {0x83, 0x90, 0xCD, 0x81, 0x54, 0xBD, 0x27, 0xF8}};
EFI_GUID mEfiTcp4ServiceBindingProtocolGuid = {0x00720665, 0x67EB, 0x4a99, {0xBA, 0xF7, 0xD3, 0xC3, 0x3A, 0x1C, 0x7C, 0xC9}};
EFI_GUID mEfiIp4ServiceBindingProtocolGuid = {0xC51711E7, 0xB4BF, 0x404A, {0xBF, 0xB8, 0x0A, 0x04, 0x8E, 0xF1, 0xFF, 0xE4}};
EFI_GUID mEfiUdp4ServiceBindingProtocolGuid = {0x83F01464, 0x99BD, 0x45E5, {0xB3, 0x83, 0xAF, 0x63, 0x05, 0xD8, 0xE9, 0xE6}};
EFI_GUID mPchInitVariableGuid = {0xE6C2F70A, 0xB604, 0x4877, {0x85, 0xBA, 0xDE, 0xEC, 0x89, 0xE1, 0x17, 0xEB}};
EFI_GUID mEfiMemoryRestoreDataGuid = {0x87F22DCB, 0x7304, 0x4105, {0xBB, 0x7C, 0x31, 0x71, 0x43, 0xCC, 0xC2, 0x3B}};
EFI_GUID mEfiSbAslBufferPtrGuid = {0x01F33C25, 0x764D, 0x43EA, {0xAE, 0xEA, 0x6B, 0x5A, 0x41, 0xF3, 0xF3, 0xE8}};
EFI_GUID mSaPegDataVariableGuid = {0xC4975200, 0x64F1, 0x4FB6, {0x97, 0x73, 0xF6, 0xA9, 0xF8, 0x9D, 0x98, 0x5E}};
EFI_GUID mAmiNvramSpdMapGuid = {0x717FC150, 0xABD9, 0x4614, {0x80, 0x15, 0x0B, 0x33, 0x23, 0xEA, 0xB9, 0x5C}};
EFI_GUID mShellVariableGuid = {0x158DEF5A, 0xF656, 0x419C, {0xB0, 0x27, 0x7A, 0x31, 0x92, 0xC0, 0x79, 0xD2}};
EFI_GUID mTerminalVarGuid = {0x560BF58A, 0x1E0D, 0x4D7E, {0x95, 0x3F, 0x29, 0x80, 0xA2, 0x61, 0xE0, 0x31}};
//AMI UEFI
EFI_GUID mAmiTseSetupGuid = {0xC811FA38, 0x42C8, 0x4579, {0xA9, 0xBB, 0x60, 0xE9, 0x4E, 0xDD, 0xFB, 0x34}};
EFI_GUID mAmiNetworkStackGuid = {0xD1405D16, 0x7AFC, 0x4695, {0xBB, 0x12, 0x41, 0x45, 0x9D, 0x36, 0x95, 0xA2}};
EFI_GUID mAmiRecoveryFormSetGuid = {0x80E1202E, 0x2697, 0x4264, {0x9C, 0xC9, 0x80, 0x76, 0x2C, 0x3E, 0x58, 0x63}};
EFI_GUID mAmiIsaDmaIrqMaskVarGuid = {0xFC8BE767, 0x89F1, 0x4D6E, {0x80, 0x99, 0x6F, 0x02, 0x1E, 0xBC, 0x87, 0xCC}};
EFI_GUID mAmiNvRamMailboxVariableGuid = {0x54913A6D, 0xF4EE, 0x4CDB, {0x84, 0x75, 0x74, 0x06, 0x2B, 0xFC, 0xEC, 0xF5}};
EFI_GUID mAmiTableDataVarGuid = {0x4BAFC2B4, 0x02DC, 0x4104, {0xB2, 0x36, 0xD6, 0xF1, 0xB9, 0x8D, 0x9E, 0x84}};
EFI_GUID mAmiSecurityFormSetGuid = {0x981CEAEE, 0x931C, 0x4A17, {0xB9, 0xC8, 0x66, 0xC7, 0xBC, 0xFD, 0x77, 0xE1}};
EFI_GUID mAmiDriverHealthCountGuid = {0x7459A7D4, 0x6533, 0x4480, {0xBB, 0xA7, 0x79, 0xE2, 0x5A, 0x44, 0x43, 0xC9}};
EFI_GUID mAmiDriverHlthEnableGuid = {0x0885F288, 0x418C, 0x4bE1, {0xA6, 0xAF, 0x8B, 0xAD, 0x61, 0xDA, 0x08, 0xFE}};
EFI_GUID mAmiBootManagerGuid = {0xB4909CF3, 0x7B93, 0x4751, {0x9B, 0xD8, 0x5B, 0xA8, 0x22, 0x0B, 0x9B, 0xB2}};
EFI_GUID mAmiBootNowCountGuid = {0x052E6EB0, 0xF240, 0x42C5, {0x83, 0x09, 0x45, 0x87, 0x45, 0x45, 0xC6, 0xB4}};
EFI_GUID mAmiBootFlowVariableGuid = {0xEF152FB4, 0x7B2F, 0x427D, {0xBD, 0xB4, 0x7E, 0x0A, 0x05, 0x82, 0x6E, 0x64}};
EFI_GUID mAmiSystemAccessGuid = {0xE770BB69, 0xBCB4, 0x4D04, {0x9E, 0x97, 0x23, 0xFF, 0x94, 0x56, 0xFE, 0xAC}};
EFI_GUID mAmiFastBootVariableGuid = {0xB540A530, 0x6978, 0x4DA7, {0x91, 0xCB, 0x72, 0x07, 0xD7, 0x64, 0xD2, 0x62}};
EFI_GUID mAmiSmbiosDynamicDataGuid = {0xE380280C, 0x4C35, 0x4AA3, {0xB9, 0x61, 0x7A, 0xE4, 0x89, 0xA2, 0xB9, 0x26}};
EFI_GUID mMeSetupInfoGuid = {0x78259433, 0x7B6D, 0x4DB3, {0x9A, 0xE8, 0x36, 0xC4, 0xC2, 0xC3, 0xA1, 0x7D}};
EFI_GUID mMeBiosExtensionGuid = {0x1BAD711C, 0xD451, 0x4241, {0xB1, 0xF3, 0x85, 0x37, 0x81, 0x2E, 0x0C, 0x70}};
EFI_GUID mAmiKeycodeProtocolGuid = {0x0ADFB62D, 0xFF74, 0x484C, {0x89, 0x44, 0xF8, 0x5C, 0x4B, 0xEA, 0x87, 0xA8}};
EFI_GUID mCpuWakeUpBufferVariableGuid = {0xDF665292, 0x79D7, 0x40E2, {0xBA, 0x51, 0xF7, 0xD4, 0x94, 0x62, 0x81, 0x85}};
EFI_GUID mSmramCpuDataVariableGuid = {0x429501D9, 0xE447, 0x40F4, {0x86, 0x7B, 0x75, 0xC9, 0x3A, 0x1D, 0xB5, 0x4E}};
EFI_GUID mSioDevStatusVarGuid = {0x5820DE98, 0xFC8E, 0x4B0B, {0xA4, 0xB9, 0x0A, 0x94, 0x0D, 0x16, 0x2A, 0x7E}};
EFI_GUID mEfiIp6ServiceBindingProtocolGuid = {0xEC835DD3, 0xFE0F, 0x617B, {0xA6, 0x21, 0xB3, 0x50, 0xC3, 0xE1, 0x33, 0x88}};
EFI_GUID mEfiUdp6ServiceBindingProtocolGuid = {0x66ED4721, 0x3C98, 0x4D3E, {0x81, 0xE3, 0xD0, 0x3D, 0xD3, 0x9A, 0x72, 0x54}};
EFI_GUID mEfiTcp6ServiceBindingProtocolGuid = {0xEC20EB79, 0x6C1A, 0x4664, {0x9A, 0x0D, 0xD2, 0xE4, 0xCC, 0x16, 0xD6, 0x64}};
EFI_GUID mLegacyDeviceOrderGuid = {0xA56074DB, 0x65FE, 0x45F7, {0xBD, 0x21, 0x2D, 0x2B, 0xDD, 0x8E, 0x96, 0x52}};
EFI_GUID mEfiFirmwareVolume2ProtocolGuid = {0x220E73B6, 0x6BDB, 0x4413, {0x84, 0x05, 0xB9, 0x74, 0xB1, 0x08, 0x61, 0x9A}};
EFI_GUID mEfiIp4ConfigProtocolGuid = {0x3B95AA31, 0x3793, 0x434B, {0x86, 0x67, 0xC8, 0x07, 0x08, 0x92, 0xE0, 0x5E}};
EFI_GUID mEfiIp6ConfigProtocolGuid = {0x937FE521, 0x95AE, 0x4D1A, {0x89, 0x29, 0x48, 0xBC, 0xD9, 0x0A, 0xD3, 0x1A}};
EFI_GUID mEfiDhcp4ServiceBindingProtocolGuid = {0x9D9A39D8, 0xBD42, 0x4A73, {0xA4, 0xD5, 0x8E, 0xE9, 0x4B, 0xE1, 0x13, 0x80}};
EFI_GUID mEfiDhcp6ServiceBindingProtocolGuid = {0x9FB9A8A1, 0x2F4A, 0x43A6, {0x88, 0x9C, 0xD0, 0xF7, 0xB6, 0xC4, 0x7A, 0xD5}};
EFI_GUID mEfiIpSec2ProtocolGuid = {0xA3979E64, 0xACE8, 0x4DDC, {0xBC, 0x07, 0x4D, 0x66, 0xB8, 0xFD, 0x09, 0x77}};
EFI_GUID mEfiPerformanceProtocolGuid = {0xFFECFFFF, 0x923C, 0x14D2, {0x9E, 0x3F, 0x22, 0xA0, 0xC9, 0x69, 0x56, 0x3B}};
EFI_GUID mEfiPciRootBridgeIoProtocolGuid = {0x2F707EBB, 0x4A1A, 0x11D4, {0x9A, 0x38, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D}};
EFI_GUID mMtcVendorGuid = {0xEB704011, 0x1402, 0x11D3, {0x8E, 0x77, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B}};
EFI_GUID mEfiUsbIoProtocolGuid = {0x2B2F68D6, 0x0CD2, 0x44CF, {0x8E, 0x8B, 0xBB, 0xA2, 0x0B, 0x1B, 0x5B, 0x75}};
EFI_GUID mEfiUsb2HcProtocolGuid = {0x3E745226, 0x9818, 0x45B6, {0xA2, 0xAC, 0xD7, 0xCD, 0x0E, 0x8B, 0xA2, 0xBC}};
EFI_GUID mEfiUsbHcProtocolGuid = {0xF5089266, 0x1AA0, 0x4953, {0x97, 0xD8, 0x56, 0x2F, 0x8A, 0x73, 0xB5, 0x19}};
EFI_GUID mEfiIsaIoProtocolGuid = {0x7EE2BD44, 0x3DA0, 0x11D4, {0x9A, 0x38, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D}};
EFI_GUID mEfiUsbAtapiProtocolGuid = {0x2B2F68DA, 0x0CD2, 0x44CF, {0x8E, 0x8B, 0xBB, 0xA2, 0x0B, 0x1B, 0x5B, 0x75}};
EFI_GUID mEfiSimpleTextOutputProtocolGuid = {0x387477C2, 0x69C7, 0x11D2, {0x8E, 0x39, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B}};
EFI_GUID mEfiSimpleTextInputProtocolGuid = {0x387477C1, 0x69C7, 0x11D2, {0x8E, 0x39, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B}};
EFI_GUID mEfiSimpleTextInputExProtocolGuid = {0xDD9E7534, 0x7762, 0x4698, {0x8C, 0x14, 0xF5, 0x85, 0x17, 0xA6, 0x25, 0xAA}};
EFI_GUID mEfiConsoleInDeviceGuid = {0xD3B36F2B, 0xD551, 0x11D4, {0x9A, 0x46, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D}};
EFI_GUID mEfiConsoleOutDeviceGuid = {0xD3B36F2C, 0xD551, 0x11D4, {0x9A, 0x46, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D}};
EFI_GUID mEfiStandardErrorDeviceGuid = {0xD3B36F2D, 0xd551, 0x11D4, {0x9A, 0x46, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D}};
EFI_GUID mEfiArpServiceBindingProtocolGuid = {0xF44C00EE, 0x1F2C, 0x4A00, {0xAA, 0x09, 0x1C, 0x9F, 0x3E, 0x08, 0x00, 0xA3}};
EFI_GUID mEfiSerialIoProtocolGuid = {0xBB25CF6F, 0xF1D4, 0x11D2, {0x9A, 0x0C, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0xFD}};
EFI_GUID mEfiIsaAcpiProtocolGuid = {0x64A892DC, 0x5561, 0x4536, {0x92, 0xC7, 0x79, 0x9B, 0xFC, 0x18, 0x33, 0x55}};
EFI_GUID mEfiIdeControllerInitProtocolGuid = {0xA1E37052, 0x80D9, 0x4E65, {0xA3, 0x17, 0x3E, 0x9A, 0x55, 0xC4, 0x3E, 0xC9}};
EFI_GUID mEfiDriverBindingProtGuid = {0x18A031AB, 0xB443, 0x4D1A, {0xA5, 0xC0, 0x0C, 0x09, 0x26, 0x1E, 0x9F, 0x71}};
EFI_GUID mEfiPciPlatformProtocolGuid = {0x07D75280, 0x27D4, 0x4D69, {0x90, 0xD0, 0x56, 0x43, 0xE2, 0x38, 0xB3, 0x41}};
EFI_GUID mEfiUnicodeCollationProtocolGuid = {0x1D85CD7F, 0xF43D, 0x11D2, {0x9A, 0x0C, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D}};
EFI_GUID mEfiGenericMemTestProtocolGuid = {0x309DE7F1, 0x7F5E, 0x4ACE, {0xB4, 0x9C, 0x53, 0x1B, 0xE5, 0xAA, 0x95, 0xEF}};
EFI_GUID mEfiHashProtocolGuid = {0xc5184932, 0xdba5, 0x46db, {0xa5, 0xba, 0xcc, 0x0b, 0xda, 0x9c, 0x14, 0x35}};
EFI_GUID mEfiHashServiceBindingProtocolGuid = {0x42881c98, 0xa4f3, 0x44b0, {0xa3, 0x9d, 0xdf, 0xa1, 0x86, 0x67, 0xd8, 0xcd}};
EFI_GUID mEfiMtftp4ServiceBindingProtocolGuid = {0x2FE800BE, 0x8F01, 0x4AA6, {0x94, 0x6B, 0xD7, 0x13, 0x88, 0xE1, 0x83, 0x3F}};
EFI_GUID mEfiSimpleNetworkProtocolGuid = {0xA19832B9, 0xAC25, 0x11D3, {0x9A, 0x2D, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D}};
EFI_GUID mEfiManagedNetworkServiceBindingProtocolGuid = {0xF36FF770, 0xA7E1, 0x42CF, {0x9E, 0xD2, 0x56, 0xF0, 0xF2, 0x71, 0xF4, 0x4C}};
EFI_GUID mEfiNetworkInterfaceIdentifierProtocolGuid_31 = {0x1ACED566, 0x76ED, 0x4218, {0xBC, 0x81, 0x76, 0x7F, 0x1F, 0x97, 0x7A, 0x89}};
EFI_GUID mEfiNetworkInterfaceIdentifierProtocolGuid = {0xE18541CD, 0xF755, 0x4f73, {0x92, 0x8D, 0x64, 0x3C, 0x8A, 0x79, 0xB2, 0x29}};
EFI_GUID mEfiIncompatiblePciDeviceSupportProtocolGuid = {0xEB23F55A, 0x7863, 0x4AC2, {0x8D, 0x3D, 0x95, 0x65, 0x35, 0xDE, 0x03, 0x75}};
EFI_GUID mEfiHdaControllerInfoProtocolGuid = { 0xE5FC2CAF, 0x0291, 0x46F2, { 0x87, 0xF8, 0x10, 0xC7, 0x58, 0x72, 0x58, 0x04}};
EFI_GUID mEfiHdaIoProtocolGuid = { 0xA090D7F9, 0xB50A, 0x4EA1, { 0xBD, 0xE9, 0x1A, 0xA5, 0xE9, 0x81, 0x2F, 0x45}};
EFI_GUID mEfiHdaCodecInfoProtocolGuid = { 0x6C9CDDE1, 0xE8A5, 0x43E5, { 0xBE, 0x88, 0xDA, 0x15, 0xBC, 0x1C, 0x02, 0x50}};
EFI_GUID mEfiAudioIoProtocolGuid = { 0xF05B559C, 0x1971, 0x4AF5, { 0xB2, 0xAE, 0xD6, 0x08, 0x08, 0xF7, 0x4F, 0x70}};
// From MacOsxBootloader source:
EFI_GUID mAppleAcpiVariableGuid = {0xAF9FFD67, 0xEC10, 0x488A, {0x9D, 0xFC, 0x6C, 0xBF, 0x5E, 0xE2, 0x2C, 0x2E}};
EFI_GUID mAppleFileVaultVariableGuid = {0x8D63D4FE, 0xBD3C, 0x4AAD, {0x88, 0x1D, 0x86, 0xFD, 0x97, 0x4B, 0xC1, 0xDF}};
EFI_GUID mApplePasswordUIEfiFileNameGuid = {0x9EBA2D25, 0xBBE3, 0x4AC2, {0xA2, 0xC6, 0xC8, 0x7F, 0x44, 0xA1, 0x27, 0x8C}};
EFI_GUID mAppleRamDmgDevicePathGuid = {0x040B07E8, 0x0B9C, 0x427E, {0xB0, 0xD4, 0xA4, 0x66, 0xE6, 0xE5, 0x7A, 0x62}};
EFI_GUID mAppleSMCProtocolGuid = {0x17407E5A, 0xAF6C, 0x4EE8, {0x98, 0xA8, 0x00, 0x21, 0x04, 0x53, 0xCD, 0xD9}};
EFI_GUID mAppleFireWireProtocolGuid = {0x67708AA8, 0x2079, 0x4E4F, {0xB1, 0x58, 0xB1, 0x5B, 0x1F, 0x6A, 0x6C, 0x92}};
EFI_GUID mAppleDeviceControlProtocolGuid = {0x8ECE08D8, 0xA6D4, 0x430B, {0xA7, 0xB0, 0x2D, 0xF3, 0x18, 0xE7, 0x88, 0x4A}};
EFI_GUID mAppleDiskIoProtocolGuid = {0x5B27263B, 0x9083, 0x415E, {0x88, 0x9E, 0x64, 0x32, 0xCA, 0xA9, 0xB8, 0x13}};
EFI_GUID mEfiOSInfoProtocolGuid = {0xC5C5DA95, 0x7D5C, 0x45E6, {0xB2, 0xF1, 0x3F, 0xD5, 0x2B, 0xB1, 0x00, 0x77}};
EFI_GUID mAppleGraphConfigProtocolGuid = {0x03622D6D, 0x362A, 0x4E47, {0x97, 0x10, 0xC2, 0x38, 0xB2, 0x37, 0x55, 0xC1}};
EFI_GUID mAppleEventProtocolGuid = {0x33BE0EF1, 0x89C9, 0x4A6D, {0xBB, 0x9F, 0x69, 0xDC, 0x8D, 0xD5, 0x16, 0xB9}};
EFI_GUID mAppleSMCStateProtocolGuid = {0x5301FE59, 0x1770, 0x4166, {0xA1, 0x69, 0x00, 0xC4, 0xBD, 0xE4, 0xA1, 0x62}};
EFI_GUID mAppleKeyMapDatabaseProtocolGuid = {0x584B9EBE, 0x80C1, 0x4BD6, {0x98, 0xB0, 0xA7, 0x78, 0x6E, 0xC2, 0xF2, 0xE2}};
// Shell guids
EFI_GUID ShellInt = {0x47C7B223, 0xC42A, 0x11D2, {0x8E, 0x57, 0x0, 0xA0, 0xC9, 0x69, 0x72, 0x3B}};
EFI_GUID SEnv = {0x47C7B224, 0xC42A, 0x11D2, {0x8E, 0x57, 0x0, 0xA0, 0xC9, 0x69, 0x72, 0x3B}};
EFI_GUID ShellDevPathMap = {0x47C7B225, 0xC42A, 0x11D2, {0x8E, 0x57, 0x0, 0xA0, 0xC9, 0x69, 0x72, 0x3B}};
EFI_GUID ShellProtId = {0x47C7B226, 0xC42A, 0x11D2, {0x8E, 0x57, 0x0, 0xA0, 0xC9, 0x69, 0x72, 0x3B}};
EFI_GUID ShellAlias = {0x47C7B227, 0xC42A, 0x11D2, {0x8E, 0x57, 0x0, 0xA0, 0xC9, 0x69, 0x72, 0x3B}};
/** Map of known guids and friendly names. Searchable with GuidStr(). */
MAP_EFI_GUID_STR EfiGuidStrMap[] = {
{NULL, L"Tmp buffer AE074D26-6E9E-11E1-A5B8-9BFC4824019B"},
{&gEfiFileInfoGuid, L"gEfiFileInfoGuid"},
{&gEfiFileSystemInfoGuid, L"gEfiFileSystemInfoGuid"},
{&gEfiFileSystemVolumeLabelInfoIdGuid, L"gEfiFileSystemVolumeLabelInfoIdGuid"},
{&gEfiLoadedImageProtocolGuid, L"gEfiLoadedImageProtocolGuid"},
{&gEfiDevicePathProtocolGuid, L"gEfiDevicePathProtocolGuid"},
{&gEfiSimpleFileSystemProtocolGuid, L"gEfiSimpleFileSystemProtocolGuid"},
{&gEfiBlockIoProtocolGuid, L"gEfiBlockIoProtocolGuid"},
{&gEfiBlockIo2ProtocolGuid, L"gEfiBlockIo2ProtocolGuid"},
{&gEfiDiskIoProtocolGuid, L"gEfiDiskIoProtocolGuid"},
{&gEfiDiskIo2ProtocolGuid, L"gEfiDiskIo2ProtocolGuid"},
{&gEfiGraphicsOutputProtocolGuid, L"gEfiGraphicsOutputProtocolGuid"},
{&mEfiHdaControllerInfoProtocolGuid, L"gEfiHdaControllerInfoProtocolGuid"},
{&mEfiHdaIoProtocolGuid, L"gEfiHdaIoProtocolGuid"},
{&mEfiHdaCodecInfoProtocolGuid, L"gEfiHdaCodecInfoProtocolGuid"},
{&mEfiAudioIoProtocolGuid, L"gEfiAudioIoProtocolGuid"},
{&mEfiConsoleControlProtocolGuid, L"gEfiConsoleControlProtocolGuid"},
{&mAppleFirmwarePasswordProtocolGuid, L"gAppleFirmwarePasswordProtocolGuid"},
{&mEfiGlobalVariableGuid, L"gEfiGlobalVariableGuid"},
{&mAppleDevicePropertyProtocolGuid, L"gAppleDevicePropertyProtocolGuid"},
{&mEfiAppleBootGuid, L"gEfiAppleBootGuid"},
{&mEfiAppleNvramGuid, L"gEfiAppleNvramGuid"},
{&mAppleFramebufferInfoProtocolGuid, L"gAppleFramebufferInfoProtocolGuid"},
{&mAppleKeyStateProtocolGuid, L"gAppleKeyStateProtocolGuid"},
{&mAppleNetBootProtocolGuid, L"gAppleNetBootProtocolGuid"},
{&mAppleImageCodecProtocolGuid, L"gAppleImageCodecProtocolGuid"},
{&mAppleEfiVendorGuid, L"gAppleEfiVendorGuid"},
{&mAppleEFINVRAMTRBSecureGuid, L"gAppleEFINVRAMTRBSecureGuid"},
{&mDataHubOptionsGuid, L"gDataHubOptionsGuid"},
{&mRestartDataProtocolGiud, L"gRestartDataProtocolGiud"},
{&mAppleUserInterfaceThemeProtocolGuid, L"gAppleUserInterfaceThemeProtocolGuid"},
{&mApfsEfiBootRecordInfoProtocolGuid, L"gApfsEfiBootRecordInfoProtocolGuid"},
{&mApplePlatformInfoDatabaseProtocolGuid, L"gApplePlatformInfoDatabaseProtocolGuid"},
{&mAppleSMCStateProtocolGuid, L"gAppleSMCStateProtocolGuid"},
{&mAppleKeyMapDatabaseProtocolGuid, L"gAppleKeyMapDatabaseProtocolGuid"},
{&mNotifyMouseActivity, L"gNotifyMouseActivity"},
{&mEfiDataHubProtocolGuid, L"gEfiDataHubProtocolGuid"},
{&mEfiMiscSubClassGuid, L"gEfiMiscSubClassGuid"},
{&mEfiProcessorSubClassGuid, L"gEfiProcessorSubClassGuid"},
{&mEfiMemorySubClassGuid, L"gEfiMemorySubClassGuid"},
{&mEfiCacheSubClassGuid, L"gEfiCacheSubClassGuid"},
{&mMsgLogProtocolGuid, L"gMsgLogProtocolGuid"},
{&mEfiLegacy8259ProtocolGuid, L"gEfiLegacy8259ProtocolGuid"},
{&mEfiDataHubStatusCodeRecordGuid, L"gEfiDataHubStatusCodeRecordGuid"},
{&mEfiStatusCodeRuntimeProtocolGuid, L"gEfiStatusCodeRuntimeProtocolGuid"},
{&mEfiStatusCodeGuid, L"gEfiStatusCodeGuid"},
{&gEfiAcpi10TableGuid, L"gEfiAcpi10TableGuid"},
{&gEfiAcpi20TableGuid, L"gEfiAcpi20TableGuid"},
{&gEfiDebugImageInfoTableGuid, L"gEfiDebugImageInfoTableGuid"},
{&gEfiDxeServicesTableGuid, L"gEfiDxeServicesTableGuid"},
{&gEfiHobListGuid, L"gEfiHobListGuid"},
{&gEfiMpsTableGuid, L"gEfiMpsTableGuid"},
{&gEfiSmbiosTableGuid, L"gEfiSmbiosTableGuid"},
{&gEfiSmbios3TableGuid, L"gEfiSmbios3TableGuid"},
{&mEfiMemoryTypeInformationGuid, L"gEfiMemoryTypeInformationGuid"},
{&mEfiSimplePointerProtocolGuid, L"gEfiSimplePointerProtocolGuid"},
{&mEfiTimeVariableGuid, L"gEfiTimeVariableGuid"},
{&mEfiLegacyRegionProtocolGuid, L"gEfiLegacyRegionProtocolGuid"},
{&mEfiCpuArchProtocolGuid, L"gEfiCpuArchProtocolGuid"},
{&mEfiMpServiceProtocolGuid, L"gEfiMpServiceProtocolGuid"},
{&mEfiApplePlatformInfoGuid, L"gEfiApplePlatformInfoGuid"},
{&mEfiOzmosisNvramGuid, L"gEfiOzmosisNvramGuid"},
{&mEfiWdtPersistentDataGuid, L"gEfiWdtPersistentDataGuid"},
{&mAmiDefaultsVariableGuid, L"gAmiDefaultsVariableGuid"},
{&mEfiRomImageAddressGuid, L"gEfiRomImageAddressGuid"},
{&mAmiSetupGuid, L"gAmiSetupGuid"},
{&mEfiPciIoProtocolGuid, L"gEfiPciIoProtocolGuid"},
{&mEfiFirmwareVolumeProtocolGuid, L"gEfiFirmwareVolumeProtocolGuid"},
{&mEfiTcp4ServiceBindingProtocolGuid, L"gEfiTcp4ServiceBindingProtocolGuid"},
{&mEfiIp4ServiceBindingProtocolGuid, L"gEfiIp4ServiceBindingProtocolGuid"},
{&mEfiUdp4ServiceBindingProtocolGuid, L"gEfiUdp4ServiceBindingProtocolGuid"},
{&mPchInitVariableGuid, L"gPchInitVariableGuid"},
{&mEfiMemoryRestoreDataGuid, L"gEfiMemoryRestoreDataGuid"},
{&mEfiSbAslBufferPtrGuid, L"gEfiSbAslBufferPtrGuid"},
{&mSaPegDataVariableGuid, L"gSaPegDataVariableGuid"},
{&mAmiNvramSpdMapGuid, L"gAmiNvramSpdMapGuid"},
{&mShellVariableGuid, L"gShellVariableGuid"},
{&mTerminalVarGuid, L"gTerminalVarGuid"},
{&mAmiTseSetupGuid, L"gAmiTseSetupGuid"},
{&mAmiNetworkStackGuid, L"gAmiNetworkStackGuid"},
{&mAmiRecoveryFormSetGuid, L"gAmiRecoveryFormSetGuid"},
{&mAmiIsaDmaIrqMaskVarGuid, L"gAmiIsaDmaIrqMaskVarGuid"},
{&mAmiNvRamMailboxVariableGuid, L"gAmiNvRamMailboxVariableGuid"},
{&mAmiTableDataVarGuid, L"gAmiTableDataVarGuid"},
{&mCpuWakeUpBufferVariableGuid, L"gCpuWakeUpBufferVariableGuid"},
{&mMeSetupInfoGuid, L"gMeSetupInfoGuid"},
{&mMeBiosExtensionGuid, L"gMeBiosExtensionGuid"},
{&mAmiSecurityFormSetGuid, L"gAmiSecurityFormSetGuid"},
{&mAmiDriverHealthCountGuid, L"gAmiDriverHealthCountGuid"},
{&mAmiDriverHlthEnableGuid, L"gAmiDriverHlthEnableGuid"},
{&mSioDevStatusVarGuid, L"gSioDevStatusVarGuid"},
{&mEfiIp6ServiceBindingProtocolGuid, L"gEfiIp6ServiceBindingProtocolGuid"},
{&mEfiUdp6ServiceBindingProtocolGuid, L"gEfiUdp6ServiceBindingProtocolGuid"},
{&mEfiTcp6ServiceBindingProtocolGuid, L"gEfiTcp6ServiceBindingProtocolGuid"},
{&mSmramCpuDataVariableGuid, L"gSmramCpuDataVariableGuid"},
{&mLegacyDeviceOrderGuid, L"gLegacyDeviceOrderGuid"},
{&mAmiBootManagerGuid, L"gAmiBootManagerGuid"},
{&mAmiBootNowCountGuid, L"gAmiBootNowCountGuid"},
{&mAmiBootFlowVariableGuid, L"gAmiBootFlowVariableGuid"},
{&mAmiSystemAccessGuid, L"gAmiSystemAccessGuid"},
{&mAmiFastBootVariableGuid, L"gAmiFastBootVariableGuid"},
{&mAmiSmbiosDynamicDataGuid, L"gAmiSmbiosDynamicDataGuid"},
{&mAmiKeycodeProtocolGuid, L"gAmiKeycodeProtocolGuid"},
{&mEfiFirmwareVolume2ProtocolGuid, L"gEfiFirmwareVolume2ProtocolGuid"},
{&mEfiIp4ConfigProtocolGuid, L"gEfiIp4ConfigProtocolGuid"},
{&mEfiIp6ConfigProtocolGuid, L"gEfiIp6ConfigProtocolGuid"},
{&mEfiDhcp4ServiceBindingProtocolGuid, L"gEfiDhcp4ServiceBindingProtocolGuid"},
{&mEfiDhcp6ServiceBindingProtocolGuid, L"gEfiDhcp6ServiceBindingProtocolGuid"},
{&mEfiIpSec2ProtocolGuid, L"gEfiIpSec2ProtocolGuid"},
{&mEfiPerformanceProtocolGuid, L"gEfiPerformanceProtocolGuid"},
{&mEfiPciRootBridgeIoProtocolGuid, L"gEfiPciRootBridgeIoProtocolGuid"},
{&mMtcVendorGuid, L"gMtcVendorGuid"},
{&mEfiUsbIoProtocolGuid, L"gEfiUsbIoProtocolGuid"},
{&mEfiUsb2HcProtocolGuid, L"gEfiUsb2HcProtocolGuid"},
{&mEfiUsbHcProtocolGuid, L"gEfiUsbHcProtocolGuid"},
{&mEfiIsaIoProtocolGuid, L"gEfiIsaIoProtocolGuid"},
{&mEfiUsbAtapiProtocolGuid, L"gEfiUsbAtapiProtocolGuid"},
{&mEfiSimpleTextOutputProtocolGuid, L"gEfiSimpleTextOutProtocolGuid"},
{&mEfiSimpleTextInputProtocolGuid, L"gEfiSimpleTextInProtocolGuid"},
{&mEfiSimpleTextInputExProtocolGuid, L"gEfiSimpleTextInExProtocolGuid"},
{&mEfiConsoleInDeviceGuid, L"gEfiConsoleInDeviceGuid"},
{&mEfiConsoleOutDeviceGuid, L"gEfiConsoleOutDeviceGuid"},
{&mEfiStandardErrorDeviceGuid, L"gEfiStandardErrorDeviceGuid"},
{&mEfiManagedNetworkServiceBindingProtocolGuid, L"gEfiManagedNetworkServiceBindingProtocolGuid"},
{&mEfiSimpleNetworkProtocolGuid, L"gEfiSimpleNetworkProtocolGuid"},
{&mEfiArpServiceBindingProtocolGuid, L"gEfiArpServiceBindingProtocolGuid"},
{&mEfiNetworkInterfaceIdentifierProtocolGuid_31, L"gEfiNetworkInterfaceIdentifierProtocolGuid_31"},
{&mEfiNetworkInterfaceIdentifierProtocolGuid, L"gEfiNetworkInterfaceIdentifierProtocolGuid"},
{&mEfiSerialIoProtocolGuid, L"gEfiSerialIoProtocolGuid"},
{&mEfiIsaAcpiProtocolGuid, L"gEfiIsaAcpiProtocolGuid"},
{&mEfiIdeControllerInitProtocolGuid, L"gEfiIdeControllerInitProtocolGuid"},
{&mEfiDriverBindingProtGuid, L"gEfiDriverBindingProtocolGuid"},
{&mEfiIncompatiblePciDeviceSupportProtocolGuid, L"gEfiIncompatiblePciDeviceSupportProtocolGuid"},
{&mEfiPciPlatformProtocolGuid, L"gEfiPciPlatformProtocolGuid"},
{&mEfiMtftp4ServiceBindingProtocolGuid, L"gEfiMtftp4ServiceBindingProtocolGuid"},
{&mEfiUnicodeCollationProtocolGuid, L"gEfiUnicodeCollationProtocolGuid"},
{&mEfiGenericMemTestProtocolGuid, L"gEfiGenericMemTestProtocolGuid"},
{&mEfiHashProtocolGuid, L"gEfiHashProtocolGuid"},
{&mEfiHashServiceBindingProtocolGuid, L"gEfiHashServiceBindingProtocolGuid"},
{&mAppleAcpiVariableGuid, L"gAppleAcpiVariableGuid"},
{&mAppleFileVaultVariableGuid, L"gAppleFileVaultVariableGuid"},
{&mApplePasswordUIEfiFileNameGuid, L"gApplePasswordUIEfiFileNameGuid"},
{&mAppleRamDmgDevicePathGuid, L"gAppleRamDmgDevicePathGuid"},
{&mAppleSMCProtocolGuid, L"gAppleSMCProtocolGuid"},
{&mAppleFireWireProtocolGuid, L"gAppleFireWireProtocolGuid"},
{&mAppleDeviceControlProtocolGuid, L"gAppleDeviceControlProtocolGuid"},
{&mAppleDiskIoProtocolGuid, L"gAppleDiskIoProtocolGuid"},
{&mEfiOSInfoProtocolGuid, L"gEfiOSInfoProtocolGuid"},
{&mAppleGraphConfigProtocolGuid, L"gAppleGraphConfigProtocolGuid"},
{&mAppleEventProtocolGuid, L"gAppleEventProtocolGuid"},
{&ShellInt, L"ShellInt"},
{&SEnv, L"SEnv"},
{&ShellDevPathMap, L"ShellDevPathMap"},
{&ShellProtId, L"ShellProtId"},
{&ShellAlias, L"ShellAlias"},
{NULL, NULL}
};
/** Print buffer for unknown GUID printing. Allocated as RT mem
* and gets converted in RuntimeServices.c VirtualAddressChangeEvent().
*/
CHAR16 *GuidPrintBuffer = NULL;
#define GUID_PRINT_BUFFER_SIZE ((36+1) * sizeof(CHAR16))
//CHAR16 GuidPrintBuffer[40];
/** Buffer for RT variable names. Allocated as RT mem
* and gets converted in RuntimeServices.c VirtualAddressChangeEvent().
*/
CHAR16 *gVariableNameBuffer = NULL;
#define VARIABLE_NAME_BUFFER_SIZE 1024
/** Buffer for RT variable data. Allocated as RT mem
* and gets converted in RuntimeServices.c VirtualAddressChangeEvent().
*/
CHAR8 *gVariableDataBuffer = NULL;
#define VARIABLE_DATA_BUFFER_SIZE (64 * 1024)
/** Returns GUID as string, with friendly name for known guids. */
CHAR16*
EFIAPI
GuidStr(IN EFI_GUID *Guid)
{
UINTN i;
CHAR16 *Str = NULL;
if (GuidPrintBuffer == NULL) {
GuidPrintBuffer = AllocateRuntimePool(GUID_PRINT_BUFFER_SIZE);
}
for(i = 1; EfiGuidStrMap[i].Guid != NULL; i++) {
if (CompareGuid(EfiGuidStrMap[i].Guid, Guid)) {
Str = EfiGuidStrMap[i].Str;
break;
}
}
if (Str == NULL) {
UnicodeSPrint(GuidPrintBuffer, GUID_PRINT_BUFFER_SIZE, L"%g", Guid);
Str = GuidPrintBuffer;
}
return Str;
}
/** Prints Number of bytes in a row (hex and ascii). Row size is MaxNumber. */
VOID
EFIAPI
PrintBytesRow(IN CHAR8 *Bytes, IN UINTN Number, IN UINTN MaxNumber)
{
UINTN Index;
// print hex vals
for (Index = 0; Index < Number; Index++) {
PRINT("%02x ", (UINT8)Bytes[Index]);
}
// pad to MaxNumber if needed
for (; Index < MaxNumber; Index++) {
PRINT(" ");
}
PRINT("| ");
// print ASCII
for (Index = 0; Index < Number; Index++) {
if (Bytes[Index] >= 0x20 && Bytes[Index] <= 0x7e) {
PRINT("%c", (CHAR16)Bytes[Index]);
} else {
PRINT("%c", L'.');
}
}
PRINT("\n");
}
/** Prints series of bytes. */
VOID
EFIAPI
PrintBytes(IN CHAR8 *Bytes, IN UINTN Number)
{
UINTN Index;
for (Index = 0; Index < Number; Index += 16) {
PrintBytesRow(Bytes + Index, (Index + 16 < Number ? 16 : Number - Index), 16);
}
}
/** Returns pointer to last Char in String or NULL. */
CHAR16*
EFIAPI
GetStrLastChar(IN CHAR16 *String)
{
CHAR16 *Pos;
if (String == NULL || *String == L'\0') {
return NULL;
}
// go to end
Pos = String;
while (*Pos != L'\0') {
Pos++;
}
Pos--;
return Pos;
}
/** Returns pointer to last occurence of Char in String or NULL. */
CHAR16*
EFIAPI
GetStrLastCharOccurence(IN CHAR16 *String, IN CHAR16 Char)
{
CHAR16 *Pos;
if (String == NULL || *String == L'\0') {
return NULL;
}
// go to end
Pos = String;
while (*Pos != L'\0') {
Pos++;
}
// search for Char
while (*Pos != Char && Pos != String) {
Pos--;
}
return (*Pos == Char) ? Pos : NULL;
}
/** Returns upper case version of char - valid only for ASCII chars in unicode. */
CHAR16
EFIAPI
ToUpperChar(IN CHAR16 Chr)
{
CHAR8 C;
if (Chr > 0xFF) return Chr;
C = (CHAR8)Chr;
return ((C >= 'a' && C <= 'z') ? C - ('a' - 'A') : C);
}
/** Returns 0 if two strings are equal, !=0 otherwise. Compares just first 8 bits of chars (valid for ASCII), case insensitive.. */
UINTN
EFIAPI
StrCmpiBasic(IN CHAR16 *String1, IN CHAR16 *String2)
{
CHAR16 Chr1;
CHAR16 Chr2;
if (String1 == NULL || String2 == NULL) {
return 1;
}
if (*String1 == L'\0' && *String2 == L'\0') {
return 0;
}
if (*String1 == L'\0' || *String2 == L'\0') {
return 1;
}
Chr1 = ToUpperChar(*String1);
Chr2 = ToUpperChar(*String2);
while ((*String1 != L'\0') && (Chr1 == Chr2)) {
String1++;
String2++;
Chr1 = ToUpperChar(*String1);
Chr2 = ToUpperChar(*String2);
}
return Chr1 - Chr2;
}
/** Returns the first occurrence of a Null-terminated Unicode SearchString
* in a Null-terminated Unicode String.
* Compares just first 8 bits of chars (valid for ASCII), case insensitive.
* Copied from MdePkg/Library/BaseLib/String.c and modified
*/
CHAR16*
EFIAPI
StrStriBasic(
IN CONST CHAR16 *String,
IN CONST CHAR16 *SearchString
)
{
CONST CHAR16 *FirstMatch;
CONST CHAR16 *SearchStringTmp;
if (*SearchString == L'\0') {
return (CHAR16 *) String;
}
while (*String != L'\0') {
SearchStringTmp = SearchString;
FirstMatch = String;
while ((ToUpperChar(*String) == ToUpperChar(*SearchStringTmp))
&& (*String != L'\0'))
{
String++;
SearchStringTmp++;
}
if (*SearchStringTmp == L'\0') {
return (CHAR16 *) FirstMatch;
}
if (*String == L'\0') {
return NULL;
}
String = FirstMatch + 1;
}
return NULL;
}
/** Returns TRUE if String1 starts with String2, FALSE otherwise. Compares just first 8 bits of chars (valid for ASCII), case insensitive.. */
BOOLEAN
EFIAPI
StriStartsWithBasic(IN CHAR16 *String1, IN CHAR16 *String2)
{
CHAR16 Chr1;
CHAR16 Chr2;
BOOLEAN Result;
if (String1 == NULL || String2 == NULL) {
return FALSE;
}
if (*String1 == L'\0' && *String2 == L'\0') {
return TRUE;
}
if (*String1 == L'\0' || *String2 == L'\0') {
return FALSE;
}
Chr1 = ToUpperChar(*String1);
Chr2 = ToUpperChar(*String2);
while ((Chr1 != L'\0') && (Chr2 != L'\0') && (Chr1 == Chr2)) {
String1++;
String2++;
Chr1 = ToUpperChar(*String1);
Chr2 = ToUpperChar(*String2);
}
Result = ((Chr1 == L'\0') && (Chr2 == L'\0'))
|| ((Chr1 != L'\0') && (Chr2 == L'\0'));
return Result;
}
VOID EFIAPI
ShrinkMemMap(
IN UINTN *MemoryMapSize,
IN EFI_MEMORY_DESCRIPTOR *MemoryMap,
IN UINTN DescriptorSize,
IN UINT32 DescriptorVersion
)
{
UINTN SizeFromDescToEnd;
UINT64 Bytes;
EFI_MEMORY_DESCRIPTOR *PrevDesc;
EFI_MEMORY_DESCRIPTOR *Desc;
BOOLEAN CanBeJoined;
BOOLEAN HasEntriesToRemove;
PrevDesc = MemoryMap;
Desc = NEXT_MEMORY_DESCRIPTOR(PrevDesc, DescriptorSize);
SizeFromDescToEnd = *MemoryMapSize - DescriptorSize;
*MemoryMapSize = DescriptorSize;
HasEntriesToRemove = FALSE;
while (SizeFromDescToEnd > 0) {
Bytes = (((UINTN) PrevDesc->NumberOfPages) * EFI_PAGE_SIZE);
CanBeJoined = FALSE;
if ((Desc->Attribute == PrevDesc->Attribute) && (PrevDesc->PhysicalStart + Bytes == Desc->PhysicalStart)) {
if (Desc->Type == EfiBootServicesCode
|| Desc->Type == EfiBootServicesData
//|| Desc->Type == EfiConventionalMemory
//|| Desc->Type == EfiLoaderCode
//|| Desc->Type == EfiLoaderData
)
{
CanBeJoined = PrevDesc->Type == EfiBootServicesCode
|| PrevDesc->Type == EfiBootServicesData
//|| PrevDesc->Type == EfiConventionalMemory
//|| PrevDesc->Type == EfiLoaderCode
//|| PrevDesc->Type == EfiLoaderData
;
}
}
if (CanBeJoined) {
// two entries are the same/similar - join them
PrevDesc->NumberOfPages += Desc->NumberOfPages;
HasEntriesToRemove = TRUE;
} else {
// can not be joined - we need to move to next
*MemoryMapSize += DescriptorSize;
PrevDesc = NEXT_MEMORY_DESCRIPTOR(PrevDesc, DescriptorSize);
if (HasEntriesToRemove) {
// have entries between PrevDesc and Desc which are joined to PrevDesc
// we need to copy [Desc, end of list] to PrevDesc + 1
CopyMem(PrevDesc, Desc, SizeFromDescToEnd);
Desc = PrevDesc;
}
HasEntriesToRemove = FALSE;
}
// move to next
Desc = NEXT_MEMORY_DESCRIPTOR(Desc, DescriptorSize);
SizeFromDescToEnd -= DescriptorSize;
}
}
VOID EFIAPI
PrintMemMap(
IN UINTN MemoryMapSize,
IN EFI_MEMORY_DESCRIPTOR *MemoryMap,
IN UINTN DescriptorSize,
IN UINT32 DescriptorVersion
)
{
UINTN NumEntries;
UINTN Index;
UINT64 Bytes;
EFI_MEMORY_DESCRIPTOR *Desc;
Desc = MemoryMap;
NumEntries = MemoryMapSize / DescriptorSize;
PRINT("MEMMAP: Size=%d, Addr=%p, DescSize=%d, DescVersion: 0x%x\n", MemoryMapSize, MemoryMap, DescriptorSize, DescriptorVersion);
PRINT("Type Start End VStart # Pages Attributes\n");
for (Index = 0; Index < NumEntries; Index++) {
Bytes = (((UINTN) Desc->NumberOfPages) * EFI_PAGE_SIZE);
PRINT("%-12s %lX-%lX %lX %lX %lX\n",
EfiMemoryTypeDesc[Desc->Type],
Desc->PhysicalStart,
Desc->PhysicalStart + Bytes - 1,
Desc->VirtualStart,
Desc->NumberOfPages,
Desc->Attribute
);
Desc = NEXT_MEMORY_DESCRIPTOR(Desc, DescriptorSize);
//if ((Index + 1) % 16 == 0) {
// WaitForKeyPress(L"press a key to continue\n");
//}
}
//WaitForKeyPress(L"End: press a key to continue\n");
}
VOID EFIAPI
PrintSystemTable(IN EFI_SYSTEM_TABLE *ST)
{
UINTN Index;
PRINT("SysTable: %p\n", ST);
PRINT("- FirmwareVendor: %p, %s\n", ST->FirmwareVendor, ST->FirmwareVendor);
PRINT("- FirmwareRevision: %x\n", ST->FirmwareRevision);
PRINT("- ConsoleInHandle: %p, ConIn: %p\n", ST->ConsoleInHandle, ST->ConIn);
PRINT("- ConsoleOutHandle: %p, ConOut: %p\n", ST->ConsoleOutHandle, ST->ConOut);
PRINT("- StandardErrorHandle: %p, StdErr: %p\n", ST->StandardErrorHandle, ST->StdErr);
PRINT("- RuntimeServices: %p, BootServices: %p\n", ST->RuntimeServices, ST->BootServices);
PRINT("- ConfigurationTable: %p\n", ST->ConfigurationTable);
for(Index = 0; Index < ST->NumberOfTableEntries; Index++) {
PRINT(" %p - %s\n", ST->ConfigurationTable[Index].VendorTable, GuidStr(&ST->ConfigurationTable[Index].VendorGuid));
}
// print RT services table
PRINT("- RuntimeServices: %p\n", ST->RuntimeServices);
PRINT(" GetTime: %p\n", ST->RuntimeServices->GetTime);
PRINT(" SetTime: %p\n", ST->RuntimeServices->SetTime);
PRINT(" GetWakeupTime: %p\n", ST->RuntimeServices->GetWakeupTime);
PRINT(" SetWakeupTime: %p\n", ST->RuntimeServices->SetWakeupTime);
PRINT(" SetVirtualAddressMap: %p\n", ST->RuntimeServices->SetVirtualAddressMap);
PRINT(" ConvertPointer: %p\n", ST->RuntimeServices->ConvertPointer);
PRINT(" GetVariable: %p\n", ST->RuntimeServices->GetVariable);
PRINT(" GetNextVariableName: %p\n", ST->RuntimeServices->GetNextVariableName);
PRINT(" SetVariable: %p\n", ST->RuntimeServices->SetVariable);
PRINT(" GetNextHighMonotonicCount: %p\n", ST->RuntimeServices->GetNextHighMonotonicCount);
PRINT(" ResetSystem: %p\n", ST->RuntimeServices->ResetSystem);
PRINT(" UpdateCapsule: %p\n", ST->RuntimeServices->UpdateCapsule);
PRINT(" QueryCapsuleCapabilities: %p\n", ST->RuntimeServices->QueryCapsuleCapabilities);
PRINT(" QueryVariableInfo: %p\n", ST->RuntimeServices->QueryVariableInfo);
PRINT("- RuntimeServices Oiginals:\n");
PRINT(" GetTime: %p\n", gOrgRS.GetTime);
PRINT(" SetTime: %p\n", gOrgRS.SetTime);
PRINT(" GetWakeupTime: %p\n", gOrgRS.GetWakeupTime);
PRINT(" SetWakeupTime: %p\n", gOrgRS.SetWakeupTime);
PRINT(" SetVirtualAddressMap: %p\n", gOrgRS.SetVirtualAddressMap);
PRINT(" ConvertPointer: %p\n", gOrgRS.ConvertPointer);
PRINT(" GetVariable: %p\n", gOrgRS.GetVariable);
PRINT(" GetNextVariableName: %p\n", gOrgRS.GetNextVariableName);
PRINT(" SetVariable: %p\n", gOrgRS.SetVariable);
PRINT(" GetNextHighMonotonicCount: %p\n", gOrgRS.GetNextHighMonotonicCount);
PRINT(" ResetSystem: %p\n", gOrgRS.ResetSystem);
PRINT(" UpdateCapsule: %p\n", gOrgRS.UpdateCapsule);
PRINT(" QueryCapsuleCapabilities: %p\n", gOrgRS.QueryCapsuleCapabilities);
PRINT(" QueryVariableInfo: %p\n", gOrgRS.QueryVariableInfo);
}
VOID
WaitForKeyPress(CHAR16 *Message)
{
EFI_STATUS Status;
UINTN index;
EFI_INPUT_KEY key;
Print(Message);
do {
Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &key);
} while(Status == EFI_SUCCESS);
gBS->WaitForEvent(1, &gST->ConIn->WaitForKey, &index);
do {
Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &key);
} while(Status == EFI_SUCCESS);
}
/** Returns file path from FilePathProto in allocated memory. Mem should be released by caler.*/
CHAR16 *
EFIAPI
FileDevicePathToText(EFI_DEVICE_PATH_PROTOCOL *FilePathProto)
{
EFI_STATUS Status;
FILEPATH_DEVICE_PATH *FilePath;
CHAR16 FilePathText[256]; // possible problem: if filepath is bigger
CHAR16 *OutFilePathText;
INTN Size;
INTN SizeAll;
INTN i;
FilePathText[0] = L'\0';
i = 4;
SizeAll = 0;
//PRINT("FilePathProto->Type: %d, SubType: %d, Length: %d\n", FilePathProto->Type, FilePathProto->SubType, DevicePathNodeLength(FilePathProto));
while (FilePathProto != NULL && FilePathProto->Type != END_DEVICE_PATH_TYPE && i > 0) {
if (FilePathProto->Type == MEDIA_DEVICE_PATH && FilePathProto->SubType == MEDIA_FILEPATH_DP) {
FilePath = (FILEPATH_DEVICE_PATH *) FilePathProto;
Size = (DevicePathNodeLength(FilePathProto) - 4) / 2;
if (SizeAll + Size < 256) {
if (SizeAll > 0 && FilePathText[SizeAll / 2 - 2] != L'\\') {
StrCatS(FilePathText, 256, L"\\");
}
StrCatS(FilePathText, 256, FilePath->PathName);
SizeAll = StrSize(FilePathText);
}
}
FilePathProto = NextDevicePathNode(FilePathProto);
//PRINT("FilePathProto->Type: %d, SubType: %d, Length: %d\n", FilePathProto->Type, FilePathProto->SubType, DevicePathNodeLength(FilePathProto));
i--;
//PRINT("FilePathText: %s\n", FilePathText);
}
OutFilePathText = NULL;
Size = StrSize(FilePathText);
if (Size > 2) {
// we are allocating mem here - should be released by caller
Status = gBS->AllocatePool(EfiBootServicesData, Size, (VOID*)&OutFilePathText);
if (Status == EFI_SUCCESS) {
StrCpyS(OutFilePathText, Size/sizeof(CHAR16), FilePathText);
} else {
OutFilePathText = NULL;
}
}
return OutFilePathText;
}
/** Helper function that calls GetMemoryMap(), allocates space for mem map and returns it. */
EFI_STATUS
EFIAPI
GetMemoryMapAlloc (
IN EFI_GET_MEMORY_MAP GetMemoryMapFunction,
OUT UINTN *MemoryMapSize,
OUT EFI_MEMORY_DESCRIPTOR **MemoryMap,
OUT UINTN *MapKey,
OUT UINTN *DescriptorSize,
OUT UINT32 *DescriptorVersion
)
{
EFI_STATUS Status;
*MemoryMapSize = 0;
*MemoryMap = NULL;
Status = GetMemoryMapFunction(MemoryMapSize, *MemoryMap, MapKey, DescriptorSize, DescriptorVersion);
if (Status == EFI_BUFFER_TOO_SMALL) {
// OK. Space needed for mem map is in MemoryMapSize
// Important: next AllocatePool can increase mem map size - we must add some space for this
*MemoryMapSize += 256;
*MemoryMap = AllocatePool(*MemoryMapSize);
Status = GetMemoryMapFunction(MemoryMapSize, *MemoryMap, MapKey, DescriptorSize, DescriptorVersion);
if (EFI_ERROR(Status)) {
FreePool(*MemoryMap);
}
}
return Status;
}
/** Alloctes Pages from the top of mem, up to address specified in Memory. Returns allocated address in Memory. */
EFI_STATUS
EFIAPI
AllocatePagesFromTop(
IN EFI_MEMORY_TYPE MemoryType,
IN UINTN Pages,
IN OUT EFI_PHYSICAL_ADDRESS *Memory
)
{
EFI_STATUS Status;
UINTN MemoryMapSize;
EFI_MEMORY_DESCRIPTOR *MemoryMap;
UINTN MapKey;
UINTN DescriptorSize;
UINT32 DescriptorVersion;
EFI_MEMORY_DESCRIPTOR *MemoryMapEnd;
EFI_MEMORY_DESCRIPTOR *Desc;
Status = GetMemoryMapAlloc(gBS->GetMemoryMap, &MemoryMapSize, &MemoryMap, &MapKey, &DescriptorSize, &DescriptorVersion);
if (EFI_ERROR(Status)) {
return Status;
}
Status = EFI_NOT_FOUND;
//PRINT("Search for Pages=%x, TopAddr=%lx\n", Pages, *Memory);
//PRINT("MEMMAP: Size=%d, Addr=%p, DescSize=%d, DescVersion: 0x%x\n", MemoryMapSize, MemoryMap, DescriptorSize, DescriptorVersion);
//PRINT("Type Start End VStart # Pages Attributes\n");
MemoryMapEnd = NEXT_MEMORY_DESCRIPTOR(MemoryMap, MemoryMapSize);
Desc = PREV_MEMORY_DESCRIPTOR(MemoryMapEnd, DescriptorSize);
for ( ; Desc >= MemoryMap; Desc = PREV_MEMORY_DESCRIPTOR(Desc, DescriptorSize)) {
/*
PRINT("%-12s %lX-%lX %lX %lX %lX\n",
EfiMemoryTypeDesc[Desc->Type],
Desc->PhysicalStart,
Desc->PhysicalStart + EFI_PAGES_TO_SIZE(Desc->NumberOfPages) - 1,
Desc->VirtualStart,
Desc->NumberOfPages,
Desc->Attribute
);
*/
if ( (Desc->Type == EfiConventionalMemory) // free mem
&& (Pages <= Desc->NumberOfPages) // contains enough space
&& (Desc->PhysicalStart + EFI_PAGES_TO_SIZE(Pages) <= *Memory) // contains space below specified Memory
)
{
// free block found
if (Desc->PhysicalStart + EFI_PAGES_TO_SIZE((UINTN)Desc->NumberOfPages) <= *Memory) {
// the whole block is unded Memory - allocate from the top of the block
*Memory = Desc->PhysicalStart + EFI_PAGES_TO_SIZE((UINTN)Desc->NumberOfPages - Pages);
//PRINT("found the whole block under top mem, allocating at %lx\n", *Memory);
} else {
// the block contains enough pages under Memory, but spans above it - allocate below Memory.
*Memory = *Memory - EFI_PAGES_TO_SIZE(Pages);
//PRINT("found the whole block under top mem, allocating at %lx\n", *Memory);
}
Status = gBS->AllocatePages(AllocateAddress,
MemoryType,
Pages,
Memory);
//PRINT("Alloc Pages=%x, Addr=%lx, Status=%r\n", Pages, *Memory, Status);
break;
}
}
// release mem
FreePool(MemoryMap);
return Status;
}
/** Prints RT vars. */
VOID
EFIAPI
PrintRTVariables(
IN EFI_RUNTIME_SERVICES *RT
)
{
EFI_STATUS Status;
UINT32 Attributes;
//UINT64 MaximumVariableStorageSize;
//UINT64 RemainingVariableStorageSize;
//UINT64 MaximumVariableSize;
UINTN VariableNameSize;
UINTN VariableNameBufferSize;
UINTN VariableDataSize;
EFI_GUID VendorGuid;
BOOLEAN IsDataPrintDisabled;
//
// Print storage info
//
/*
PRINT("Vars storage:\n");
PRINT(" Attrib: MaximumVariableStorageSize, RemainingVariableStorageSize, MaximumVariableSize\n");
// NV+BS
PRINT(" NV+BS : ");
Attributes = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS;
Status = RT->QueryVariableInfo(Attributes, &MaximumVariableStorageSize, &RemainingVariableStorageSize, &MaximumVariableSize);
if (EFI_ERROR(Status)) {
PRINT("%r\n", Status);
} else {
PRINT("%ld, %ld, %ld\n", MaximumVariableStorageSize, RemainingVariableStorageSize, MaximumVariableSize);
}
// NV+BS+RT
PRINT(" NV+BS+RT: ");
Attributes = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;
Status = RT->QueryVariableInfo(Attributes, &MaximumVariableStorageSize, &RemainingVariableStorageSize, &MaximumVariableSize);
if (EFI_ERROR(Status)) {
PRINT("%r\n", Status);
} else {
PRINT("%ld, %ld, %ld\n", MaximumVariableStorageSize, RemainingVariableStorageSize, MaximumVariableSize);
}
*/
//
// Print all vars
//
PRINT("Variables:\n");
VariableNameBufferSize = VARIABLE_NAME_BUFFER_SIZE;
if (gVariableNameBuffer == NULL) {
// init var name buffer
// note: this must be called during boot services,
// so if vars are going to be printed during runtime
// they must be first printed during boot services
// to init this buffer.
if (InBootServices) {
gVariableNameBuffer = AllocateRuntimePool(VariableNameBufferSize);
} else {
// error: buffer not inited during boot services
PRINT("ERROR: gVariableNameBuffer not inited\n");
return;
}
}
// first call to GetNextVariableName must be with empty string
gVariableNameBuffer[0] = L'\0';
while (TRUE) {
VariableNameSize = VariableNameBufferSize;
Status = RT->GetNextVariableName(&VariableNameSize, gVariableNameBuffer, &VendorGuid);
if (Status == EFI_BUFFER_TOO_SMALL) {
// we will not handle this to avoid problems during calling in runtime
PRINT("ERROR: gVariableNameBuffer too small\n");
return;
}
if (Status == EFI_NOT_FOUND) {
// no more vars
break;
}
if (EFI_ERROR (Status)) {
// no more vars or error
PRINT("ERROR: GetNextVariableName: %r\n", Status);
return;
}
// prepare for var data if needed
if (gVariableDataBuffer == NULL) {
if (InBootServices) {
gVariableDataBuffer = AllocateRuntimePool(VARIABLE_DATA_BUFFER_SIZE);
} else {
// error: buffer not inited during boot services
PRINT("ERROR: gVariableDataBuffer not inited\n");
return;
}
}
IsDataPrintDisabled = FALSE;
#if PRINT_SHELL_VARS == 0
{
BOOLEAN IsShellVar;
IsShellVar = CompareGuid(&VendorGuid, &ShellInt)
|| CompareGuid(&VendorGuid, &SEnv)
|| CompareGuid(&VendorGuid, &ShellDevPathMap)
|| CompareGuid(&VendorGuid, &ShellProtId)
|| CompareGuid(&VendorGuid, &ShellAlias);
IsDataPrintDisabled = IsShellVar;
}
#endif
// get and print this var
VariableDataSize = VARIABLE_DATA_BUFFER_SIZE;
Status = RT->GetVariable(gVariableNameBuffer, &VendorGuid, &Attributes, &VariableDataSize, gVariableDataBuffer);
if (EFI_ERROR(Status)) {
PRINT(" %s:%s = %r\n", GuidStr(&VendorGuid), gVariableNameBuffer, Status);
} else {
PRINT("%08x ", Attributes);
PRINT("%a", (Attributes & EFI_VARIABLE_NON_VOLATILE) ? "NV+" : " ");
PRINT("%a", (Attributes & EFI_VARIABLE_BOOTSERVICE_ACCESS) ? "BS+" : " ");
PRINT("%a", (Attributes & EFI_VARIABLE_RUNTIME_ACCESS) ? "RT+" : " ");
PRINT("%a", (Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) ? "HW+" : " ");
PRINT(" %s:%s, DataSize = %x\n", GuidStr(&VendorGuid), gVariableNameBuffer, VariableDataSize);
if (!IsDataPrintDisabled) {
PrintBytes(gVariableDataBuffer, VariableDataSize);
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink