[mirror_edk2.git] / ArmPlatformPkg / Scripts / Ds5 / edk2_debugger.py

#\r
#  Copyright (c) 2011-2013, ARM Limited. All rights reserved.\r
#\r
#  This program and the accompanying materials\r
#  are licensed and made available under the terms and conditions of the BSD License\r
#  which accompanies this distribution.  The full text of the license may be found at\r
#  http://opensource.org/licenses/bsd-license.php\r
#\r
#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
#\r
\r
import os\r
\r
import firmware_volume\r
import build_report\r
import system_table\r
\r
# Reload external classes\r
reload(firmware_volume)\r
reload(build_report)\r
reload(system_table)\r
\r
def readMem32(executionContext, address):\r
    bytes = executionContext.getMemoryService().read(address, 4, 32)\r
    return struct.unpack('<I',bytes)[0]\r
\r
def dump_fv(ec, fv_base, fv_size):\r
    fv = firmware_volume.FirmwareVolume(ec,\r
                                        int(build.PCDs['gArmTokenSpaceGuid']['PcdFvBaseAddress'][0],16),\r
                                        int(build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16))\r
\r
    ffs = fv.get_next_ffs()\r
    while ffs != None:\r
        print "# %s" % ffs\r
\r
        section = ffs.get_next_section()\r
        while section != None:\r
            print "\t%s" % section\r
            try:\r
                print "\t\t- %s" % section.get_debug_filepath()\r
            except Exception:\r
                pass\r
            section = ffs.get_next_section(section)\r
\r
        ffs = fv.get_next_ffs(ffs)\r
\r
def dump_system_table(ec, mem_base, mem_size):\r
    st = system_table.SystemTable(ec, mem_base, mem_size)\r
\r
    debug_info_table_base = st.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)\r
\r
    debug_info_table = system_table.DebugInfoTable(ec, debug_info_table_base)\r
    debug_info_table.dump()\r
\r
def load_symbol_from_file(ec, filename, address, verbose = False):\r
    if verbose:\r
        print "Add symbols of %s at 0x%x" % (filename, address)\r
\r
    try:\r
        ec.getImageService().addSymbols(filename, address)\r
    except:\r
        try:\r
            # We could get an exception if the symbols are already loaded\r
            ec.getImageService().unloadSymbols(filename)\r
            ec.getImageService().addSymbols(filename, address)\r
        except:\r
            print "Warning: not possible to load symbols from %s at 0x%x" % (filename, address)\r
\r
def is_aarch64(ec):\r
    success = True\r
    try:\r
        # Try to access a Aarch64 specific register\r
        ec.getRegisterService().getValue('X0')\r
    except:\r
        success = False\r
    return success\r
\r
class ArmPlatform:\r
    def __init__(self, sysmembase=None, sysmemsize=None, fvs={}):\r
        self.sysmembase = sysmembase\r
        self.sysmemsize = sysmemsize\r
        self.fvs = fvs\r
\r
class ArmPlatformDebugger:\r
    system_table = None\r
    firmware_volumes = {}\r
\r
    REGION_TYPE_SYSMEM = 1\r
    REGION_TYPE_ROM    = 2\r
    REGION_TYPE_FV     = 3\r
\r
    def __init__(self, ec, report_log, regions, verbose = False):\r
        self.ec = ec\r
        self.verbose = verbose\r
        fvs = []\r
        sysmem_base = None\r
        sysmem_size = None\r
\r
        if report_log and os.path.isfile(report_log):\r
            try:\r
                self.build = build_report.BuildReport(report_log)\r
            except IOError:\r
                raise IOError(2, 'Report \'%s\' is not valid' % report_log)\r
\r
            # Generate list of supported Firmware Volumes\r
            if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16) != 0:\r
                fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16)))\r
            if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdSecureFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvSize'][0],16) != 0:\r
                fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvSize'][0],16)))\r
            if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdHypFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvSize'][0],16) != 0:\r
                fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvSize'][0],16)))\r
\r
            sysmem_base = int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSystemMemoryBase'][0],16)\r
            sysmem_size = int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSystemMemorySize'][0],16)\r
        else:\r
            for region in regions:\r
                if region[0] == ArmPlatformDebugger.REGION_TYPE_SYSMEM:\r
                    sysmem_base = region[1]\r
                    sysmem_size = region[2]\r
                elif region[0] == ArmPlatformDebugger.REGION_TYPE_FV:\r
                    fvs.append((region[1],region[2]))\r
                elif region[0] == ArmPlatformDebugger.REGION_TYPE_ROM:\r
                    for base in xrange(region[1], region[1] + region[2], 0x400000):\r
                        signature = struct.unpack("cccc", self.ec.getMemoryService().read(base, 4, 32))\r
                        if signature == FirmwareVolume.CONST_FV_SIGNATURE:\r
                            fvs.append((base,0))\r
                else:\r
                    print "Region type '%d' Not Supported" % region[0]\r
\r
        self.platform = ArmPlatform(sysmem_base, sysmem_size, fvs)\r
\r
    def in_sysmem(self, addr):\r
        return (self.platform.sysmembase is not None) and (self.platform.sysmembase <= addr) and (addr < self.platform.sysmembase + self.platform.sysmemsize)\r
\r
    def in_fv(self, addr):\r
        return (self.get_fv_at(addr) != None)\r
\r
    def get_fv_at(self, addr):\r
        for fv in self.platform.fvs:\r
            if (fv[0] <= addr) and (addr < fv[0] + fv[1]):\r
                return fv\r
        return None\r
\r
    def load_current_symbols(self):\r
        pc = int(self.ec.getRegisterService().getValue('PC')) & 0xFFFFFFFF\r
        if self.in_fv(pc):\r
            debug_infos = []\r
\r
            (fv_base, fv_size) = self.get_fv_at(pc)\r
\r
            if self.firmware_volumes.has_key(fv_base) == False:\r
                self.firmware_volumes[fv_base] = firmware_volume.FirmwareVolume(self.ec, fv_base, fv_size)\r
\r
            stack_frame = self.ec.getTopLevelStackFrame()\r
            info = self.firmware_volumes[fv_base].load_symbols_at(int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF, self.verbose)\r
            debug_infos.append(info)\r
            while stack_frame.next() is not None:\r
                stack_frame = stack_frame.next()\r
\r
                # Stack frame attached to 'PC'\r
                pc = int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF\r
\r
                # Check if the symbols for this stack frame have already been loaded\r
                found = False\r
                for debug_info in debug_infos:\r
                    if (pc >= debug_info[0]) and (pc < debug_info[0] + debug_info[1]):\r
                        found = True\r
                if found == False:\r
                    info = self.firmware_volumes[fv_base].load_symbols_at(pc)\r
                    debug_infos.append(info)\r
\r
            #self.firmware_volumes[fv_base].load_symbols_at(pc)\r
        elif self.in_sysmem(pc):\r
            debug_infos = []\r
\r
            if self.system_table is None:\r
                # Find the System Table\r
                self.system_table = system_table.SystemTable(self.ec, self.platform.sysmembase, self.platform.sysmemsize)\r
\r
                # Find the Debug Info Table\r
                debug_info_table_base = self.system_table.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)\r
                self.debug_info_table = system_table.DebugInfoTable(self.ec, debug_info_table_base)\r
\r
            stack_frame = self.ec.getTopLevelStackFrame()\r
            info = self.debug_info_table.load_symbols_at(int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF, self.verbose)\r
            debug_infos.append(info)\r
            while stack_frame.next() is not None:\r
                stack_frame = stack_frame.next()\r
\r
                # Stack frame attached to 'PC'\r
                pc = int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF\r
\r
                # Check if the symbols for this stack frame have already been loaded\r
                found = False\r
                for debug_info in debug_infos:\r
                    if (pc >= debug_info[0]) and (pc < debug_info[0] + debug_info[1]):\r
                        found = True\r
                if found == False:\r
                    try:\r
                        info = self.debug_info_table.load_symbols_at(pc)\r
                        debug_infos.append(info)\r
                    except:\r
                        pass\r
\r
            #self.debug_info_table.load_symbols_at(pc)\r
        else:\r
            raise Exception('ArmPlatformDebugger', "Not supported region")\r
\r
    def load_all_symbols(self):\r
        # Load all the XIP symbols attached to the Firmware Volume\r
        for (fv_base, fv_size) in self.platform.fvs:\r
            if self.firmware_volumes.has_key(fv_base) == False:\r
                self.firmware_volumes[fv_base] = firmware_volume.FirmwareVolume(self.ec, fv_base, fv_size)\r
            self.firmware_volumes[fv_base].load_all_symbols(self.verbose)\r
\r
        try:\r
            # Load all symbols of module loaded into System Memory\r
            if self.system_table is None:\r
                # Find the System Table\r
                self.system_table = system_table.SystemTable(self.ec, self.platform.sysmembase, self.platform.sysmemsize)\r
\r
\r
                # Find the Debug Info Table\r
                debug_info_table_base = self.system_table.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)\r
                self.debug_info_table = system_table.DebugInfoTable(self.ec, debug_info_table_base)\r
\r
            self.debug_info_table.load_all_symbols(self.verbose)\r
        except:\r
            # Debugger exception could be excepted if DRAM has not been initialized or if we have not started to run from DRAM yet\r
            print "Note: no symbols have been found in System Memory (possible cause: the UEFI permanent memory has been installed yet)"\r
Commit	Line	Data
1e57a462	1	#\r
72efe027	2	# Copyright (c) 2011-2013, ARM Limited. All rights reserved.\r
1e57a462	3	#\r
3402aac7 RC	4	# This program and the accompanying materials\r
	5	# are licensed and made available under the terms and conditions of the BSD License\r
	6	# which accompanies this distribution. The full text of the license may be found at\r
	7	# http://opensource.org/licenses/bsd-license.php\r
	8	#\r
	9	# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	10	# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
1e57a462	11	#\r
	12	\r
	13	import os\r
	14	\r
	15	import firmware_volume\r
	16	import build_report\r
	17	import system_table\r
	18	\r
	19	# Reload external classes\r
	20	reload(firmware_volume)\r
	21	reload(build_report)\r
	22	reload(system_table)\r
	23	\r
	24	def readMem32(executionContext, address):\r
	25	bytes = executionContext.getMemoryService().read(address, 4, 32)\r
	26	return struct.unpack('<I',bytes)[0]\r
	27	\r
	28	def dump_fv(ec, fv_base, fv_size):\r
	29	fv = firmware_volume.FirmwareVolume(ec,\r
	30	int(build.PCDs['gArmTokenSpaceGuid']['PcdFvBaseAddress'][0],16),\r
	31	int(build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16))\r
3402aac7	32	\r
1e57a462	33	ffs = fv.get_next_ffs()\r
3402aac7	34	while ffs != None:\r
1e57a462	35	print "# %s" % ffs\r
3402aac7	36	\r
1e57a462	37	section = ffs.get_next_section()\r
	38	while section != None:\r
	39	print "\t%s" % section\r
	40	try:\r
	41	print "\t\t- %s" % section.get_debug_filepath()\r
	42	except Exception:\r
	43	pass\r
	44	section = ffs.get_next_section(section)\r
3402aac7	45	\r
1e57a462	46	ffs = fv.get_next_ffs(ffs)\r
	47	\r
	48	def dump_system_table(ec, mem_base, mem_size):\r
	49	st = system_table.SystemTable(ec, mem_base, mem_size)\r
3402aac7	50	\r
1e57a462	51	debug_info_table_base = st.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)\r
3402aac7	52	\r
1e57a462	53	debug_info_table = system_table.DebugInfoTable(ec, debug_info_table_base)\r
	54	debug_info_table.dump()\r
	55	\r
72efe027	56	def load_symbol_from_file(ec, filename, address, verbose = False):\r
	57	if verbose:\r
	58	print "Add symbols of %s at 0x%x" % (filename, address)\r
3402aac7	59	\r
1e57a462	60	try:\r
	61	ec.getImageService().addSymbols(filename, address)\r
	62	except:\r
	63	try:\r
	64	# We could get an exception if the symbols are already loaded\r
	65	ec.getImageService().unloadSymbols(filename)\r
	66	ec.getImageService().addSymbols(filename, address)\r
	67	except:\r
72efe027	68	print "Warning: not possible to load symbols from %s at 0x%x" % (filename, address)\r
e3d495e1 HL	69	\r
	70	def is_aarch64(ec):\r
	71	success = True\r
	72	try:\r
	73	# Try to access a Aarch64 specific register\r
	74	ec.getRegisterService().getValue('X0')\r
	75	except:\r
	76	success = False\r
	77	return success\r
1e57a462	78	\r
	79	class ArmPlatform:\r
	80	def __init__(self, sysmembase=None, sysmemsize=None, fvs={}):\r
	81	self.sysmembase = sysmembase\r
	82	self.sysmemsize = sysmemsize\r
	83	self.fvs = fvs\r
3402aac7	84	\r
1e57a462	85	class ArmPlatformDebugger:\r
	86	system_table = None\r
	87	firmware_volumes = {}\r
3402aac7	88	\r
1e57a462	89	REGION_TYPE_SYSMEM = 1\r
	90	REGION_TYPE_ROM = 2\r
	91	REGION_TYPE_FV = 3\r
3402aac7	92	\r
72efe027	93	def __init__(self, ec, report_log, regions, verbose = False):\r
1e57a462	94	self.ec = ec\r
72efe027	95	self.verbose = verbose\r
1e57a462	96	fvs = []\r
	97	sysmem_base = None\r
	98	sysmem_size = None\r
3402aac7	99	\r
1e57a462	100	if report_log and os.path.isfile(report_log):\r
	101	try:\r
	102	self.build = build_report.BuildReport(report_log)\r
	103	except IOError:\r
72efe027	104	raise IOError(2, 'Report \'%s\' is not valid' % report_log)\r
3402aac7	105	\r
1e57a462	106	# Generate list of supported Firmware Volumes\r
	107	if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16) != 0:\r
	108	fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16)))\r
	109	if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdSecureFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvSize'][0],16) != 0:\r
	110	fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvSize'][0],16)))\r
	111	if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdHypFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvSize'][0],16) != 0:\r
	112	fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvSize'][0],16)))\r
3402aac7	113	\r
1e57a462	114	sysmem_base = int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSystemMemoryBase'][0],16)\r
	115	sysmem_size = int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSystemMemorySize'][0],16)\r
	116	else:\r
	117	for region in regions:\r
	118	if region[0] == ArmPlatformDebugger.REGION_TYPE_SYSMEM:\r
	119	sysmem_base = region[1]\r
	120	sysmem_size = region[2]\r
	121	elif region[0] == ArmPlatformDebugger.REGION_TYPE_FV:\r
	122	fvs.append((region[1],region[2]))\r
	123	elif region[0] == ArmPlatformDebugger.REGION_TYPE_ROM:\r
	124	for base in xrange(region[1], region[1] + region[2], 0x400000):\r
	125	signature = struct.unpack("cccc", self.ec.getMemoryService().read(base, 4, 32))\r
	126	if signature == FirmwareVolume.CONST_FV_SIGNATURE:\r
	127	fvs.append((base,0))\r
	128	else:\r
	129	print "Region type '%d' Not Supported" % region[0]\r
3402aac7	130	\r
1e57a462	131	self.platform = ArmPlatform(sysmem_base, sysmem_size, fvs)\r
3402aac7	132	\r
1e57a462	133	def in_sysmem(self, addr):\r
	134	return (self.platform.sysmembase is not None) and (self.platform.sysmembase <= addr) and (addr < self.platform.sysmembase + self.platform.sysmemsize)\r
	135	\r
	136	def in_fv(self, addr):\r
	137	return (self.get_fv_at(addr) != None)\r
	138	\r
	139	def get_fv_at(self, addr):\r
	140	for fv in self.platform.fvs:\r
	141	if (fv[0] <= addr) and (addr < fv[0] + fv[1]):\r
	142	return fv\r
	143	return None\r
	144	\r
	145	def load_current_symbols(self):\r
	146	pc = int(self.ec.getRegisterService().getValue('PC')) & 0xFFFFFFFF\r
	147	if self.in_fv(pc):\r
	148	debug_infos = []\r
3402aac7	149	\r
1e57a462	150	(fv_base, fv_size) = self.get_fv_at(pc)\r
3402aac7	151	\r
1e57a462	152	if self.firmware_volumes.has_key(fv_base) == False:\r
1e57a462	153	self.firmware_volumes[fv_base] = firmware_volume.FirmwareVolume(self.ec, fv_base, fv_size)\r
3402aac7	154	\r
1e57a462	155	stack_frame = self.ec.getTopLevelStackFrame()\r
72efe027	156	info = self.firmware_volumes[fv_base].load_symbols_at(int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF, self.verbose)\r
1e57a462	157	debug_infos.append(info)\r
	158	while stack_frame.next() is not None:\r
	159	stack_frame = stack_frame.next()\r
3402aac7	160	\r
1e57a462	161	# Stack frame attached to 'PC'\r
1e57a462	162	pc = int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF\r
3402aac7	163	\r
1e57a462	164	# Check if the symbols for this stack frame have already been loaded\r
	165	found = False\r
	166	for debug_info in debug_infos:\r
	167	if (pc >= debug_info[0]) and (pc < debug_info[0] + debug_info[1]):\r
	168	found = True\r
	169	if found == False:\r
	170	info = self.firmware_volumes[fv_base].load_symbols_at(pc)\r
	171	debug_infos.append(info)\r
3402aac7	172	\r
1e57a462	173	#self.firmware_volumes[fv_base].load_symbols_at(pc)\r
	174	elif self.in_sysmem(pc):\r
	175	debug_infos = []\r
3402aac7	176	\r
1e57a462	177	if self.system_table is None:\r
	178	# Find the System Table\r
	179	self.system_table = system_table.SystemTable(self.ec, self.platform.sysmembase, self.platform.sysmemsize)\r
3402aac7	180	\r
1e57a462	181	# Find the Debug Info Table\r
	182	debug_info_table_base = self.system_table.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)\r
	183	self.debug_info_table = system_table.DebugInfoTable(self.ec, debug_info_table_base)\r
3402aac7	184	\r
1e57a462	185	stack_frame = self.ec.getTopLevelStackFrame()\r
72efe027	186	info = self.debug_info_table.load_symbols_at(int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF, self.verbose)\r
1e57a462	187	debug_infos.append(info)\r
	188	while stack_frame.next() is not None:\r
	189	stack_frame = stack_frame.next()\r
3402aac7	190	\r
1e57a462	191	# Stack frame attached to 'PC'\r
1e57a462	192	pc = int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF\r
3402aac7	193	\r
1e57a462	194	# Check if the symbols for this stack frame have already been loaded\r
	195	found = False\r
	196	for debug_info in debug_infos:\r
	197	if (pc >= debug_info[0]) and (pc < debug_info[0] + debug_info[1]):\r
	198	found = True\r
	199	if found == False:\r
e3d495e1 HL	200	try:\r
	201	info = self.debug_info_table.load_symbols_at(pc)\r
	202	debug_infos.append(info)\r
	203	except:\r
	204	pass\r
3402aac7	205	\r
1e57a462	206	#self.debug_info_table.load_symbols_at(pc)\r
	207	else:\r
	208	raise Exception('ArmPlatformDebugger', "Not supported region")\r
3402aac7	209	\r
1e57a462	210	def load_all_symbols(self):\r
	211	# Load all the XIP symbols attached to the Firmware Volume\r
	212	for (fv_base, fv_size) in self.platform.fvs:\r
	213	if self.firmware_volumes.has_key(fv_base) == False:\r
3402aac7	214	self.firmware_volumes[fv_base] = firmware_volume.FirmwareVolume(self.ec, fv_base, fv_size)\r
72efe027	215	self.firmware_volumes[fv_base].load_all_symbols(self.verbose)\r
1e57a462	216	\r
	217	try:\r
	218	# Load all symbols of module loaded into System Memory\r
	219	if self.system_table is None:\r
	220	# Find the System Table\r
	221	self.system_table = system_table.SystemTable(self.ec, self.platform.sysmembase, self.platform.sysmemsize)\r
3402aac7 RC	222	\r
3402aac7 RC	223	\r
1e57a462	224	# Find the Debug Info Table\r
	225	debug_info_table_base = self.system_table.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)\r
	226	self.debug_info_table = system_table.DebugInfoTable(self.ec, debug_info_table_base)\r
3402aac7	227	\r
72efe027	228	self.debug_info_table.load_all_symbols(self.verbose)\r
1e57a462	229	except:\r
	230	# Debugger exception could be excepted if DRAM has not been initialized or if we have not started to run from DRAM yet\r
	231	print "Note: no symbols have been found in System Memory (possible cause: the UEFI permanent memory has been installed yet)"\r