Kernel: Don't run non-essential trap exit steps for low-level exceptions

If there's a higher level trap, then that should take care of signal
dispatching, scheduling, etc. when it exits its own trap frame.

Author: implicitfield

Kernel/Arch/Processor.cpp

@@ -265,7 +265,7 @@ ErrorOr<Vector<FlatPtr, 32>> ProcessorBase::capture_stack_trace(Thread& thread,
     return stack_trace;
 }
 
-void ProcessorBase::exit_trap(TrapFrame& trap)
+void ProcessorBase::exit_trap(TrapFrame& trap, bool handling_exception)
 {
     VERIFY_INTERRUPTS_DISABLED();
     VERIFY(&Processor::current() == this);
@@ -277,23 +277,30 @@ void ProcessorBase::exit_trap(TrapFrame& trap)
     // ScopedCritical here.
     m_in_critical = m_in_critical + 1;
 
-    m_in_irq = 0;
+    // Don't clear m_in_irq yet if we're still handling a lower-level
+    // exception.
+    if (m_in_irq && !handling_exception)
+        m_in_irq = 0;
 
+    bool only_update_state = handling_exception && trap.next_trap;
+
+    auto* current_thread = Processor::current_thread();
+    if (!only_update_state) {
 #if ARCH(X86_64)
-    auto* self = static_cast<Processor*>(this);
-    if (is_smp_enabled())
-        self->smp_process_pending_messages();
+        auto* self = static_cast<Processor*>(this);
+        if (is_smp_enabled())
+            self->smp_process_pending_messages();
 #endif
 
-    auto* current_thread = Processor::current_thread();
-    if (current_thread) {
-        SpinlockLocker thread_lock(current_thread->get_lock());
-        current_thread->check_dispatch_pending_signal(YieldBehavior::FlagYield);
-    }
+        if (current_thread) {
+            SpinlockLocker thread_lock(current_thread->get_lock());
+            current_thread->check_dispatch_pending_signal(YieldBehavior::FlagYield);
+        }
 
-    // Process the deferred call queue. Among other things, this ensures
-    // that any pending thread unblocks happen before we enter the scheduler.
-    m_deferred_call_pool.execute_pending();
+        // Process the deferred call queue. Among other things, this ensures
+        // that any pending thread unblocks happen before we enter the scheduler.
+        m_deferred_call_pool.execute_pending();
+    }
 
     if (current_thread) {
         auto& current_trap = current_thread->current_trap();
@@ -320,7 +327,7 @@ void ProcessorBase::exit_trap(TrapFrame& trap)
     // We don't want context switches to happen until we're explicitly
     // triggering a switch in check_invoke_scheduler.
     m_in_critical = m_in_critical - 1;
-    if (!m_in_irq && !m_in_critical)
+    if (!only_update_state && !m_in_irq && !m_in_critical)
         check_invoke_scheduler();
 }
 

Kernel/Arch/Processor.h

@@ -113,7 +113,7 @@ class ProcessorBase {
     }
 
     void enter_trap(TrapFrame& trap, bool raise_irq);
-    void exit_trap(TrapFrame& trap);
+    void exit_trap(TrapFrame& trap, bool handling_exception = false);
 
     static void flush_entire_tlb_local();
 

Kernel/Arch/TrapFrame.cpp

@@ -29,4 +29,10 @@ extern "C" void exit_trap(TrapFrame* trap)
     return Processor::current().exit_trap(*trap);
 }
 
+extern "C" void exit_trap_exception(TrapFrame* trap)
+{
+    InterruptDisabler disable;
+    return Processor::current().exit_trap(*trap, true);
+}
+
 }

Kernel/Arch/TrapFrame.h

@@ -31,5 +31,6 @@ static_assert(AssertSize<TrapFrame, TRAP_FRAME_SIZE>());
 extern "C" void enter_trap_no_irq(TrapFrame* trap) __attribute__((used));
 extern "C" void enter_trap(TrapFrame*) __attribute__((used));
 extern "C" void exit_trap(TrapFrame*) __attribute__((used));
+extern "C" void exit_trap_exception(TrapFrame*) __attribute__((used));
 
 }

Kernel/Arch/aarch64/Interrupts.cpp

@@ -132,7 +132,7 @@ extern "C" void exception_common(Kernel::TrapFrame* trap_frame)
     }
 
     Processor::disable_interrupts();
-    Processor::current().exit_trap(*trap_frame);
+    Processor::current().exit_trap(*trap_frame, true);
 }
 
 // This spinlock is used to reserve IRQs that can be later used by interrupt mechanism such as MSIx

Kernel/Arch/riscv64/Interrupts.cpp

@@ -156,7 +156,7 @@ extern "C" void trap_handler(TrapFrame& trap_frame)
         };
 
         Processor::disable_interrupts();
-        Processor::current().exit_trap(trap_frame);
+        Processor::current().exit_trap(trap_frame, true);
     }
 }
 

Kernel/Arch/x86_64/Interrupts.cpp

@@ -54,6 +54,17 @@ static EntropySource s_entropy_source_interrupts { EntropySource::Static::Interr
 
 // clang-format off
 
+asm(
+    ".globl trap_exit_exception \n"
+    "trap_exit_exception: \n"
+    // another thread may have handled this trap at this point, so don't
+    // make assumptions about the stack other than there's a TrapFrame.
+    "    movq %rsp, %rdi \n"
+    "    call exit_trap_exception \n"
+    "    addq $" __STRINGIFY(TRAP_FRAME_SIZE) ", %rsp\n" // pop TrapFrame
+    "    jmp interrupt_common_asm_exit \n"
+);
+
 #define EH_ENTRY(ec, title)                                                    \
     extern "C" void title##_asm_entry();                                       \
     extern "C" void title##_handler(TrapFrame*) __attribute__((used));         \
@@ -82,7 +93,7 @@ static EntropySource s_entropy_source_interrupts { EntropySource::Static::Interr
             "    call enter_trap_no_irq \n"                                    \
             "    movq %rsp, %rdi \n"                                           \
             "    call " #title "_handler\n"                                    \
-            "    jmp common_trap_exit \n"                                      \
+            "    jmp trap_exit_exception \n"                                   \
         );                                                                     \
     }
 
@@ -115,7 +126,7 @@ static EntropySource s_entropy_source_interrupts { EntropySource::Static::Interr
             "    call enter_trap_no_irq \n"                                    \
             "    movq %rsp, %rdi \n"                                           \
             "    call " #title "_handler\n"                                    \
-            "    jmp common_trap_exit \n"                                      \
+            "    jmp trap_exit_exception \n"                                   \
         );                                                                     \
     }