CloverBootloader/Protocols/DumpUefiCalls/Lib.c

/** @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 mAppleScreenInfoProtocolGuid			= {0xE316E100, 0x0751, 0x4C49, {0x90, 0x56, 0x48, 0x6C, 0x7E, 0x47, 0x29, 0x03}};
EFI_GUID mAppleBootKeyPressProtocolGuid			= {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 mEfiManagedNetworkServiceBindingProtocolGuid	= {0xF36FF770, 0xA7E1, 0x42CF, {0x9E, 0xD2, 0x56, 0xF0, 0xF2, 0x71, 0xF4, 0x4C}};
EFI_GUID mEfiSimpleNetworkProtocolGuid			= {0xA19832B9, 0xAC25, 0x11D3, {0x9A, 0x2D, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D}};
EFI_GUID mEfiArpServiceBindingProtocolGuid		= {0xF44C00EE, 0x1F2C, 0x4A00, {0xAA, 0x09, 0x1C, 0x9F, 0x3E, 0x08, 0x00, 0xA3}};
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 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 mEfiIncompatiblePciDeviceSupportProtocolGuid	= {0xEB23F55A, 0x7863, 0x4AC2, {0x8D, 0x3D, 0x95, 0x65, 0x35, 0xDE, 0x03, 0x75}};
EFI_GUID mEfiPciPlatformProtocolGuid			= {0x07D75280, 0x27D4, 0x4D69, {0x90, 0xD0, 0x56, 0x43, 0xE2, 0x38, 0xB3, 0x41}};
EFI_GUID mEfiMtftp4ServiceBindingProtocolGuid		= {0x2FE800BE, 0x8F01, 0x4AA6, {0x94, 0x6B, 0xD7, 0x13, 0x88, 0xE1, 0x83, 0x3F}};
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 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"},
  {&mAppleScreenInfoProtocolGuid, L"gAppleScreenInfoProtocolGuid"},
  {&mAppleBootKeyPressProtocolGuid, L"gAppleBootKeyPressProtocolGuid"},
  {&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);
			}
		}
	}
}