Adds support for kernel symbol dumping via kallsyms

os/StarryOS/kernel/Cargo.toml

@@ -138,6 +138,7 @@ sg200x-bsp = { workspace = true, optional = true }
 # because Writeable trait must come from the same version as sg200x-bsp's types.
 tock-registers = { version = "0.9", optional = true }
 ktracepoint = "0.6"
+ksym = "0.6"
 
 [target.'cfg(target_arch = "x86_64")'.dependencies]
 x86 = "0.52"

os/StarryOS/kernel/src/pseudofs/dev/mod.rs

@@ -269,7 +269,7 @@ fn builder(fs: Arc<SimpleFs>) -> DirMaker {
     #[cfg(feature = "dev-log")]
     root.add(
         "log",
-        crate::pseudofs::SimpleFile::new(fs.clone(), NodeType::Socket, || Ok(b"")),
+        crate::pseudofs::SimpleFile::new(fs.clone(), NodeType::Socket, || Ok("")),
     );
 
     #[cfg(feature = "memtrack")]

os/StarryOS/kernel/src/pseudofs/file.rs

@@ -1,4 +1,4 @@
-use alloc::{borrow::Cow, sync::Arc, vec::Vec};
+use alloc::{borrow::Cow, string::String, sync::Arc, vec::Vec};
 use core::{any::Any, cmp::Ordering, task::Context};
 
 use ax_sync::Mutex;
@@ -16,7 +16,9 @@ pub trait SimpleFileOps: Send + Sync + 'static {
     /// Reads all content in the file.
     fn read_all(&self) -> VfsResult<Cow<'_, [u8]>>;
     /// Replaces the file's content with `data`.
-    fn write_all(&self, data: &[u8]) -> VfsResult<()>;
+    fn write_all(&self, _data: &[u8]) -> VfsResult<()> {
+        Err(VfsError::BadFileDescriptor)
+    }
 }
 
 /// Type representing operation applied to a simple file.
@@ -56,17 +58,42 @@ where
     }
 }
 
+pub trait SimpleFileContent {
+    /// Converts the content into bytes.
+    fn into_content(self) -> Cow<'static, [u8]>;
+}
+
+impl SimpleFileContent for Vec<u8> {
+    fn into_content(self) -> Cow<'static, [u8]> {
+        Cow::Owned(self)
+    }
+}
+
+impl SimpleFileContent for String {
+    fn into_content(self) -> Cow<'static, [u8]> {
+        Cow::Owned(self.into_bytes())
+    }
+}
+
+impl SimpleFileContent for &'static str {
+    fn into_content(self) -> Cow<'static, [u8]> {
+        Cow::Borrowed(self.as_bytes())
+    }
+}
+
+impl SimpleFileContent for &'static [u8] {
+    fn into_content(self) -> Cow<'static, [u8]> {
+        Cow::Borrowed(self)
+    }
+}
+
 impl<F, R> SimpleFileOps for F
 where
     F: Fn() -> VfsResult<R> + Send + Sync + 'static,
-    R: Into<Vec<u8>>,
+    R: SimpleFileContent,
 {
     fn read_all(&self) -> VfsResult<Cow<'_, [u8]>> {
-        (self)().map(|it| Cow::Owned(it.into()))
-    }
-
-    fn write_all(&self, _data: &[u8]) -> VfsResult<()> {
-        Err(VfsError::BadFileDescriptor)
+        Ok((self)()?.into_content())
     }
 }
 
@@ -262,8 +289,8 @@ impl<T: DirectRwFsFileOps> FileNodeOps for SpecialFsFile<T> {
     }
 
     fn append(&self, buf: &[u8]) -> VfsResult<(usize, u64)> {
-        self.ops.write_at(buf, 0)?;
-        Ok((buf.len(), 0))
+        let w = self.ops.write_at(buf, 0)?;
+        Ok((w, 0))
     }
 
     fn set_len(&self, len: u64) -> VfsResult<()> {

os/StarryOS/kernel/src/pseudofs/proc.rs

@@ -14,13 +14,15 @@ use core::{
     sync::atomic::{AtomicUsize, Ordering},
 };
 
+use ax_lazyinit::LazyInit;
 use ax_memory_addr::PAGE_SIZE_4K;
 use ax_runtime::hal::{
     paging::MappingFlags,
     time::{monotonic_time, wall_time},
 };
 use ax_task::{AxCpuMask, AxTaskRef, TaskState, WeakAxTaskRef, current};
 use axfs_ng_vfs::{DeviceId, Filesystem, NodePermission, NodeType, VfsError, VfsResult};
+use ksym::KallsymsMapped;
 use starry_process::{Pid, Process};
 
 use crate::{
@@ -41,6 +43,36 @@ use crate::{
 static IRQ_CNT: AtomicUsize = AtomicUsize::new(0);
 const PROCFS_INIT_PID: Pid = 1;
 
+pub static KALLSYMS: LazyInit<KallsymsMapped<'static>> = LazyInit::new();
+
+fn read_kallsyms() -> KallsymsMapped<'static> {
+    unsafe extern "C" {
+        fn _stext();
+        fn _etext();
+        fn __kallsyms_start();
+        fn __kallsyms_end();
+    }
+
+    let kallsyms_start = __kallsyms_start as *const () as usize;
+    let kallsyms_end = __kallsyms_end as *const () as usize;
+    let kallsyms_sec_size = kallsyms_end - kallsyms_start;
+    let kallsyms_sec =
+        unsafe { core::slice::from_raw_parts(__kallsyms_start as *const u8, kallsyms_sec_size) };
+
+    let total_size =
+        KallsymsMapped::check_total_bytes(kallsyms_sec).expect("Invalid kallsyms format");
+
+    let kallsyms = &kallsyms_sec[..total_size as usize];
+    // TODO: recycle unused space in .kallsyms section
+    info!("Read kallsyms, size: {}KB", kallsyms.len() / 1024);
+    KallsymsMapped::from_blob(
+        kallsyms,
+        _stext as *const () as u64,
+        _etext as *const () as u64,
+    )
+    .expect("Failed to create KallsymsMapped")
+}
+
 fn procfs_visible_pid(proc: &Arc<Process>) -> Pid {
     if proc.is_init() {
         PROCFS_INIT_PID
@@ -961,6 +993,23 @@ fn builder(fs: Arc<SimpleFs>) -> DirMaker {
         SimpleDir::new_maker(fs.clone(), Arc::new(dynamic_debug))
     });
 
+    static ALL_SYMS: LazyInit<String> = LazyInit::new();
+
+    let ksym = read_kallsyms();
+    KALLSYMS.init_once(ksym);
+
+    root.add("kallsyms", {
+        if !ALL_SYMS.is_inited() {
+            ALL_SYMS.init_once(KALLSYMS.dump_all_symbols());
+        }
+        let seq_obj = SeqObject::new(|| Ok(ALL_SYMS.as_str()));
+        SpecialFsFile::new_regular_with_perm(
+            fs.clone(),
+            seq_obj,
+            NodePermission::from_bits_truncate(0o444),
+        )
+    });
+
     let proc_dir = ProcFsHandler(fs.clone());
     SimpleDir::new_maker(fs, Arc::new(proc_dir.chain(root)))
 }

os/StarryOS/starryos/ext_linker.ld

@@ -16,6 +16,12 @@ SECTIONS {
         KEEP(*(.tracepoint .tracepoint.*))
         __stop_tracepoint = .;
     }
+
+    .kallsyms : ALIGN(4K) {
+        __kallsyms_start = .;
+        . += 8M; /* reserve space for kallsyms, can be recycled */
+        __kallsyms_end = .;
+    }
 }
 
-INSERT AFTER .data;
+INSERT AFTER .data;

scripts/axbuild/scripts/starry-kallsyms.sh

@@ -0,0 +1,104 @@
+#!/usr/bin/env sh
+set -eu
+
+auto_install_enabled() {
+    case "${AXBUILD_STARRY_KALLSYMS_AUTO_INSTALL:-1}" in
+        0 | n | no | false | off) return 1 ;;
+        *) return 0 ;;
+    esac
+}
+
+install_rust_binutils() {
+    if ! auto_install_enabled; then
+        echo "rust-nm and rust-objcopy are required for Starry kallsyms generation" >&2
+        echo "install them with: rustup component add llvm-tools-preview && cargo install cargo-binutils" >&2
+        exit 1
+    fi
+
+    echo "Installing rust-nm and rust-objcopy (cargo-binutils)..." >&2
+    if command -v rustup >/dev/null 2>&1; then
+        rustup component add llvm-tools-preview
+    fi
+    cargo install cargo-binutils
+}
+
+ensure_llvm_tools() {
+    if command -v rust-nm >/dev/null 2>&1 \
+        && command -v rust-objcopy >/dev/null 2>&1 \
+        && rust-nm --version >/dev/null 2>&1 \
+        && rust-objcopy --version >/dev/null 2>&1; then
+        return
+    fi
+
+    if ! command -v rustup >/dev/null 2>&1; then
+        return
+    fi
+    if rustup component list --installed | grep -q '^llvm-tools'; then
+        return
+    fi
+
+    if ! auto_install_enabled; then
+        echo "llvm-tools-preview is required for rust-nm and rust-objcopy" >&2
+        echo "install it with: rustup component add llvm-tools-preview" >&2
+        exit 1
+    fi
+
+    echo "Installing llvm-tools-preview via rustup..." >&2
+    rustup component add llvm-tools-preview
+}
+
+install_ksym() {
+    if ! auto_install_enabled; then
+        echo "gen_ksym is required for Starry kallsyms generation" >&2
+        echo "install it with: cargo install ksym" >&2
+        exit 1
+    fi
+
+    echo "Installing ksym (gen_ksym) via cargo..." >&2
+    cargo install ksym
+}
+
+ensure_tools() {
+    ensure_llvm_tools
+
+    if ! command -v rust-nm >/dev/null 2>&1 || ! command -v rust-objcopy >/dev/null 2>&1; then
+        install_rust_binutils
+    fi
+    if ! command -v gen_ksym >/dev/null 2>&1; then
+        install_ksym
+    fi
+
+    command -v rust-nm >/dev/null 2>&1
+    command -v rust-objcopy >/dev/null 2>&1
+    command -v gen_ksym >/dev/null 2>&1
+}
+
+generate_kallsyms() {
+    symbols=$(mktemp "${KERNEL_ELF}.symbols.XXXXXX")
+    kallsyms=$(mktemp "${KERNEL_ELF}.kallsyms.XXXXXX")
+    trap 'rm -f "$symbols" "$kallsyms"' EXIT
+
+    rust-nm -n "$KERNEL_ELF" > "$symbols"
+    grep ' [TtDBR] ' "$symbols" \
+        | awk '$3 !~ /^\.L/' \
+        | awk '$3 != "$x"' \
+        | gen_ksym > "$kallsyms"
+
+    rust-objcopy --update-section .kallsyms="$kallsyms" "$KERNEL_ELF"
+}
+
+refresh_bin_if_present() {
+    bin="${KERNEL_ELF%.elf}.bin"
+    if [ -f "$bin" ]; then
+        rust-objcopy --strip-all -O binary "$KERNEL_ELF" "$bin"
+    fi
+}
+
+if [ -z "${KERNEL_ELF:-}" ]; then
+    echo "KERNEL_ELF is required for Starry kallsyms generation" >&2
+    exit 1
+fi
+
+ensure_tools
+generate_kallsyms
+refresh_bin_if_present

scripts/axbuild/src/arceos/test.rs

@@ -1634,7 +1634,6 @@ mod tests {
                 env: Default::default(),
                 target: "x86_64-unknown-none".to_string(),
                 package: package.to_string(),
-                bin: None,
                 features: Vec::new(),
                 log: None,
                 extra_config: None,
@@ -1644,6 +1643,7 @@ mod tests {
                 pre_build_cmds: Vec::new(),
                 post_build_cmds: Vec::new(),
                 to_bin: false,
+                bin: None,
             },
             qemu: QemuConfig::default(),
         }

scripts/axbuild/src/build.rs

@@ -159,7 +159,6 @@ impl BuildInfo {
             env: self.env,
             target,
             package,
-            bin: None,
             features: self.features,
             log: Some(self.log),
             extra_config: None,
@@ -169,6 +168,7 @@ impl BuildInfo {
             pre_build_cmds: vec![],
             post_build_cmds: vec![],
             to_bin,
+            bin: None,
         }
     }