blob: e3dd706bde0aad501157e98ad8381d8804bb5a58 [file] [log] [blame]
// Copyright 2018 The Fuchsia Authors
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file or at
#include <kernel/cpu.h>
#include <kernel/thread.h>
struct int_handler_saved_state_t {
bool blocking_disallowed;
// Start the main part of handling an interrupt in which preemption and
// blocking are disabled. This must be matched by a later call to
// int_handler_finish().
inline void int_handler_start(int_handler_saved_state_t* state) {
// Save the current blocking_disallowed value so that we can restore it during
// int_handler_finish.
state->blocking_disallowed = arch_blocking_disallowed();
PreemptionState& preemption_state = Thread::Current::preemption_state();
// Disable all reschedules at least until the interrupt is finishing up.
// Although eager resched disable implies preempt disable, the nesting here is
// not redundant and is necessary to defer the local preemption to the safe
// point in the calling frame.
// Leave the main part of handling an interrupt, following a call to
// int_handler_start().
// If this function returns true, it means that there was a local preempt
// pending at the time the exception handler finished, and that the current
// thread does not have preemption disabled. In this case, callers *must*
// arrange to have preemption take place (typically via
// Thread::Current()::Preempt()) _before_ completely unwinding from the
// exception.
[[nodiscard]] inline bool int_handler_finish(int_handler_saved_state_t* state) {
PreemptionState& preemption_state = Thread::Current::preemption_state();
// Flush any pending remote preemptions if eager reschedules are enabled.
// Drop the preempt disable count that we added at the start of the interrupt
// handler, but do not trigger any local preemption if the disabled count has
// hit zero, and there is a local preempt pending.
// Instead, if a local preemption became pending during the interrupt handler and
// preemption is now enabled, indicate that the caller should perform the
// preemption.
const bool do_preempt = preemption_state.PreemptReenableDelayFlush();
// We can't blindly set blocking_disallowed to false because it's possible
// this interrupt handler interrupted a context where blocking_disallowed was
// true. Instead, simply restore the value we saved during int_handler_start.
return do_preempt;