def _execute(self, input):
if input:
self._latest_command = input
else:
input = self._latest_command
if input == 'q':
global_env.stop_all()
global_env.dbg_event.set()
elif input == 'h':
logger.critical("In the future this will show you the help.")
elif input == 'c' or input == 'continue':
logger.critical("Continue")
global_env.dbg_event.set()
elif input == 'ci':
logger.critical(global_env.get_info())
logger.critical("Continue ..")
global_env.dbg_event.set()
elif input == 'n' or input == 'next':
global_env.STEPPING = True
global_env.dbg_event.set()
logger.critical("Next ..")
elif input == 's off':
global_env.STEPPING = False
elif input == 's on':
global_env.STEPPING = True
elif self.break1_re.match(input):
# Breakpoint decimal
address = self.break1_number_re.search(input).group()
self._gdb_breakpoint_insert(int(address), 4, 0)
elif self.break2_re.match(input):
# Breakpoint hex
address = self.break2_number_re.search(input).group()
self._gdb_breakpoint_remove(int(address, 16), 4, 0)
elif input == 'info' or input == 'i':
print global_env.get_info()
else:
logger.critical("Wrong command.")
def run(self):
while True:
try:
if self._stopped:
logger.critical("System was stopped")
break
input = self.char_driver.read_byte()
if not input:
logger.critical("Client closed connection.")
break
logger.critical("Received char (%s) => (%s)", ord(input), input)
self.process_byte(input)
except socket.timeout:
# check events now
if global_env.dbg_breakpoint_hit:
global_env.dbg_breakpoint_hit = False
self._send_anonymous_stop_signal()
except:
break
logger.critical("Makkah: Terminated via GDBstub")
global_env.stop_all()
global_env.dbg_event.set()
def shutdown(signum, frame):
logger.info("Received shutdown.")
global_env.stop_all()
def gdb_handle_packet(self):
def unknown_command():
_buffer = (c_uint8 * 2)()
_buffer[0] = ord('\x00')
_buffer[1] = ord('\x00')
self._put_packet(_buffer, 1)
index = 0
ch = chr(self.PIBuffer[index])
index = 1
if ch == 'z' or ch == 'Z':
type, index = self._strtoul(self.PIBuffer, index, True)
if self.PIBuffer[index] == ord(','):
index += 1
addr, index = self._strtoul(self.PIBuffer, index, True)
if self.PIBuffer[index] == ord(','):
index += 1
length, index = self._strtoul(self.PIBuffer, index, True)
if ch == 'Z':
res = self._gdb_breakpoint_insert(addr, length, type);
else:
res = self._gdb_breakpoint_remove(addr, length, type);
if res >= 0:
str = "OK"
self._put_packet(self._str_to_buf(str), len(str))
elif res == -self.ENOSYS:
str = ""
self._put_packet(self._str_to_buf(str), len(str))
else:
str = "E22"
self._put_packet(self._str_to_buf(str), len(str))
elif ch == '?':
# Initializing.
str = "T05thread:01;"
global_env.GDB_IPs = []
global_env.GDB_ops = []
self._put_packet(self._str_to_buf(str), len(str))
elif ch == 'H':
type = self.PIBuffer[index]
index += 1
thread, index = self._strtoul(self.PIBuffer, index, True)
if thread == -1 or thread == 0:
str = "OK"
self._put_packet(self._str_to_buf(str), len(str));
else:
raise NotImplemented()
elif ch == 'q':
next_char = chr(self.PIBuffer[index])
if next_char == 'C':
# Current thread.
str = 'QC1'
self._put_packet(self._str_to_buf(str), len(str))
else:
unknown_command()
elif ch == 'g':
#FIXME
str = ''
for i in range(16):
value = self._tohex(global_env.main_cpu.register_read(i).value, 8, '0')
logger.critical(value)
str += value
logger.critical("Reading register (%s) => (%s)", i, value)
self._put_packet(self._str_to_buf(str), len(str))
elif ch == 'p':
#FIXME
register_no, index = self._strtoul(self.PIBuffer, index, True)
if register_no < 16:
str = self._tohex(global_env.main_cpu.register_read(register_no).value, 8, '0')
logger.critical("Reading register (%s) => (%s)", register_no, str)
self._put_packet(self._str_to_buf(str), len(str))
else:
str = '00000000'
self._put_packet(self._str_to_buf(str), len(str))
elif ch == 'm':
addr, index = self._strtoul(self.PIBuffer, index, True)
if self.PIBuffer[index] == ord(','):
index += 1
length, _ = self._strtoul(self.PIBuffer, index, True)
arr_length = length * 2
_buffer = (c_uint8 * arr_length)()
# Change your identity to imitate the cpu that's accessing this memory region
global_env.THREAD_ENV.engine_id = global_env.main_cpu.get_name()
i = 0
try:
for _ in range(length / 4):
value = global_env.main_cpu.mmu_read(addr + i).value
hex_value = (self._tohex(value, 8, '0'))
for index in range(8):
_buffer[index] = ord(hex_value[index])
i += 4
self._put_packet(_buffer, arr_length)
except:
str = "E14"
self._put_packet(self._str_to_buf(str), len(str))
elif ch == 'v':
if chr(self.PIBuffer[index]) == 'C' and chr(self.PIBuffer[index + 1]) == 'o' and \
chr(self.PIBuffer[index + 2]) == 'n' and chr(self.PIBuffer[index + 3]) == 't':
if chr(self.PIBuffer[index + 4]) == '?':
str = 'vCont;c;C;s;S'
self._put_packet(self._str_to_buf(str), len(str))
elif chr(self.PIBuffer[index + 4]) == ';' and chr(self.PIBuffer[index + 5]) == 'c':
global_env.STEPPING = False
global_env.dbg_event.set()
elif chr(self.PIBuffer[index + 4]) == ';' and chr(self.PIBuffer[index + 5]) == 's':
global_env.STEPPING = True
global_env.dbg_event.set()
elif ch == 'k':
logger.critical("Makkah: Terminated via GDBstub")
global_env.stop_all()
global_env.dbg_event.set()
else:
unknown_command()
return GDBStates['RS_IDLE']
