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,26 @@ void ProcessorBase::exit_trap(TrapFrame& trap)
     // ScopedCritical here.
     m_in_critical = m_in_critical + 1;
 
-    m_in_irq = 0;
+    bool only_update_state = handling_exception && trap.next_trap;
 
+    auto* current_thread = Processor::current_thread();
+    if (!only_update_state) {
+        m_in_irq = 0;
 #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 +323,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

@@ -93,6 +93,8 @@ extern "C" void exception_common(Kernel::TrapFrame* trap_frame)
         trap_frame->regs->set_ip(trap_frame->regs->ip() + 4);
     }
 
+    bool is_syscall = Aarch64::exception_class_is_svc_instruction_execution(esr_el1.EC);
+
     if (Aarch64::exception_class_is_data_abort(esr_el1.EC) || Aarch64::exception_class_is_instruction_abort(esr_el1.EC)) {
         auto page_fault_or_error = page_fault_from_exception_syndrome_register(VirtualAddress(fault_address), esr_el1);
         if (page_fault_or_error.is_error()) {
@@ -101,7 +103,7 @@ extern "C" void exception_common(Kernel::TrapFrame* trap_frame)
             auto page_fault = page_fault_or_error.release_value();
             page_fault.handle(*trap_frame->regs);
         }
-    } else if (Aarch64::exception_class_is_svc_instruction_execution(esr_el1.EC)) {
+    } else if (is_syscall) {
         Processor::enable_interrupts();
         syscall_handler(trap_frame);
         Processor::disable_interrupts();
@@ -133,7 +135,7 @@ extern "C" void exception_common(Kernel::TrapFrame* trap_frame)
     }
 
     VERIFY_INTERRUPTS_DISABLED();
-    Processor::current().exit_trap(*trap_frame);
+    Processor::current().exit_trap(*trap_frame, !is_syscall);
 }
 
 // This spinlock is used to reserve IRQs that can be later used by interrupt mechanism such as MSIx

Kernel/Arch/riscv64/Interrupts.cpp

@@ -89,6 +89,8 @@ extern "C" void trap_handler(TrapFrame& trap_frame)
         // Exception
         Processor::current().enter_trap(trap_frame, false);
 
+        bool handled_syscall = false;
+
         using enum RISCV64::CSR::SCAUSE;
         switch (scause) {
         case InstructionAddressMisaligned:
@@ -134,6 +136,7 @@ extern "C" void trap_handler(TrapFrame& trap_frame)
             Processor::enable_interrupts();
             syscall_handler(&trap_frame);
             Processor::disable_interrupts();
+            handled_syscall = true;
             break;
 
         case Breakpoint:
@@ -155,7 +158,7 @@ extern "C" void trap_handler(TrapFrame& trap_frame)
         };
 
         Processor::disable_interrupts();
-        Processor::current().exit_trap(trap_frame);
+        Processor::current().exit_trap(trap_frame, !handled_syscall);
     }
 }
 

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"                                   \
         );                                                                     \
     }