feat: Output information to file

Author: Godones

kernel/src/debug/tracing/mod.rs

@@ -1,7 +1,9 @@
 mod events;
+pub mod trace_pipe;
 pub mod tracepoint;
 
 use crate::debug::sysfs::debugfs_kset;
+use crate::debug::tracing::trace_pipe::TRACE_PIPE_MAX_RECORD;
 use crate::driver::base::kobject::KObject;
 use crate::filesystem::kernfs::callback::{KernCallbackData, KernFSCallback};
 use crate::filesystem::kernfs::KernFSInode;
@@ -34,6 +36,16 @@ pub fn init_debugfs_tracing() -> Result<(), SystemError> {
         Some(&TracingDirCallBack),
     )?;
 
+    tracing_root.add_file(
+        "trace_pipe".to_string(),
+        ModeType::from_bits_truncate(0o444),
+        Some(TRACE_PIPE_MAX_RECORD),
+        None,
+        Some(&trace_pipe::TracePipeCallBack),
+    )?;
+
+    trace_pipe::init_trace_pipe();
+
     events::init_events(events_root)?;
 
     unsafe {

kernel/src/debug/tracing/trace_pipe.rs

@@ -0,0 +1,123 @@
+use crate::filesystem::kernfs::callback::{KernCallbackData, KernFSCallback};
+use crate::filesystem::vfs::PollStatus;
+use crate::libs::spinlock::SpinLock;
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::fmt::Debug;
+use system_error::SystemError;
+
+static mut TRACE_PIPE: Option<TracePipe> = None;
+
+pub const TRACE_PIPE_MAX_RECORD: usize = 4096;
+
+pub fn init_trace_pipe() {
+    unsafe {
+        TRACE_PIPE = Some(TracePipe::new(TRACE_PIPE_MAX_RECORD));
+    }
+}
+
+pub fn trace_pipe() -> &'static TracePipe {
+    unsafe { TRACE_PIPE.as_ref().unwrap() }
+}
+
+/// Push a record to trace pipe
+pub fn trace_pipe_push_record(record: String) {
+    trace_pipe().push_record(record);
+}
+
+pub struct TracePipe {
+    buf: SpinLock<TracePipeBuf>,
+}
+
+struct TracePipeBuf {
+    size: usize,
+    max_record: usize,
+    buf: Vec<String>,
+}
+
+impl TracePipeBuf {
+    pub const fn new(max_record: usize) -> Self {
+        Self {
+            max_record,
+            size: 0,
+            buf: Vec::new(),
+        }
+    }
+
+    pub fn push_str(&mut self, record: String) {
+        let record_size = record.len();
+        if self.size + record_size > self.max_record {
+            let mut i = 0;
+            while i < record_size {
+                let t = self.buf.pop().unwrap();
+                self.size -= t.len();
+                i += t.len();
+            }
+        }
+        self.buf.push(record);
+        self.size += record_size;
+    }
+
+    pub fn read_at(&self, buf: &mut [u8], offset: usize) -> Result<usize, SystemError> {
+        if offset == self.size {
+            return Ok(0);
+        }
+        if buf.len() < self.size {
+            return Err(SystemError::EINVAL);
+        }
+        let mut count = 0;
+        for line in self.buf.iter() {
+            let line = line.as_bytes();
+            buf[count..count + line.len()].copy_from_slice(line);
+            count += line.len();
+        }
+        Ok(count)
+    }
+}
+
+impl TracePipe {
+    pub const fn new(max_record: usize) -> Self {
+        Self {
+            buf: SpinLock::new(TracePipeBuf::new(max_record)),
+        }
+    }
+    pub fn push_record(&self, record: String) {
+        self.buf.lock().push_str(record);
+    }
+
+    pub fn read_at(&self, buf: &mut [u8], offset: usize) -> Result<usize, SystemError> {
+        self.buf.lock().read_at(buf, offset)
+    }
+}
+
+#[derive(Debug)]
+pub struct TracePipeCallBack;
+
+impl KernFSCallback for TracePipeCallBack {
+    fn open(&self, _data: KernCallbackData) -> Result<(), SystemError> {
+        Ok(())
+    }
+
+    fn read(
+        &self,
+        _data: KernCallbackData,
+        buf: &mut [u8],
+        offset: usize,
+    ) -> Result<usize, SystemError> {
+        let trace_pipe = trace_pipe();
+        trace_pipe.read_at(buf, offset)
+    }
+
+    fn write(
+        &self,
+        _data: KernCallbackData,
+        _buf: &[u8],
+        _offset: usize,
+    ) -> Result<usize, SystemError> {
+        Err(SystemError::EPERM)
+    }
+
+    fn poll(&self, _data: KernCallbackData) -> Result<PollStatus, SystemError> {
+        Ok(PollStatus::READ)
+    }
+}

kernel/src/debug/tracing/tracepoint.rs

@@ -151,10 +151,11 @@ macro_rules! define_trace_point {
 
 #[macro_export]
 macro_rules! define_event_trace{
-     ($name:ident,$($arg:ident:$arg_type:ty),*, $print:literal) => {
-         define_trace_point!($name,$($arg:$arg_type),*);
-
-         paste::paste!{
+    ($name:ident,
+        ($($arg:ident:$arg_type:ty),*),
+        $fmt:expr) =>{
+        define_trace_point!($name,$($arg:$arg_type),*);
+        paste::paste!{
             #[derive(Debug)]
             #[repr(C)]
             #[allow(non_snake_case)]
@@ -171,8 +172,12 @@ macro_rules! define_event_trace{
                 print_func:[<trace_print_ $name>],
             };
             pub fn [<trace_print_ $name>](_data:&mut (dyn core::any::Any+Send+Sync),$($arg:$arg_type),* ){
-                println!($print $(,$arg)*);
+                 let time = $crate::time::Instant::now();
+                 let cpu_id = $crate::arch::cpu::current_cpu_id().data();
+                 let current_pid = $crate::process::ProcessManager::current_pcb().pid().data();
+                 let format = format!("[{}][{}][{}] {}\n",time,cpu_id,current_pid,$fmt);
+                 $crate::debug::tracing::trace_pipe::trace_pipe_push_record(format);
             }
         }
-     }
+    };
 }

kernel/src/filesystem/vfs/core.rs

@@ -156,7 +156,7 @@ pub fn mount_root_fs() -> Result<(), SystemError> {
     let fatfs: Arc<FATFileSystem> = fatfs.unwrap();
     let r = migrate_virtual_filesystem(fatfs);
     if r.is_err() {
-        error!("Failed to migrate virtual filesystem to FAT32!");
+        error!("Failed to migrate virtual filesyst  em to FAT32!");
         loop {
             spin_loop();
         }
@@ -166,8 +166,8 @@ pub fn mount_root_fs() -> Result<(), SystemError> {
     return Ok(());
 }
 
-define_event_trace!(do_mkdir_at,path:&str,mode:FileMode,"mkdir at {} with mode {:?}");
-
+define_event_trace!(do_mkdir_at,(path:&str,mode:FileMode),
+    format_args!("mkdir at {} with mode {:?}",path, mode));
 /// @brief 创建文件/文件夹
 pub fn do_mkdir_at(
     dirfd: i32,