add debugger

This commit is contained in:
2026-03-24 13:40:16 +00:00
parent 71bb007499
commit cd68bb0d0a
10 changed files with 506 additions and 24 deletions
+2 -1
View File
@@ -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"
+25 -9
View File
@@ -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);
+264 -9
View File
@@ -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");
}
}