add debugger
This commit is contained in:
@@ -8,4 +8,5 @@ prometeu-core = { path = "../prometeu-core" }
|
||||
winit = "0.30.12"
|
||||
pixels = "0.15.0"
|
||||
cpal = "0.15.3"
|
||||
ringbuf = "0.4.7"
|
||||
ringbuf = "0.4.7"
|
||||
serde_json = "1.0"
|
||||
@@ -38,26 +38,32 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
let args: Vec<String> = std::env::args().collect();
|
||||
let mut fs_root = None;
|
||||
let mut cap_config = None;
|
||||
let mut boot_target = BootTarget::Hub;
|
||||
let mut cartridge_path = None;
|
||||
let mut debug_mode = false;
|
||||
let mut debug_port = 7777;
|
||||
|
||||
let mut i = 1; // Pula o nome do executável
|
||||
while i < args.len() {
|
||||
match args[i].as_str() {
|
||||
"--run" => {
|
||||
if i + 1 < args.len() {
|
||||
boot_target = BootTarget::Cartridge {
|
||||
path: args[i + 1].clone(),
|
||||
debug: false,
|
||||
};
|
||||
cartridge_path = Some(args[i + 1].clone());
|
||||
debug_mode = false;
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
"--debug" => {
|
||||
if i + 1 < args.len() {
|
||||
boot_target = BootTarget::Cartridge {
|
||||
path: args[i + 1].clone(),
|
||||
debug: true,
|
||||
};
|
||||
cartridge_path = Some(args[i + 1].clone());
|
||||
debug_mode = true;
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
"--port" => {
|
||||
if i + 1 < args.len() {
|
||||
if let Ok(port) = args[i + 1].parse::<u16>() {
|
||||
debug_port = port;
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
@@ -78,6 +84,16 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
i += 1;
|
||||
}
|
||||
|
||||
let boot_target = if let Some(path) = cartridge_path {
|
||||
BootTarget::Cartridge {
|
||||
path,
|
||||
debug: debug_mode,
|
||||
debug_port: if debug_mode { debug_port } else { 7777 },
|
||||
}
|
||||
} else {
|
||||
BootTarget::Hub
|
||||
};
|
||||
|
||||
let event_loop = EventLoop::new()?;
|
||||
|
||||
let mut runner = PrometeuRunner::new(fs_root, cap_config);
|
||||
|
||||
@@ -8,6 +8,7 @@ use prometeu_core::hardware::{AudioCommand, InputSignals, OUTPUT_SAMPLE_RATE};
|
||||
use prometeu_core::Hardware;
|
||||
use ringbuf::traits::{Consumer, Producer, Split};
|
||||
use ringbuf::HeapRb;
|
||||
use std::net::{TcpListener, TcpStream};
|
||||
use std::sync::Arc;
|
||||
use std::time::{Duration, Instant};
|
||||
use winit::application::ApplicationHandler;
|
||||
@@ -17,8 +18,10 @@ use winit::event_loop::{ActiveEventLoop, ControlFlow};
|
||||
use winit::keyboard::{KeyCode, PhysicalKey};
|
||||
use winit::window::{Window, WindowAttributes, WindowId};
|
||||
|
||||
use prometeu_core::model::{CartridgeError, CartridgeLoader};
|
||||
use prometeu_core::model::CartridgeLoader;
|
||||
use prometeu_core::telemetry::CertificationConfig;
|
||||
use prometeu_core::debugger_protocol::*;
|
||||
use std::io::{Read, Write};
|
||||
|
||||
pub struct PrometeuRunner {
|
||||
window: Option<&'static Window>,
|
||||
@@ -43,6 +46,10 @@ pub struct PrometeuRunner {
|
||||
overlay_enabled: bool,
|
||||
|
||||
debug_waiting_for_start: bool,
|
||||
debug_listener: Option<TcpListener>,
|
||||
debug_stream: Option<TcpStream>,
|
||||
debug_last_log_seq: u64,
|
||||
debug_last_telemetry_frame: u64,
|
||||
|
||||
audio_load_accum_us: u64,
|
||||
audio_load_samples: u64,
|
||||
@@ -55,17 +62,206 @@ pub struct PrometeuRunner {
|
||||
impl PrometeuRunner {
|
||||
pub(crate) fn set_boot_target(&mut self, boot_target: BootTarget) {
|
||||
self.firmware.boot_target = boot_target.clone();
|
||||
if let BootTarget::Cartridge { debug: true, .. } = boot_target {
|
||||
if let BootTarget::Cartridge { path, debug: true, debug_port } = boot_target {
|
||||
self.debug_waiting_for_start = true;
|
||||
println!("[Debugger] Waiting for start command...");
|
||||
println!("[Debugger] (Stub: press D to start execution)");
|
||||
|
||||
// Pré-carrega informações do cartucho para o handshake
|
||||
if let Ok(cartridge) = CartridgeLoader::load(&path) {
|
||||
self.firmware.os.initialize_vm(&mut self.firmware.vm, &cartridge);
|
||||
}
|
||||
|
||||
match TcpListener::bind(format!("127.0.0.1:{}", debug_port)) {
|
||||
Ok(listener) => {
|
||||
listener.set_nonblocking(true).expect("Cannot set non-blocking");
|
||||
self.debug_listener = Some(listener);
|
||||
println!("[Debugger] Listening for start command on port {}...", debug_port);
|
||||
}
|
||||
Err(e) => {
|
||||
eprintln!("[Debugger] Failed to bind to port {}: {}", debug_port, e);
|
||||
}
|
||||
}
|
||||
|
||||
println!("[Debugger] (Or press D to start execution)");
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn load_cartridge(&mut self, path: &str) -> Result<(), CartridgeError> {
|
||||
let cartridge = CartridgeLoader::load(path)?;
|
||||
self.firmware.load_cartridge(cartridge);
|
||||
Ok(())
|
||||
|
||||
fn send_debug_response(&mut self, resp: DebugResponse) {
|
||||
if let Some(stream) = &mut self.debug_stream {
|
||||
if let Ok(json) = serde_json::to_string(&resp) {
|
||||
let _ = stream.write_all(json.as_bytes());
|
||||
let _ = stream.write_all(b"\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn send_debug_event(&mut self, event: DebugEvent) {
|
||||
if let Some(stream) = &mut self.debug_stream {
|
||||
if let Ok(json) = serde_json::to_string(&event) {
|
||||
let _ = stream.write_all(json.as_bytes());
|
||||
let _ = stream.write_all(b"\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn check_debug_commands(&mut self) {
|
||||
if self.debug_waiting_for_start {
|
||||
if let Some(listener) = &self.debug_listener {
|
||||
if let Ok((stream, _addr)) = listener.accept() {
|
||||
println!("[Debugger] Connection received!");
|
||||
stream.set_nonblocking(true).expect("Cannot set non-blocking on stream");
|
||||
|
||||
self.debug_stream = Some(stream);
|
||||
|
||||
// Enviar Handshake
|
||||
let handshake = DebugResponse::Handshake {
|
||||
runtime_version: "0.1".to_string(),
|
||||
cartridge: HandshakeCartridge {
|
||||
app_id: self.firmware.os.current_app_id,
|
||||
title: self.firmware.os.current_cartridge_title.clone(),
|
||||
app_version: self.firmware.os.current_cartridge_app_version.clone(),
|
||||
app_mode: self.firmware.os.current_cartridge_app_mode,
|
||||
},
|
||||
};
|
||||
self.send_debug_response(handshake);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(mut stream) = self.debug_stream.take() {
|
||||
let mut buf = [0u8; 4096];
|
||||
match stream.read(&mut buf) {
|
||||
Ok(0) => {
|
||||
println!("[Debugger] Connection closed by remote.");
|
||||
self.debug_stream = None;
|
||||
}
|
||||
Ok(n) => {
|
||||
let data = &buf[..n];
|
||||
// Processar múltiplos comandos se houver \n
|
||||
let msg = String::from_utf8_lossy(data);
|
||||
for line in msg.lines() {
|
||||
if let Ok(cmd) = serde_json::from_str::<DebugCommand>(line) {
|
||||
self.handle_debug_command(cmd);
|
||||
}
|
||||
}
|
||||
self.debug_stream = Some(stream);
|
||||
}
|
||||
Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
|
||||
self.debug_stream = Some(stream);
|
||||
}
|
||||
Err(e) => {
|
||||
eprintln!("[Debugger] Connection error: {}", e);
|
||||
self.debug_stream = None;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Streaming de eventos
|
||||
if self.debug_stream.is_some() {
|
||||
self.stream_debug_events();
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_debug_command(&mut self, cmd: DebugCommand) {
|
||||
match cmd {
|
||||
DebugCommand::Ok | DebugCommand::Start => {
|
||||
if self.debug_waiting_for_start {
|
||||
println!("[Debugger] Starting execution...");
|
||||
self.debug_waiting_for_start = false;
|
||||
self.debug_listener = None;
|
||||
}
|
||||
self.firmware.os.paused = false;
|
||||
}
|
||||
DebugCommand::Pause => {
|
||||
self.firmware.os.paused = true;
|
||||
}
|
||||
DebugCommand::Resume => {
|
||||
self.firmware.os.paused = false;
|
||||
}
|
||||
DebugCommand::Step => {
|
||||
self.firmware.os.paused = true;
|
||||
// Executa uma instrução imediatamente
|
||||
let _ = self.firmware.os.debug_step_instruction(&mut self.firmware.vm, &mut self.hardware);
|
||||
}
|
||||
DebugCommand::StepFrame => {
|
||||
self.firmware.os.paused = false;
|
||||
self.firmware.os.debug_step_request = true;
|
||||
}
|
||||
DebugCommand::GetState => {
|
||||
let stack_top = self.firmware.vm.operand_stack.iter()
|
||||
.rev().take(10).filter_map(|v| v.as_integer()).collect();
|
||||
|
||||
let resp = DebugResponse::State {
|
||||
pc: self.firmware.vm.pc,
|
||||
stack_top,
|
||||
frame_index: self.firmware.os.logical_frame_index,
|
||||
app_id: self.firmware.os.current_app_id,
|
||||
};
|
||||
self.send_debug_response(resp);
|
||||
}
|
||||
DebugCommand::SetBreakpoint { pc } => {
|
||||
self.firmware.vm.breakpoints.insert(pc);
|
||||
}
|
||||
DebugCommand::ListBreakpoints => {
|
||||
let pcs = self.firmware.vm.breakpoints.iter().cloned().collect();
|
||||
self.send_debug_response(DebugResponse::Breakpoints { pcs });
|
||||
}
|
||||
DebugCommand::ClearBreakpoint { pc } => {
|
||||
self.firmware.vm.breakpoints.remove(&pc);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn stream_debug_events(&mut self) {
|
||||
// Logs
|
||||
let new_events = self.firmware.os.log_service.get_after(self.debug_last_log_seq);
|
||||
for event in new_events {
|
||||
self.debug_last_log_seq = event.seq;
|
||||
|
||||
// Verifica se é um breakpoint hit via tag
|
||||
if event.tag == 0xDEB1 {
|
||||
self.send_debug_event(DebugEvent::BreakpointHit {
|
||||
pc: self.firmware.vm.pc,
|
||||
frame_index: self.firmware.os.logical_frame_index,
|
||||
});
|
||||
}
|
||||
|
||||
// Certificação via Tags 0xCA01-0xCA03
|
||||
if event.tag >= 0xCA01 && event.tag <= 0xCA03 {
|
||||
let rule = match event.tag {
|
||||
0xCA01 => "cycles_budget",
|
||||
0xCA02 => "max_syscalls",
|
||||
0xCA03 => "max_host_cpu_us",
|
||||
_ => "unknown"
|
||||
}.to_string();
|
||||
|
||||
self.send_debug_event(DebugEvent::Cert {
|
||||
rule,
|
||||
used: 0, // Simplificado, informações detalhadas estão na msg do log
|
||||
limit: 0,
|
||||
frame_index: self.firmware.os.logical_frame_index,
|
||||
});
|
||||
}
|
||||
|
||||
self.send_debug_event(DebugEvent::Log {
|
||||
level: format!("{:?}", event.level),
|
||||
source: format!("{:?}", event.source),
|
||||
msg: event.msg.clone(),
|
||||
});
|
||||
}
|
||||
|
||||
// Telemetria (a cada novo frame)
|
||||
let current_frame = self.firmware.os.logical_frame_index;
|
||||
if current_frame > self.debug_last_telemetry_frame {
|
||||
let tel = &self.firmware.os.telemetry_last;
|
||||
self.send_debug_event(DebugEvent::Telemetry {
|
||||
frame_index: tel.frame_index,
|
||||
vm_steps: tel.vm_steps,
|
||||
syscalls: tel.syscalls,
|
||||
cycles: tel.cycles_used,
|
||||
});
|
||||
self.debug_last_telemetry_frame = current_frame;
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn new(fs_root: Option<String>, cap_config: Option<CertificationConfig>) -> Self {
|
||||
@@ -94,6 +290,10 @@ impl PrometeuRunner {
|
||||
current_fps: 0.0,
|
||||
overlay_enabled: false,
|
||||
debug_waiting_for_start: false,
|
||||
debug_listener: None,
|
||||
debug_stream: None,
|
||||
debug_last_log_seq: 0,
|
||||
debug_last_telemetry_frame: 0,
|
||||
audio_load_accum_us: 0,
|
||||
audio_load_samples: 0,
|
||||
audio_perf_consumer: None,
|
||||
@@ -240,6 +440,7 @@ impl ApplicationHandler for PrometeuRunner {
|
||||
|
||||
if is_down && code == KeyCode::KeyD && self.debug_waiting_for_start {
|
||||
self.debug_waiting_for_start = false;
|
||||
self.debug_listener = None; // Fecha o socket
|
||||
println!("[Debugger] Execution started!");
|
||||
}
|
||||
|
||||
@@ -295,6 +496,8 @@ impl ApplicationHandler for PrometeuRunner {
|
||||
}
|
||||
|
||||
fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {
|
||||
self.check_debug_commands();
|
||||
|
||||
// Atualiza estado do Filesystem no OS (específico do host-desktop)
|
||||
if let Some(root) = &self.fs_root {
|
||||
use prometeu_core::fs::FsState;
|
||||
@@ -454,4 +657,56 @@ fn rgb565_to_rgb888(px: u16) -> (u8, u8, u8) {
|
||||
let b8 = (b5 << 3) | (b5 >> 2);
|
||||
|
||||
(r8, g8, b8)
|
||||
}
|
||||
}
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use prometeu_core::firmware::BootTarget;
|
||||
|
||||
#[test]
|
||||
fn test_debug_port_opens() {
|
||||
let mut runner = PrometeuRunner::new(None, None);
|
||||
let port = 9999;
|
||||
runner.set_boot_target(BootTarget::Cartridge {
|
||||
path: "dummy.bin".to_string(),
|
||||
debug: true,
|
||||
debug_port: port,
|
||||
});
|
||||
|
||||
assert!(runner.debug_waiting_for_start);
|
||||
assert!(runner.debug_listener.is_some());
|
||||
|
||||
// Verifica se conseguimos conectar
|
||||
use std::net::TcpStream;
|
||||
use std::io::{Write, Read};
|
||||
{
|
||||
let mut stream = TcpStream::connect(format!("127.0.0.1:{}", port)).expect("Deve conectar");
|
||||
// Pequeno sleep para garantir que o SO processe
|
||||
std::thread::sleep(std::time::Duration::from_millis(100));
|
||||
|
||||
// Simula o loop para aceitar a conexão
|
||||
runner.check_debug_commands();
|
||||
assert!(runner.debug_stream.is_some(), "Stream deve ter sido mantido aberto");
|
||||
|
||||
// Verifica Handshake
|
||||
let mut buf = [0u8; 2048];
|
||||
let n = stream.read(&mut buf).expect("Deve ler handshake");
|
||||
let resp: serde_json::Value = serde_json::from_slice(&buf[..n]).expect("Handshake deve ser JSON válido");
|
||||
assert_eq!(resp["type"], "handshake");
|
||||
|
||||
// Envia start via JSON
|
||||
stream.write_all(b"{\"type\":\"start\"}\n").expect("Conexão deve estar aberta para escrita");
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
|
||||
// Processa o comando recebido
|
||||
runner.check_debug_commands();
|
||||
assert!(!runner.debug_waiting_for_start, "Execução deve ter iniciado após comando start");
|
||||
assert!(runner.debug_listener.is_none(), "Listener deve ter sido fechado");
|
||||
}
|
||||
|
||||
// Agora que o stream saiu do escopo do teste, o runner deve detectar o fechamento no próximo check
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
runner.check_debug_commands();
|
||||
assert!(runner.debug_stream.is_none(), "Stream deve ter sido fechado após o cliente desconectar");
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user