Adding log-tail capability to dsp-to-serial

Author: pdscomp

dsp-to-serial/src/main.rs

@@ -5,7 +5,7 @@ use std::{
 use serialport::{SerialPort, TTYPort};
 
 use crate::{
-    communication_handler::CommunicationHandler, kbuf::{kbuf_use_new_buf}, msgbox::MsgboxEndpoint, sharespace::{sharespace_mmap}
+    communication_handler::CommunicationHandler, kbuf::{kbuf_use_new_buf}, msgbox::MsgboxEndpoint, sharespace::{sharespace_mmap, mmap_log_buffer}
 };
 
 mod error;
@@ -15,6 +15,42 @@ mod sharespace;
 mod util;
 mod communication_handler;
 
+fn log_tail_thread() {
+    let log_buffer = mmap_log_buffer();
+
+    println!("Log buffer mapped at: {:p}", log_buffer.as_ptr());
+
+    let mut read_ptr = 4;
+
+    loop {
+        let write_ptr = u32::from_le_bytes(log_buffer[0..4].try_into().unwrap()) as usize;
+
+        if write_ptr == read_ptr {
+            std::thread::sleep(Duration::from_millis(100));
+            continue;
+        }
+
+        let process_buffer = |buffer: &[u8]| {
+            for message in buffer.split(|&b| b == 0) {
+                if !message.is_empty() {
+                    println!("DSP_log: {}", String::from_utf8_lossy(message).trim_end());
+                }
+            }
+        };
+
+        if write_ptr > read_ptr {
+            process_buffer(&log_buffer[read_ptr..write_ptr]);
+        } else { // write_ptr < read_ptr, wrapped around
+            process_buffer(&log_buffer[read_ptr..]);
+            process_buffer(&log_buffer[4..write_ptr]);
+        }
+        
+        read_ptr = write_ptr;
+
+        std::thread::sleep(Duration::from_millis(100));
+    }
+}
+
 fn read_dsp(msgbox : &mut MsgboxEndpoint, handler : &mut CommunicationHandler, port: &mut TTYPort) {
     if !msgbox.msgbox_has_signal()
     {
@@ -72,6 +108,9 @@ fn write_dsp(msgbox : &mut MsgboxEndpoint, handler : &mut CommunicationHandler,
 
 fn main() {
     println!("Hello, world!");
+
+    std::thread::spawn(log_tail_thread);
+
     let mmap = sharespace_mmap();
     println!("Got sharespace mmap!");
     let kbuf = kbuf_use_new_buf(mmap.dsp_sharespace.arm_write_addr).unwrap();

dsp-to-serial/src/sharespace.rs

@@ -1,13 +1,13 @@
 use std::os::fd::{AsRawFd, OwnedFd};
 
-use memmap2::{MmapMut, MmapOptions};
+use memmap2::{Mmap, MmapMut, MmapOptions};
 use nix::{errno::Errno, fcntl::{open, OFlag}, ioctl_readwrite_bad, sys::stat::Mode};
 
 use crate::util::wrap_ioctl_negative_invalid;
 
 #[repr(C)]
 #[derive(Default, Debug)]
-struct DebugMessage {
+pub struct DebugMessage {
     pub sys_cnt: u32,
     pub log_head_addr: u32,
     pub log_end_addr: u32,
@@ -33,16 +33,17 @@ pub struct DspSharespace {
     pub debug_msg: DebugMessage,
 }
 
-#[derive(Debug)]
-enum ChooseShareSpace {
+#[derive(Debug, Clone, Copy)]
+pub enum ChooseShareSpace {
     ChooseDspWriteSpace = 0,
     ChooseArmWriteSpace = 1,
+    ChooseLogSpace = 2,
 }
 
 ioctl_readwrite_bad!(read_debug_message, 0x01, DspSharespace);
 ioctl_readwrite_bad!(write_debug_message, 0x03, DspSharespace);
 
-fn choose_sharespace(
+pub fn choose_sharespace(
     fd: &OwnedFd,
     msg: &mut DspSharespace,
     choose: ChooseShareSpace,
@@ -53,7 +54,15 @@ fn choose_sharespace(
     msg.mmap_phy_addr = match choose {
         ChooseShareSpace::ChooseDspWriteSpace => msg.dsp_write_addr,
         ChooseShareSpace::ChooseArmWriteSpace => msg.arm_write_addr,
+        ChooseShareSpace::ChooseLogSpace => msg.dsp_log_addr,
     };
+    
+    msg.mmap_phy_size = match choose {
+        ChooseShareSpace::ChooseDspWriteSpace => msg.dsp_write_size,
+        ChooseShareSpace::ChooseArmWriteSpace => msg.arm_write_size,
+        ChooseShareSpace::ChooseLogSpace => msg.dsp_log_size,
+    };
+
 
     println!("Init sharespace {:?} to 0x{:x}", choose, msg.mmap_phy_addr);
 
@@ -62,16 +71,30 @@ fn choose_sharespace(
     Ok(())
 }
 
-fn sharespace_open() -> Result<OwnedFd, Errno> {
+pub fn sharespace_open() -> Result<OwnedFd, Errno> {
     open(
         "/dev/dsp_debug",
         OFlag::O_RDWR | OFlag::O_SYNC | OFlag::O_NONBLOCK,
         Mode::empty(),
     )
 }
 
+pub fn mmap_log_buffer() -> Mmap {
+    let mut dsp_sharespace = DspSharespace::default();
+    let fd = sharespace_open().unwrap();
+
+    choose_sharespace(
+        &fd,
+        &mut dsp_sharespace,
+        ChooseShareSpace::ChooseLogSpace,
+    )
+    .unwrap();
+
+    unsafe { MmapOptions::new().len(dsp_sharespace.dsp_log_size as usize).map(&fd).unwrap() }
+}
+
 pub struct Sharespace {
-    fd: OwnedFd,
+    pub fd: OwnedFd,
     pub dsp_sharespace: DspSharespace,
     pub write_buffer: MmapMut, // ARM buffer - pu8ArmBuf
 }
@@ -87,7 +110,7 @@ pub fn sharespace_mmap() -> Sharespace {
     )
     .unwrap();
 
-    let write_buffer = unsafe { MmapOptions::new().len(0x1000).map_mut(&fd).unwrap() };
+    let write_buffer = unsafe { MmapOptions::new().len(dsp_sharespace.mmap_phy_size as usize).map_mut(&fd).unwrap() };
 
     Sharespace {
         fd,