Adds panic handler

Author: ultimaweapon

.github/workflows/ci.yml

@@ -16,4 +16,6 @@ jobs:
     - name: Check Rust styles
       run: cargo fmt --check
     - name: Lint
-      run: cargo clippy -- -D warnings
+      run: cargo clippy --workspace -- -D warnings
+    - name: Run tests
+      run: cargo test --workspace

Cargo.toml

@@ -3,9 +3,6 @@ name = "okf"
 version = "0.1.0"
 edition = "2024"
 
-[lints.rust]
-unexpected_cfgs = { level = "deny", check-cfg = ['cfg(fw, values("1100"))'] }
-
 [dependencies]
 bitflags = "2.5.0"
 okf-macros = { version = "0.1.0", path = "macros" }

macros/src/lib.rs

@@ -3,7 +3,6 @@ use syn::{Error, ItemStruct, LitInt, TraitItem, parse_macro_input};
 
 mod derive;
 mod offset;
-mod panic_handler;
 
 #[proc_macro_derive(MappedKernel)]
 pub fn derive_mapped_kernel(item: TokenStream) -> TokenStream {
@@ -23,12 +22,3 @@ pub fn offset(args: TokenStream, item: TokenStream) -> TokenStream {
         .unwrap_or_else(Error::into_compile_error)
         .into()
 }
-
-#[proc_macro]
-pub fn panic_handler(args: TokenStream) -> TokenStream {
-    let args = parse_macro_input!(args as LitInt);
-
-    self::panic_handler::transform(args)
-        .unwrap_or_else(Error::into_compile_error)
-        .into()
-}

macros/src/panic_handler.rs

@@ -18,7 +18,7 @@ use okf::malloc::MallocFlags;
 use okf::queue::TailQueue;
 use okf::socket::SockAddr;
 use okf::uio::UioSeg;
-use okf::{Function, MappedKernel, StaticMut, offset, panic_handler};
+use okf::{Function, MappedKernel, StaticMut, offset};
 
 mod file;
 mod lock;
@@ -55,7 +55,7 @@ impl okf::Kernel for Kernel {
     const MOUNTLIST_MTX: StaticMut<Self::Mtx>;
     const NOCPU: u32 = 0xff;
     #[offset(0x1987C0)]
-    const PANIC: Function<extern "C" fn(*const c_char, ...) -> !>;
+    const PANIC: Function<unsafe extern "C" fn(*const c_char, ...) -> !>;
     const VDIR: c_int = 2;
     #[offset(0x15308F0)]
     const VOP_LOOKUP: StaticMut<Self::VnodeOp>;
@@ -221,5 +221,3 @@ impl okf::Kernel for Kernel {
 
 unsafe impl Send for Kernel {}
 unsafe impl Sync for Kernel {}
-
-panic_handler!(0x1987C0);

ps4-1100/build.rs

@@ -29,6 +29,7 @@ pub mod malloc;
 pub mod mount;
 pub mod namei;
 pub mod notification;
+pub mod panic;
 pub mod pcpu;
 pub mod queue;
 pub mod socket;
@@ -37,14 +38,6 @@ pub mod ucred;
 pub mod uio;
 pub mod vnode;
 
-#[cfg(fw = "1100")]
-#[macro_export]
-macro_rules! kernel {
-    () => {
-        okf_1100::Kernel
-    };
-}
-
 /// Provides methods to access the PS4 kernel for a specific version.
 ///
 /// All methods here are a direct call to the kernel so most of them are unsafe and hard to use.
@@ -63,7 +56,7 @@ pub trait Kernel: MappedKernel {
     const MOUNTLIST: StaticMut<TailQueue<Self::Mount>>;
     const MOUNTLIST_MTX: StaticMut<Self::Mtx>;
     const NOCPU: u32;
-    const PANIC: Function<extern "C" fn(*const c_char, ...) -> !>;
+    const PANIC: Function<unsafe extern "C" fn(*const c_char, ...) -> !>;
     const VDIR: c_int;
     const VOP_LOOKUP: StaticMut<Self::VnodeOp>;
     const VOP_READ: StaticMut<Self::VnodeOp>;
@@ -397,7 +390,9 @@ impl<T> Offset for StaticMut<T> {
     }
 }
 
-/// Implementation of [`StaticOps`] for [`StaticMut`].
+/// Implementation of [`OffsetOps`] for [`StaticMut`].
+///
+/// This type does not implement [DerefMut](core::ops::DerefMut) by design.
 pub struct MutableOps<T>(*mut T);
 
 impl<T> MutableOps<T> {
@@ -462,7 +457,7 @@ impl<T: KernelFn> Clone for Function<T> {
 impl<T: KernelFn> Copy for Function<T> {}
 
 impl<T: KernelFn> Offset for Function<T> {
-    type Ops = ImmutableOps<T>;
+    type Ops = FunctionOps<T>;
 
     fn get(self) -> usize {
         self.off
@@ -506,7 +501,7 @@ pub trait KernelFn: Copy {
     unsafe fn from_addr(addr: *const u8) -> Self;
 }
 
-impl<R, A1> KernelFn for extern "C" fn(A1, ...) -> R {
+impl<R, A1> KernelFn for unsafe extern "C" fn(A1, ...) -> R {
     unsafe fn from_addr(addr: *const u8) -> Self {
         unsafe { transmute(addr) }
     }

ps4-1100/src/lib.rs

@@ -0,0 +1,17 @@
+use self::msg::Message;
+use crate::Kernel;
+use core::fmt::Write;
+use core::panic::PanicInfo;
+
+mod msg;
+
+pub fn panic<K: Kernel>(k: K, i: &PanicInfo) -> ! {
+    // Write panic message.
+    let mut m = Message::default();
+    let _ = write!(m, "{i}");
+
+    // Invoke panic function.
+    let f = k.get(K::PANIC).as_ptr();
+
+    unsafe { f(c"%s".as_ptr(), m.as_ptr()) };
+}

src/lib.rs

@@ -0,0 +1,59 @@
+use core::cmp::min;
+use core::ffi::c_char;
+use core::fmt::Write;
+
+/// Provides [`Write`] implementation backed by a fixed size buffer.
+pub struct Message {
+    buf: [u8; 2048],
+    pos: usize,
+}
+
+impl Message {
+    pub fn as_ptr(&self) -> *const c_char {
+        self.buf.as_ptr().cast()
+    }
+}
+
+impl Default for Message {
+    fn default() -> Self {
+        Self {
+            buf: [0; 2048],
+            pos: 0,
+        }
+    }
+}
+
+impl Write for Message {
+    fn write_str(&mut self, s: &str) -> core::fmt::Result {
+        // This method need to be careful not to cause any panic so we don't end up nested panic.
+        let len = min(s.len(), (self.buf.len() - 1) - self.pos);
+        let buf = unsafe { self.buf.as_mut_ptr().add(self.pos) };
+
+        unsafe { buf.copy_from_nonoverlapping(s.as_ptr(), len) };
+        self.pos += len;
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn write_str() {
+        let mut m = Message::default();
+
+        write!(m, "Hello, world!").unwrap();
+
+        assert!(m.buf.as_slice().starts_with(b"Hello, world!\0"));
+
+        // Make sure repeated write on a full buffer won't do anything.
+        for _ in 0..m.buf.len() {
+            write!(m, "Hello, world!").unwrap();
+        }
+
+        assert!(m.buf.as_slice().starts_with(b"Hello, world!Hello"));
+        assert_eq!(m.buf.last().copied().unwrap(), 0);
+    }
+}