Function dispatch_fail

kernel/integration/support/src/dispatch_fail.hpp:63–100

<!-- description --> @brief Dispatches the fail as needed, or returns an error so that the microkernel can halt the PP. <!-- inputs/outputs --> @param gs the gs_t to use @param tls the tls_t to use @param sys the bf_syscall_t to use @param intrinsic the intrinsic_t to use @param vp_pool the vp_pool_t to use @param vs_pool the vs_pool_t to use @param errc the reason for the failure, which is CPU s

    ///     and friends otherwise
    ///
    [[nodiscard]] static constexpr auto
    dispatch_fail(
        gs_t const &gs,
        tls_t const &tls,
        syscall::bf_syscall_t const &sys,
        intrinsic_t const &intrinsic,
        vp_pool_t const &vp_pool,
        vs_pool_t const &vs_pool,
        bsl::safe_u64 const &errc,
        bsl::safe_u64 const &addr) noexcept -> bsl::errc_type
    {
        bsl::expects(errc.is_valid_and_checked());
        bsl::expects(addr.is_valid_and_checked());

        bsl::discard(gs);
        bsl::discard(tls);
        bsl::discard(sys);
        bsl::discard(intrinsic);
        bsl::discard(vp_pool);
        bsl::discard(vs_pool);

        /// NOTE:
        /// - Tells the microkernel that we didn't handle the fast fail.
        ///   When this occurs, the microkernel will halt this PP. In most
        ///   cases, there are only two options for how to handle a fail:
        ///   - Do the following, and report an error and halt.
        ///   - Return to a parent VS and continue execution from there,
        ///     which is typically only possible if you are implementing
        ///     more than one VP/VS per PP (e.g., when implementing guest
        ///     support, VSM support or nested virtualization support).
        ///
        /// - Another use case is integration testing. We can also use this
        ///   to generate faults that we can recover from to ensure the
        ///   fault system works properly during testing.
        ///

        return bsl::errc_failure;
    }
}

#endif