Print who and on which CPU the kernel panics

kernel/src/thread/mod.rs

@@ -25,6 +25,7 @@ pub mod work_queue;
 pub type Tid = u32;
 
 /// A thread is a wrapper on top of task.
+#[derive(Debug)]
 pub struct Thread {
     // immutable part
     /// Low-level info

kernel/src/thread/oops.rs

@@ -22,7 +22,7 @@ use core::{
     sync::atomic::{AtomicBool, AtomicUsize, Ordering},
 };
 
-use ostd::panic;
+use ostd::{cpu::PinCurrentCpu, panic, task::disable_preempt};
 
 use super::Thread;
 
@@ -97,16 +97,27 @@ fn panic_handler(info: &core::panic::PanicInfo) -> ! {
         }
     }
 
+    let preempt_guard = disable_preempt();
+    let thread = Thread::current();
+    let cpu = preempt_guard.current_cpu();
+
     // Halt the system if the panic is not caught.
     if let Some(location) = info.location() {
         log::error!(
-            "Uncaught panic: {}\nat {}:{}",
+            "Uncaught panic:\n\t{}\n\tat {}:{}\n\ton CPU {} by thread {:?}",
             message,
             location.file(),
             location.line(),
+            cpu.as_usize(),
+            thread,
         );
     } else {
-        log::error!("Uncaught panic: {}", message);
+        log::error!(
+            "Uncaught panic:\n\t{}\n\ton CPU {} by thread {:?}",
+            message,
+            cpu.as_usize(),
+            thread,
+        );
     }
 
     if info.can_unwind() {

ostd/src/task/mod.rs

@@ -26,6 +26,7 @@ use crate::{prelude::*, user::UserSpace};
 /// Each task is associated with per-task data and an optional user space.
 /// If having a user space, the task can switch to the user space to
 /// execute user code. Multiple tasks can share a single user space.
+#[derive(Debug)]
 pub struct Task {
     func: SyncUnsafeCell<Option<Box<dyn FnOnce() + Send + Sync>>>,
     data: Box<dyn Any + Send + Sync>,

ostd/src/task/scheduler/info.rs

@@ -14,12 +14,14 @@ use crate::{cpu::CpuId, task::Task};
 /// define them, such as
 /// [existential types](https://github.com/rust-lang/rfcs/pull/2492) do not
 /// exist yet. So we decide to define them in OSTD.
+#[derive(Debug)]
 pub struct TaskScheduleInfo {
     /// The CPU that the task would like to be running on.
     pub cpu: AtomicCpuId,
 }
 
 /// An atomic CPUID container.
+#[derive(Debug)]
 pub struct AtomicCpuId(AtomicU32);
 
 impl AtomicCpuId {