Kernel: Add magic key combo (Alt+Shift+F12) to dump scheduler state

Pressing this combo will dump a list of all threads and their state
to the debug console.

This might be useful to figure out why the system is not responding.

Kernel/Devices/HID/PS2KeyboardDevice.cpp

@@ -53,6 +53,11 @@ void PS2KeyboardDevice::irq_handle_byte_read(u8 byte)
  return;
  }
 
+ if (m_modifiers == (Mod_Alt | Mod_Shift) && byte == 0x58) {
+ // Alt+Shift+F12 pressed, dump some kernel state to the debug console.
+ Scheduler::dump_scheduler_state();
+ }
+
  dbgln_if(KEYBOARD_DEBUG, "Keyboard::irq_handle_byte_read: {:#02x} {}", ch, (pressed ? "down" : "up"));
  switch (ch) {
  case 0x38:

Kernel/Scheduler.cpp

@@ -79,6 +79,7 @@ static SpinLock<u8> g_ready_queues_lock;
 static u32 g_ready_queues_mask;
 static constexpr u32 g_ready_queue_buckets = sizeof(g_ready_queues_mask) * 8;
 READONLY_AFTER_INIT static ThreadReadyQueue* g_ready_queues; // g_ready_queue_buckets entries
+static void dump_thread_list();
 
 static inline u32 thread_priority_to_priority_index(u32 thread_priority)
 {
@@ -235,29 +236,7 @@ bool Scheduler::pick_next()
  }
 
  if constexpr (SCHEDULER_RUNNABLE_DEBUG) {
- dbgln("Scheduler thread list for processor {}:", Processor::id());
- Thread::for_each([&](Thread& thread) -> IterationDecision {
- switch (thread.state()) {
- case Thread::Dying:
- dbgln(" {:12} {} @ {:04x}:{:08x} Finalizable: {}",
- thread.state_string(),
- thread,
- thread.tss().cs,
- thread.tss().eip,
- thread.is_finalizable());
- break;
- default:
- dbgln(" {:12} Pr:{:2} {} @ {:04x}:{:08x}",
- thread.state_string(),
- thread.priority(),
- thread,
- thread.tss().cs,
- thread.tss().eip);
- break;
- }
-
- return IterationDecision::Continue;
- });
+ dump_thread_list();
  }
 
  auto pending_beneficiary = scheduler_data.m_pending_beneficiary.strong_ref();
@@ -633,4 +612,51 @@ void Scheduler::idle_loop(void*)
  }
 }
 
+void Scheduler::dump_scheduler_state()
+{
+ dump_thread_list();
+}
+
+void dump_thread_list()
+{
+ dbgln("Scheduler thread list for processor {}:", Processor::id());
+
+ auto get_cs = [](Thread& thread) -> u16 {
+ if (!thread.current_trap())
+ return thread.tss().cs;
+ return thread.get_register_dump_from_stack().cs;
+ };
+
+ auto get_eip = [](Thread& thread) -> u32 {
+ if (!thread.current_trap())
+ return thread.tss().eip;
+ return thread.get_register_dump_from_stack().eip;
+ };
+
+ Thread::for_each([&](Thread& thread) -> IterationDecision {
+ switch (thread.state()) {
+ case Thread::Dying:
+ dbgln(" {:14} {:30} @ {:04x}:{:08x} Finalizable: {}, (nsched: {})",
+ thread.state_string(),
+ thread,
+ get_cs(thread),
+ get_eip(thread),
+ thread.is_finalizable(),
+ thread.times_scheduled());
+ break;
+ default:
+ dbgln(" {:14} Pr:{:2} {:30} @ {:04x}:{:08x} (nsched: {})",
+ thread.state_string(),
+ thread.priority(),
+ thread,
+ get_cs(thread),
+ get_eip(thread),
+ thread.times_scheduled());
+ break;
+ }
+
+ return IterationDecision::Continue;
+ });
+}
+
 }

Kernel/Scheduler.h

@@ -70,6 +70,7 @@ class Scheduler {
  static Thread& pull_next_runnable_thread();
  static bool dequeue_runnable_thread(Thread&, bool = false);
  static void queue_runnable_thread(Thread&);
+ static void dump_scheduler_state();
 };
 
 }