diff --git a/.ruff-excludes.toml b/.ruff-excludes.toml index 05c5eb408ed23..57fbe6eb56463 100644 --- a/.ruff-excludes.toml +++ b/.ruff-excludes.toml @@ -128,57 +128,14 @@ "I001", # https://docs.astral.sh/ruff/rules/unsorted-imports "UP015", # https://docs.astral.sh/ruff/rules/redundant-open-modes ] -"./scripts/coredump/coredump_gdbserver.py" = [ - "I001", # https://docs.astral.sh/ruff/rules/unsorted-imports -] "./scripts/coredump/coredump_parser/elf_parser.py" = [ - "E501", # https://docs.astral.sh/ruff/rules/line-too-long - "I001", # https://docs.astral.sh/ruff/rules/unsorted-imports "SIM115", # https://docs.astral.sh/ruff/rules/open-file-with-context-handler - "UP031", # https://docs.astral.sh/ruff/rules/printf-string-formatting - "UP039", # https://docs.astral.sh/ruff/rules/unnecessary-class-parentheses ] "./scripts/coredump/coredump_parser/log_parser.py" = [ - "I001", # https://docs.astral.sh/ruff/rules/unsorted-imports "SIM115", # https://docs.astral.sh/ruff/rules/open-file-with-context-handler - "UP030", # https://docs.astral.sh/ruff/rules/format-literals - "UP031", # https://docs.astral.sh/ruff/rules/printf-string-formatting - "UP032", # https://docs.astral.sh/ruff/rules/f-string ] "./scripts/coredump/coredump_serial_log_parser.py" = [ - "I001", # https://docs.astral.sh/ruff/rules/unsorted-imports "SIM115", # https://docs.astral.sh/ruff/rules/open-file-with-context-handler - "UP015", # https://docs.astral.sh/ruff/rules/redundant-open-modes -] -"./scripts/coredump/gdbstubs/arch/arm64.py" = [ - "I001", # https://docs.astral.sh/ruff/rules/unsorted-imports - "UP039", # https://docs.astral.sh/ruff/rules/unnecessary-class-parentheses -] -"./scripts/coredump/gdbstubs/arch/arm_cortex_m.py" = [ - "E501", # https://docs.astral.sh/ruff/rules/line-too-long - "I001", # https://docs.astral.sh/ruff/rules/unsorted-imports - "UP039", # https://docs.astral.sh/ruff/rules/unnecessary-class-parentheses -] -"./scripts/coredump/gdbstubs/arch/risc_v.py" = [ - "I001", # https://docs.astral.sh/ruff/rules/unsorted-imports - "UP039", # https://docs.astral.sh/ruff/rules/unnecessary-class-parentheses -] -"./scripts/coredump/gdbstubs/arch/x86.py" = [ - "I001", # https://docs.astral.sh/ruff/rules/unsorted-imports - "UP039", # https://docs.astral.sh/ruff/rules/unnecessary-class-parentheses -] -"./scripts/coredump/gdbstubs/arch/x86_64.py" = [ - "I001", # https://docs.astral.sh/ruff/rules/unsorted-imports - "UP039", # https://docs.astral.sh/ruff/rules/unnecessary-class-parentheses -] -"./scripts/coredump/gdbstubs/arch/xtensa.py" = [ - "I001", # https://docs.astral.sh/ruff/rules/unsorted-imports - "SIM113", # https://docs.astral.sh/ruff/rules/enumerate-for-loop - "UP031", # https://docs.astral.sh/ruff/rules/printf-string-formatting -] -"./scripts/coredump/gdbstubs/gdbstub.py" = [ - "E501", # https://docs.astral.sh/ruff/rules/line-too-long - "I001", # https://docs.astral.sh/ruff/rules/unsorted-imports ] "./scripts/dts/gen_defines.py" = [ "B007", # https://docs.astral.sh/ruff/rules/unused-loop-control-variable @@ -965,17 +922,6 @@ exclude = [ "./samples/subsys/zbus/remote_mock/remote_mock.py", "./scripts/check_maintainers.py", "./scripts/ci/upload_test_results_es.py", - "./scripts/coredump/coredump_gdbserver.py", - "./scripts/coredump/coredump_parser/elf_parser.py", - "./scripts/coredump/coredump_parser/log_parser.py", - "./scripts/coredump/coredump_serial_log_parser.py", - "./scripts/coredump/gdbstubs/arch/arm64.py", - "./scripts/coredump/gdbstubs/arch/arm_cortex_m.py", - "./scripts/coredump/gdbstubs/arch/risc_v.py", - "./scripts/coredump/gdbstubs/arch/x86.py", - "./scripts/coredump/gdbstubs/arch/x86_64.py", - "./scripts/coredump/gdbstubs/arch/xtensa.py", - "./scripts/coredump/gdbstubs/gdbstub.py", "./scripts/dts/gen_defines.py", "./scripts/dts/gen_driver_kconfig_dts.py", "./scripts/dts/gen_dts_cmake.py", diff --git a/scripts/coredump/coredump_gdbserver.py b/scripts/coredump/coredump_gdbserver.py index 3ffe3d9cfb923..191e27d19a585 100755 --- a/scripts/coredump/coredump_gdbserver.py +++ b/scripts/coredump/coredump_gdbserver.py @@ -10,10 +10,9 @@ import socket import sys -from coredump_parser.log_parser import CoredumpLogFile -from coredump_parser.elf_parser import CoredumpElfFile - import gdbstubs +from coredump_parser.elf_parser import CoredumpElfFile +from coredump_parser.log_parser import CoredumpLogFile LOGGING_FORMAT = "[%(levelname)s][%(name)s] %(message)s" @@ -43,14 +42,10 @@ def parse_args(): parser.add_argument("elffile", help="Zephyr ELF binary") parser.add_argument("logfile", help="Coredump binary log file") - parser.add_argument("--debug", action="store_true", - help="Print extra debugging information") - parser.add_argument("--port", type=int, default=1234, - help="GDB server port") - parser.add_argument("--pipe", action="store_true", - help="Use stdio to communicate with gdb") - parser.add_argument("-v", "--verbose", action="store_true", - help="Print more information") + parser.add_argument("--debug", action="store_true", help="Print extra debugging information") + parser.add_argument("--port", type=int, default=1234, help="GDB server port") + parser.add_argument("--pipe", action="store_true", help="Use stdio to communicate with gdb") + parser.add_argument("-v", "--verbose", action="store_true", help="Print more information") return parser.parse_args() diff --git a/scripts/coredump/coredump_parser/elf_parser.py b/scripts/coredump/coredump_parser/elf_parser.py index 277c62f574698..73cf7268809ce 100644 --- a/scripts/coredump/coredump_parser/elf_parser.py +++ b/scripts/coredump/coredump_parser/elf_parser.py @@ -6,11 +6,10 @@ import logging import struct +from enum import IntEnum import elftools from elftools.elf.elffile import ELFFile -from enum import IntEnum - # ELF section flags SHF_WRITE = 0x1 @@ -19,6 +18,7 @@ SHF_WRITE_ALLOC = SHF_WRITE | SHF_ALLOC SHF_ALLOC_EXEC = SHF_ALLOC | SHF_EXEC + # Must match enum in thread_info.c class ThreadInfoOffset(IntEnum): THREAD_INFO_OFFSET_VERSION = 0 @@ -44,7 +44,7 @@ def __int__(self): logger = logging.getLogger("parser") -class CoredumpElfFile(): +class CoredumpElfFile: """ Class to parse ELF file for memory content in various sections. There are read-only sections (e.g. text and rodata) where @@ -78,7 +78,11 @@ def has_kernel_thread_info(self): return self.kernel_thread_info_offsets is not None def get_kernel_thread_info_offset(self, thread_info_offset_index): - if self.has_kernel_thread_info() and thread_info_offset_index <= ThreadInfoOffset.THREAD_INFO_OFFSET_T_ARC_RELINQUISH_CAUSE: + if ( + self.has_kernel_thread_info() + and thread_info_offset_index + <= ThreadInfoOffset.THREAD_INFO_OFFSET_T_ARC_RELINQUISH_CAUSE + ): return self.kernel_thread_info_offsets[thread_info_offset_index] else: return None @@ -96,14 +100,20 @@ def parse(self): for section in self.elf.iter_sections(): # Find symbols for _kernel_thread_info data if isinstance(section, elftools.elf.sections.SymbolTableSection): - _kernel_thread_info_offsets = section.get_symbol_by_name("_kernel_thread_info_offsets") - _kernel_thread_info_num_offsets = section.get_symbol_by_name("_kernel_thread_info_num_offsets") - _kernel_thread_info_size_t_size = section.get_symbol_by_name("_kernel_thread_info_size_t_size") + _kernel_thread_info_offsets = section.get_symbol_by_name( + "_kernel_thread_info_offsets" + ) + _kernel_thread_info_num_offsets = section.get_symbol_by_name( + "_kernel_thread_info_num_offsets" + ) + _kernel_thread_info_size_t_size = section.get_symbol_by_name( + "_kernel_thread_info_size_t_size" + ) # REALLY NEED to match exact type as all other sections # (debug, text, etc.) are descendants where # isinstance() would match. - if type(section) is not elftools.elf.sections.Section: # pylint: disable=unidiomatic-typecheck + if type(section) is not elftools.elf.sections.Section: # pylint: disable=unidiomatic-typecheck continue size = section['sh_size'] @@ -132,37 +142,49 @@ def parse(self): if store: mem_region = {"start": sec_start, "end": sec_end, "data": section.data()} - logger.info("ELF Section: 0x%x to 0x%x of size %d (%s)" % - (mem_region["start"], - mem_region["end"], - len(mem_region["data"]), - sect_desc)) + logger.info( + f'ELF Section: 0x{mem_region["start"]:x} to 0x{mem_region["end"]:x} ' + f'of size {mem_region["data"]:d} ({sect_desc:s})' + ) self.memory_regions.append(mem_region) - if _kernel_thread_info_size_t_size is not None and \ - _kernel_thread_info_num_offsets is not None and \ - _kernel_thread_info_offsets is not None: + if ( + _kernel_thread_info_size_t_size is not None + and _kernel_thread_info_num_offsets is not None + and _kernel_thread_info_offsets is not None + ): for seg in self.elf.iter_segments(): if seg.header['p_type'] != 'PT_LOAD': continue # Store segment of kernel_thread_info_offsets info_offsets_symbol = _kernel_thread_info_offsets[0] - if info_offsets_symbol['st_value'] >= seg['p_vaddr'] and info_offsets_symbol['st_value'] < seg['p_vaddr'] + seg['p_filesz']: + if ( + info_offsets_symbol['st_value'] >= seg['p_vaddr'] + and info_offsets_symbol['st_value'] < seg['p_vaddr'] + seg['p_filesz'] + ): kernel_thread_info_offsets_segment = seg # Store segment of kernel_thread_info_num_offsets num_offsets_symbol = _kernel_thread_info_num_offsets[0] - if num_offsets_symbol['st_value'] >= seg['p_vaddr'] and num_offsets_symbol['st_value'] < seg['p_vaddr'] + seg['p_filesz']: + if ( + num_offsets_symbol['st_value'] >= seg['p_vaddr'] + and num_offsets_symbol['st_value'] < seg['p_vaddr'] + seg['p_filesz'] + ): kernel_thread_info_num_offsets_segment = seg # Read and store size_t size size_t_size_symbol = _kernel_thread_info_size_t_size[0] - if size_t_size_symbol['st_value'] >= seg['p_vaddr'] and size_t_size_symbol['st_value'] < seg['p_vaddr'] + seg['p_filesz']: + if ( + size_t_size_symbol['st_value'] >= seg['p_vaddr'] + and size_t_size_symbol['st_value'] < seg['p_vaddr'] + seg['p_filesz'] + ): offset = size_t_size_symbol['st_value'] - seg['p_vaddr'] + seg['p_offset'] self.elf.stream.seek(offset) - self.kernel_thread_info_size_t_size = struct.unpack('B', self.elf.stream.read(size_t_size_symbol['st_size']))[0] + self.kernel_thread_info_size_t_size = struct.unpack( + 'B', self.elf.stream.read(size_t_size_symbol['st_size']) + )[0] struct_format = "I" if self.kernel_thread_info_size_t_size == 8: @@ -170,9 +192,15 @@ def parse(self): # Read and store count of offset values num_offsets_symbol = _kernel_thread_info_num_offsets[0] - offset = num_offsets_symbol['st_value'] - kernel_thread_info_num_offsets_segment['p_vaddr'] + kernel_thread_info_num_offsets_segment['p_offset'] + offset = ( + num_offsets_symbol['st_value'] + - kernel_thread_info_num_offsets_segment['p_vaddr'] + + kernel_thread_info_num_offsets_segment['p_offset'] + ) self.elf.stream.seek(offset) - self.kernel_thread_info_num_offsets = struct.unpack(struct_format, self.elf.stream.read(num_offsets_symbol['st_size']))[0] + self.kernel_thread_info_num_offsets = struct.unpack( + struct_format, self.elf.stream.read(num_offsets_symbol['st_size']) + )[0] array_format = "" for _ in range(self.kernel_thread_info_num_offsets): @@ -180,8 +208,14 @@ def parse(self): # Read and store array of offset values info_offsets_symbol = _kernel_thread_info_offsets[0] - offset = info_offsets_symbol['st_value'] - kernel_thread_info_offsets_segment['p_vaddr'] + kernel_thread_info_offsets_segment['p_offset'] + offset = ( + info_offsets_symbol['st_value'] + - kernel_thread_info_offsets_segment['p_vaddr'] + + kernel_thread_info_offsets_segment['p_offset'] + ) self.elf.stream.seek(offset) - self.kernel_thread_info_offsets = struct.unpack(array_format, self.elf.stream.read(info_offsets_symbol['st_size'])) + self.kernel_thread_info_offsets = struct.unpack( + array_format, self.elf.stream.read(info_offsets_symbol['st_size']) + ) return True diff --git a/scripts/coredump/coredump_parser/log_parser.py b/scripts/coredump/coredump_parser/log_parser.py index 409ee7ff568c6..45d2a0ce7e77a 100644 --- a/scripts/coredump/coredump_parser/log_parser.py +++ b/scripts/coredump/coredump_parser/log_parser.py @@ -7,7 +7,6 @@ import logging import struct - # Note: keep sync with C code COREDUMP_HDR_ID = b'ZE' COREDUMP_HDR_VER = 2 @@ -62,7 +61,7 @@ def __init__(self, logfile): self.log_hdr = None self.arch_data = list() self.memory_regions = list() - self.threads_metadata = {"hdr_ver" : None, "data" : None} + self.threads_metadata = {"hdr_ver": None, "data": None} def open(self): self.fd = open(self.logfile, "rb") @@ -85,7 +84,7 @@ def parse_arch_section(self): arch_data = self.fd.read(num_bytes) - self.arch_data = {"hdr_ver" : hdr_ver, "data" : arch_data} + self.arch_data = {"hdr_ver": hdr_ver, "data": arch_data} return True @@ -95,7 +94,7 @@ def parse_threads_metadata_section(self): data = self.fd.read(num_bytes) - self.threads_metadata = {"hdr_ver" : hdr_ver, "data" : data} + self.threads_metadata = {"hdr_ver": hdr_ver, "data": data} return True @@ -126,8 +125,7 @@ def parse_memory_section(self): mem = {"start": saddr, "end": eaddr, "data": data} self.memory_regions.append(mem) - logger.info("Memory: 0x%x to 0x%x of size %d" % - (saddr, eaddr, size)) + logger.info(f"Memory: 0x{saddr:x} to 0x{eaddr:x} of size {size:d}") return True @@ -147,17 +145,17 @@ def parse(self): logger.error(f"Log version: {hdr_ver}, expected: {COREDUMP_HDR_VER}!") return False - ptr_size = 2 ** ptr_size + ptr_size = 2**ptr_size self.log_hdr = { - "hdr_version": hdr_ver, - "tgt_code": tgt_code, - "ptr_size": ptr_size, - "flags": flags, - "reason": reason, - } - - logger.info("Reason: {0}".format(reason_string(reason))) + "hdr_version": hdr_ver, + "tgt_code": tgt_code, + "ptr_size": ptr_size, + "flags": flags, + "reason": reason, + } + + logger.info(f"Reason: {reason_string(reason)}") logger.info(f"Pointer size {ptr_size}") del id1, id2, hdr_ver, tgt_code, ptr_size, flags, reason @@ -168,7 +166,7 @@ def parse(self): # no more data to read break - self.fd.seek(-1, 1) # go back 1 byte + self.fd.seek(-1, 1) # go back 1 byte if section_id == COREDUMP_ARCH_HDR_ID: if not self.parse_arch_section(): logger.error("Cannot parse architecture section") diff --git a/scripts/coredump/coredump_serial_log_parser.py b/scripts/coredump/coredump_serial_log_parser.py index 43e2900c66c32..761fce770cafe 100755 --- a/scripts/coredump/coredump_serial_log_parser.py +++ b/scripts/coredump/coredump_serial_log_parser.py @@ -8,7 +8,6 @@ import binascii import sys - COREDUMP_PREFIX_STR = "#CD:" COREDUMP_BEGIN_STR = COREDUMP_PREFIX_STR + "BEGIN#" @@ -20,8 +19,7 @@ def parse_args(): parser = argparse.ArgumentParser(allow_abbrev=False) parser.add_argument("infile", help="Serial Log File") - parser.add_argument("outfile", - help="Output file for use with coredump GDB server") + parser.add_argument("outfile", help="Output file for use with coredump GDB server") return parser.parse_args() @@ -29,7 +27,7 @@ def parse_args(): def main(): args = parse_args() - infile = open(args.infile, "r") + infile = open(args.infile) if not infile: print(f"ERROR: Cannot open input file: {args.infile}, exiting...") sys.exit(1) diff --git a/scripts/coredump/gdbstubs/arch/arm64.py b/scripts/coredump/gdbstubs/arch/arm64.py index 7f4c03eb375ea..db849a9b4caf3 100644 --- a/scripts/coredump/gdbstubs/arch/arm64.py +++ b/scripts/coredump/gdbstubs/arch/arm64.py @@ -10,12 +10,11 @@ from gdbstubs.gdbstub import GdbStub - logger = logging.getLogger("gdbstub") -class RegNum(): - X0 = 0 # X0-X29 - 30 GP registers +class RegNum: + X0 = 0 # X0-X29 - 30 GP registers X1 = 1 X2 = 2 X3 = 3 @@ -44,14 +43,14 @@ class RegNum(): X26 = 26 X27 = 27 X28 = 28 - X29 = 29 # Frame pointer register - LR = 30 # X30 Link Register(LR) - SP_EL0 = 31 # Stack pointer EL0 (SP_EL0) - PC = 32 # Program Counter (PC) + X29 = 29 # Frame pointer register + LR = 30 # X30 Link Register(LR) + SP_EL0 = 31 # Stack pointer EL0 (SP_EL0) + PC = 32 # Program Counter (PC) class GdbStub_ARM64(GdbStub): - ARCH_DATA_BLK_STRUCT = " 1: - self.registers[RegNum.R4] = tu[9] - self.registers[RegNum.R5] = tu[10] - self.registers[RegNum.R6] = tu[11] - self.registers[RegNum.R7] = tu[12] - self.registers[RegNum.R8] = tu[13] - self.registers[RegNum.R9] = tu[14] + self.registers[RegNum.R4] = tu[9] + self.registers[RegNum.R5] = tu[10] + self.registers[RegNum.R6] = tu[11] + self.registers[RegNum.R7] = tu[12] + self.registers[RegNum.R8] = tu[13] + self.registers[RegNum.R9] = tu[14] self.registers[RegNum.R10] = tu[15] self.registers[RegNum.R11] = tu[16] @@ -121,7 +121,9 @@ def handle_register_single_write_packet(self, pkt): raise ValueError(f"Malformed register write packet: {pkt_str}") reg = int(pkt_str[1:separator_index], 16) - self.registers[reg] = int.from_bytes(binascii.unhexlify(pkt[(separator_index + 1):]), byteorder = 'little') + self.registers[reg] = int.from_bytes( + binascii.unhexlify(pkt[(separator_index + 1) :]), byteorder='little' + ) self.put_gdb_packet(b'+') def arch_supports_thread_operations(self): @@ -135,7 +137,9 @@ def handle_thread_register_group_read_packet(self): thread_ptr = self.thread_ptrs[self.selected_thread] # Get stack pointer out of thread struct - t_stack_ptr_offset = self.elffile.get_kernel_thread_info_offset(ThreadInfoOffset.THREAD_INFO_OFFSET_T_STACK_PTR) + t_stack_ptr_offset = self.elffile.get_kernel_thread_info_offset( + ThreadInfoOffset.THREAD_INFO_OFFSET_T_STACK_PTR + ) size_t_size = self.elffile.get_kernel_thread_info_size_t_size() stack_ptr_bytes = self.get_memory(thread_ptr + t_stack_ptr_offset, size_t_size) @@ -161,15 +165,22 @@ def handle_thread_register_group_read_packet(self): thread_registers[RegNum.SP] = stack_ptr + 32 # Read the exc_return value from the thread's arch struct - t_arch_offset = self.elffile.get_kernel_thread_info_offset(ThreadInfoOffset.THREAD_INFO_OFFSET_T_ARCH) - t_exc_return_offset = self.elffile.get_kernel_thread_info_offset(ThreadInfoOffset.THREAD_INFO_OFFSET_T_ARM_EXC_RETURN) + t_arch_offset = self.elffile.get_kernel_thread_info_offset( + ThreadInfoOffset.THREAD_INFO_OFFSET_T_ARCH + ) + t_exc_return_offset = self.elffile.get_kernel_thread_info_offset( + ThreadInfoOffset.THREAD_INFO_OFFSET_T_ARM_EXC_RETURN + ) # Value of 0xffffffff indicates THREAD_INFO_UNIMPLEMENTED - if t_exc_return_offset != 0xffffffff: - exc_return_bytes = self.get_memory(thread_ptr + t_arch_offset + t_exc_return_offset, 1) + if t_exc_return_offset != 0xFFFFFFFF: + exc_return_bytes = self.get_memory( + thread_ptr + t_arch_offset + t_exc_return_offset, 1 + ) exc_return = int.from_bytes(exc_return_bytes, "little") - # If the bit 4 is not set, the stack frame is extended for floating point data, adjust the SP accordingly + # If the bit 4 is not set, the stack frame is extended for floating point + # data, adjust the SP accordingly if (exc_return & (1 << 4)) == 0: thread_registers[RegNum.SP] = thread_registers[RegNum.SP] + 72 diff --git a/scripts/coredump/gdbstubs/arch/risc_v.py b/scripts/coredump/gdbstubs/arch/risc_v.py index 60c5fcdf63ab4..f00c7cceaa258 100644 --- a/scripts/coredump/gdbstubs/arch/risc_v.py +++ b/scripts/coredump/gdbstubs/arch/risc_v.py @@ -10,10 +10,10 @@ from gdbstubs.gdbstub import GdbStub - logger = logging.getLogger("gdbstub") -class RegNum(): + +class RegNum: ZERO = 0 RA = 1 SP = 2 @@ -50,8 +50,8 @@ class RegNum(): class GdbStub_RISC_V(GdbStub): - ARCH_DATA_BLK_STRUCT = "= 2: self.toolchain = XtensaToolchain(bytearray(arch_data_blk)[3]) @@ -172,18 +173,16 @@ def parse_arch_data_block(self): self.toolchain = XtensaToolchain.ZEPHYR arch_data_blk_regs = arch_data_blk[3:] - logger.debug("Xtensa toolchain: %s" % self.toolchain.name) + logger.debug(f"Xtensa toolchain: {self.toolchain.name}") self.gdb_reg_def = get_gdb_reg_definition(self.soc, self.toolchain) - tu = struct.unpack(self.gdb_reg_def.ARCH_DATA_BLK_STRUCT_REGS, - arch_data_blk_regs) + tu = struct.unpack(self.gdb_reg_def.ARCH_DATA_BLK_STRUCT_REGS, arch_data_blk_regs) self.registers = dict() self.map_registers(tu) - def map_registers(self, tu): i = 0 for r in self.gdb_reg_def.RegNum: @@ -199,8 +198,7 @@ def map_registers(self, tu): if r == self.gdb_reg_def.RegNum.EXCCAUSE: self.exception_code = tu[i] self.registers[reg_num] = tu[i] - i += 1 - + i = i + 1 def compute_signal(self): sig = self.GDB_SIGNAL_DEFAULT @@ -211,19 +209,20 @@ def compute_signal(self): if code in self.GDB_SIGNAL_MAPPING: sig = self.GDB_SIGNAL_MAPPING[code] - elif ExceptionCodes.COPROCESSOR_DISABLED_START.value <= code <= \ - ExceptionCodes.COPROCESSOR_DISABLED_END.value: + elif ( + ExceptionCodes.COPROCESSOR_DISABLED_START.value + <= code + <= ExceptionCodes.COPROCESSOR_DISABLED_END.value + ): sig = 8 self.gdb_signal = sig - def handle_register_group_read_packet(self): idx = 0 pkt = b'' - GDB_G_PKT_MAX_REG = \ - max([reg_num.value for reg_num in self.gdb_reg_def.RegNum]) + GDB_G_PKT_MAX_REG = max([reg_num.value for reg_num in self.gdb_reg_def.RegNum]) # We try to send as many of the registers listed # as possible, but we are constrained by the @@ -239,7 +238,6 @@ def handle_register_group_read_packet(self): self.put_gdb_packet(pkt) - def handle_register_single_read_packet(self, pkt): # format is pXX, where XX is the hex representation of the idx regIdx = int('0x' + pkt[1:].decode('utf8'), 16) @@ -273,7 +271,6 @@ class GdbRegDef_Sample_Controller: # actual hard limit to how big the g packet can be. SOC_GDB_GPKT_BIN_SIZE = 444 - class RegNum(Enum): PC = 0 EXCCAUSE = 77 @@ -337,6 +334,7 @@ class RegNum(Enum): WINDOWBASE = 69 WINDOWSTART = 70 + class GdbRegDef_ESP32S2: ARCH_DATA_BLK_STRUCT_REGS = ' overlays/xtensa_intel_apl/gdb/gdb/xtensa-config.c class GdbRegDef_Intel_Adsp_CAVS_Zephyr: ARCH_DATA_BLK_STRUCT_REGS = ' overlays/xtensa_dc233c/gdb/gdb/xtensa-config.c class GdbRegDef_DC233C: ARCH_DATA_BLK_STRUCT_REGS = ' thread_id: thread_info_bytes += b'name: ' thread_ptr = self.thread_ptrs[thread_id - 1] - t_name_offset = self.elffile.get_kernel_thread_info_offset(ThreadInfoOffset.THREAD_INFO_OFFSET_T_NAME) + t_name_offset = self.elffile.get_kernel_thread_info_offset( + ThreadInfoOffset.THREAD_INFO_OFFSET_T_NAME + ) thread_name_next_byte = self.get_memory(thread_ptr + t_name_offset, 1) index = 0 - while (thread_name_next_byte is not None) and (thread_name_next_byte != b'\x00'): + while (thread_name_next_byte is not None) and ( + thread_name_next_byte != b'\x00' + ): thread_info_bytes += thread_name_next_byte index += 1 - thread_name_next_byte = self.get_memory(thread_ptr + t_name_offset + index, 1) + thread_name_next_byte = self.get_memory( + thread_ptr + t_name_offset + index, 1 + ) - t_state_offset = self.elffile.get_kernel_thread_info_offset(ThreadInfoOffset.THREAD_INFO_OFFSET_T_STATE) + t_state_offset = self.elffile.get_kernel_thread_info_offset( + ThreadInfoOffset.THREAD_INFO_OFFSET_T_STATE + ) thread_state_byte = self.get_memory(thread_ptr + t_state_offset, 1) if thread_state_byte is not None: thread_state = int.from_bytes(thread_state_byte, "little") thread_info_bytes += b', state: ' + bytes(hex(thread_state), 'ascii') - t_user_options_offset = self.elffile.get_kernel_thread_info_offset(ThreadInfoOffset.THREAD_INFO_OFFSET_T_USER_OPTIONS) - thread_user_options_byte = self.get_memory(thread_ptr + t_user_options_offset, 1) + t_user_options_offset = self.elffile.get_kernel_thread_info_offset( + ThreadInfoOffset.THREAD_INFO_OFFSET_T_USER_OPTIONS + ) + thread_user_options_byte = self.get_memory( + thread_ptr + t_user_options_offset, 1 + ) if thread_user_options_byte is not None: thread_user_options = int.from_bytes(thread_user_options_byte, "little") - thread_info_bytes += b', user_options: ' + bytes(hex(thread_user_options), 'ascii') + thread_info_bytes += b', user_options: ' + bytes( + hex(thread_user_options), 'ascii' + ) - t_prio_offset = self.elffile.get_kernel_thread_info_offset(ThreadInfoOffset.THREAD_INFO_OFFSET_T_PRIO) + t_prio_offset = self.elffile.get_kernel_thread_info_offset( + ThreadInfoOffset.THREAD_INFO_OFFSET_T_PRIO + ) thread_prio_byte = self.get_memory(thread_ptr + t_prio_offset, 1) if thread_prio_byte is not None: thread_prio = int.from_bytes(thread_prio_byte, "little")