WasmSequencer.hpp

Go to the documentation of this file.

// ======================================================================
// \title  WasmSequencer.hpp
// \author tumbar
// \brief  hpp file for WasmSequencer component implementation class
// ======================================================================

#ifndef Svc_WasmSequencer_HPP
#define Svc_WasmSequencer_HPP

#include "Fw/Cmd/CmdResponseEnumAc.hpp"
#include "Fw/DataStructures/FifoQueue.hpp"
#include "Fw/Types/FileNameString.hpp"
#include "Fw/Types/MemAllocator.hpp"
#include "Fw/Types/Serializable.hpp"
#include "Fw/Types/StringBase.hpp"
#include "Fw/Types/SuccessEnumAc.hpp"
#include "Svc/Seq/SeqArgsSerializableAc.hpp"
#include "Svc/WasmSequencer/WasmSequencerComponentAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_HostFunctionEnumAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_ModuleIdxAliasAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_RequestContextSerializableAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_TrapReasonEnumAc.hpp"
#include "Svc/WasmSequencer/spacewasm_include/spacewasm.h"
#include "Utils/Types/CircularBuffer.hpp"
#include "config/FwChanIdTypeAliasAc.h"
#include "config/FwPrmIdTypeAliasAc.h"
#include "config/FwSizeTypeAliasAc.h"
#include "config/WasmSequencerConfig.hpp"

namespace Svc {

class WasmSequencer final : public WasmSequencerComponentBase {
    friend class WasmSequencerTester;

  public:
    // ----------------------------------------------------------------------
    // Component construction and destruction
    // ----------------------------------------------------------------------

    WasmSequencer(const char* const compName  
    );

    ~WasmSequencer() = default;

    WasmSequencer(const WasmSequencer&) = delete;
    WasmSequencer& operator=(const WasmSequencer&) = delete;

    enum class SerialInQueueFullBehavior {
        DROP_NEWEST,  
        DROP_OLDEST,  
        ASSERT,       
    };

    constexpr static FwSizeType SPACEWASM_MEMORY_ALIGNMENT = 8;

    constexpr static FwSizeType SPACEWASM_IR_PAGE_SIZE = 512;
    static_assert(Svc::WasmSequencerConfig::SPACEWASM_PAGE_SIZE >= SPACEWASM_IR_PAGE_SIZE,
                  "SpaceWasm does not support dynamic memory pages smaller than a single IR page (512 bytes)");

    struct SerialInQueueConfig {
        FwSizeType size = 0;
        SerialInQueueFullBehavior fullBehavior = SerialInQueueFullBehavior::DROP_NEWEST;
    };

    struct Config {
        FwSizeType heapPages = 8;

        FwSizeType guestMemorySize = 8192;

        FwSizeType stackSize = 1024;

        FwSizeType maxCodePages = 256;

        U8 maxGuestModules = 8;

        FwSizeType serialOutMax = 0;

        SerialInQueueConfig serialIn[NUM_SERIALIN_INPUT_PORTS];
    };

    void configure(const Config& cfg, Fw::MemAllocator& mallocator);

    void deinit() override;

  private:
    // ----------------------------------------------------------------------
    // Handler implementations for typed input ports
    // ----------------------------------------------------------------------

    void checkTimers_handler(FwIndexType portNum,  
                             U32 context           
                             ) override;

    void cmdResponseIn_handler(FwIndexType portNum,             
                               FwOpcodeType opCode,             
                               U32 cmdSeq,                      
                               const Fw::CmdResponse& response  
                               ) override;

    void seqCancelIn_handler(FwIndexType portNum  
                             ) override;

    void seqRunIn_handler(FwIndexType portNum,             
                          const Fw::StringBase& filename,  
                          const Svc::SeqArgs& args         
                          ) override;

    void writeTelemetry_handler(FwIndexType portNum,  
                                U32 context           
                                ) override;

  private:
    // ----------------------------------------------------------------------
    // Handler implementations for serial input ports
    // ----------------------------------------------------------------------

    void serialIn_handler(FwIndexType portNum,          
                          Fw::LinearBufferBase& buffer  
                          ) override;

  private:
    // ----------------------------------------------------------------------
    // Handler implementations for commands
    // ----------------------------------------------------------------------

    void RUN_cmdHandler(
        FwOpcodeType opCode,               
        U32 cmdSeq,                        
        const Fw::CmdStringArg& fileName,  
        const Svc::BlockState& block,      
        const Svc::SeqArgs& seqArgs        
        ) override;

    void LOAD_cmdHandler(FwOpcodeType opCode,               
                         U32 cmdSeq,                        
                         const Fw::CmdStringArg& fileName,  
                         const Fw::CmdStringArg& name  
                         ) override;

    void INVOKE_cmdHandler(FwOpcodeType opCode,             
                           U32 cmdSeq,                      
                           const Fw::CmdStringArg& module,  
                           const Svc::BlockState& block,    
                           const Svc::SeqArgs& seqArgs      
                           ) override;

    void WAIT_cmdHandler(FwOpcodeType opCode,  
                         U32 cmdSeq            
                         ) override;

    void CANCEL_cmdHandler(FwOpcodeType opCode,  
                           U32 cmdSeq            
                           ) override;

    void PAUSE_cmdHandler(FwOpcodeType opCode,  
                          U32 cmdSeq            
                          ) override;

    void CONTINUE_cmdHandler(FwOpcodeType opCode,  
                             U32 cmdSeq            
                             ) override;

    void GLOBAL_SET_I32_cmdHandler(FwOpcodeType opCode,                 
                                   U32 cmdSeq,                          
                                   const Fw::CmdStringArg& moduleName,  
                                   const Fw::CmdStringArg& name,        
                                   I32 value                            
                                   ) override;

    void GLOBAL_SET_I64_cmdHandler(FwOpcodeType opCode,                 
                                   U32 cmdSeq,                          
                                   const Fw::CmdStringArg& moduleName,  
                                   const Fw::CmdStringArg& name,        
                                   I64 value                            
                                   ) override;

    void GLOBAL_SET_F32_cmdHandler(FwOpcodeType opCode,                 
                                   U32 cmdSeq,                          
                                   const Fw::CmdStringArg& moduleName,  
                                   const Fw::CmdStringArg& name,        
                                   F32 value                            
                                   ) override;

    void GLOBAL_SET_F64_cmdHandler(FwOpcodeType opCode,                 
                                   U32 cmdSeq,                          
                                   const Fw::CmdStringArg& moduleName,  
                                   const Fw::CmdStringArg& name,        
                                   F64 value                            
                                   ) override;

    void GLOBAL_GET_cmdHandler(FwOpcodeType opCode,                 
                               U32 cmdSeq,                          
                               const Fw::CmdStringArg& moduleName,  
                               const Fw::CmdStringArg& name         
                               ) override;

  private:
    // ----------------------------------------------------------------------
    // Implementations for internal state machine actions
    // ----------------------------------------------------------------------

    void Svc_WasmSequencer_ControllerStateMachine_action_processInvoke(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_InvokeRequest& value             
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_setCancelRequested(
        SmId smId,                                               
        Svc_WasmSequencer_ControllerStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_clearCancelRequested(
        SmId smId,                                               
        Svc_WasmSequencer_ControllerStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_cancelPendingRequest(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_respond_noblock_OK(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_respond_ERROR(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_incrementSequenceFailure(
        SmId smId,                                               
        Svc_WasmSequencer_ControllerStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_respondInvoke_BUSY(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_InvokeRequest& value             
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_respondInvoke_ERROR(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_InvokeRequest& value             
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_respondLoad_BUSY(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_LoadRequest& value               
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_respond_block_OK(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_respond_block_ERROR(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_load(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_LoadRequest& value               
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_invokeStart(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_invokeMain(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_reportModuleInvalidMain(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_reportModuleMainInvokeFailed(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_reportModuleStartInvokeFailed(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_reportModuleStarted(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_reportModuleSucceeded(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_reportModuleStartFailed(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_reportModuleMainFailed(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_resetStore(
        SmId smId,                                               
        Svc_WasmSequencer_ControllerStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_ControllerStateMachine_action_runEngine(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_cmdReplyOK(
        SmId smId,                                                 
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal,  
        const Svc::WasmSequencer_CommandRequest& value             
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_signalEntered(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_spin(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_reset(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_clearExitStatus(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_setExitReason_INTERPRETER_FINISHED(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_setExitReason_INTERPRETER_TRAP(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_setExitReason_REPLY_TIMEOUT(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_setExitReason_HOST_FAILURE(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_setExitReason_TIMER_INCOMPARABLE(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_setExitReason_UNEXPECTED_REPLY(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_setExitReason_CANCEL(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_setExitCode(
        SmId smId,                                                 
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal,  
        I32 value                                                  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_setTrapReason(
        SmId smId,                                                 
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal,  
        const Svc::WasmSequencer_TrapReason& value                 
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_setLastHostFunction(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_finish(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_reportPaused(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_clearPause(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_dispatchPendingHostFunction(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_clearPendingHostFunction(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_setContext(
        SmId smId,                                                 
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value             
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_clearContext(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_resume(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_resumeI32(
        SmId smId,                                                 
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal,  
        I32 value                                                  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_checkSleepTimers(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_checkTimeout(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
        ) override;

    void Svc_WasmSequencer_InterpreterStateMachine_action_dequeueSerialAndResume(
        SmId smId,                                                 
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal,  
        const FwIndexType& value                                   
        ) override;

  private:
    // ----------------------------------------------------------------------
    // Implementations for internal state machine guards
    // ----------------------------------------------------------------------

    bool Svc_WasmSequencer_ControllerStateMachine_guard_cancelRequested(
        SmId smId,                                               
        Svc_WasmSequencer_ControllerStateMachine::Signal signal  
    ) const override;

    bool Svc_WasmSequencer_ControllerStateMachine_guard_moduleHasStart(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
    ) const override;

    bool Svc_WasmSequencer_ControllerStateMachine_guard_moduleHasValidMain(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
    ) const override;

    bool Svc_WasmSequencer_ControllerStateMachine_guard_invokeSucceeded(
        SmId smId,                                                
        Svc_WasmSequencer_ControllerStateMachine::Signal signal,  
        const Svc::WasmSequencer_RequestContext& value            
    ) const override;

    bool Svc_WasmSequencer_ControllerStateMachine_guard_interpreterSucceeded(
        SmId smId,                                               
        Svc_WasmSequencer_ControllerStateMachine::Signal signal  
    ) const override;

    bool Svc_WasmSequencer_InterpreterStateMachine_guard_pendingPause(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
    ) const override;

    bool Svc_WasmSequencer_InterpreterStateMachine_guard_pendingHostFunction(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
    ) const override;

    bool Svc_WasmSequencer_InterpreterStateMachine_guard_pendingHostFunctionIsSleep(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
    ) const override;

    bool Svc_WasmSequencer_InterpreterStateMachine_guard_blockingSerialIn(
        SmId smId,                                                 
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal,  
        const FwIndexType& value                                   
    ) const override;

    bool Svc_WasmSequencer_InterpreterStateMachine_guard_dequeueSucceeded(
        SmId smId,                                                
        Svc_WasmSequencer_InterpreterStateMachine::Signal signal  
    ) const override;

  private:
    U8* globalAlloc(U32 size, U32 align);
    void globalDealloc(const U8* ptr);

    static U8* globalAllocCallback(void* userdata, size_t size, size_t align);
    static void globalDeallocCallback(void* userdata, U8* ptr, size_t size, size_t align);

    U8* guestAlloc(FwSizeType size, U32 align);
    U8* guestRealloc(U8* ptr, FwSizeType oldSize, FwSizeType newSize, U32 align);
    void guestDealloc(const U8* ptr, FwSizeType size);

    // Guest allocator callbacks passed to C API
    static U8* guestAllocCallback(void* userdata, size_t size, size_t align);
    static U8* guestReallocCallback(void* userdata, U8* ptr, size_t old_size, size_t new_size, size_t align);
    static void guestDeallocCallback(void* userdata, U8* ptr, size_t size, size_t align);

    void createStore();

    void destroyStore();

    void takeAllocatorLock();

    void releaseAllocatorLock();

    static Svc::WasmSequencer_TrapReason::T mapTrapReason(spacewasm_trap_t trap);

    void setSequenceName(const Fw::StringBase& filePath, const Fw::StringBase& moduleName);

    static const char* pathBaseName(const char* path, FwSizeType len, FwSizeType& outLen);

    static bool pathHasParentTraversal(const Fw::StringBase& path);

    bool resolveSequencePath(const Fw::StringBase& fileName, Fw::String& filePath);

    Fw::Success readGuestMemory(WasmSequencer_HostFunction::T kind, U32 addr, U8* dst, FwSizeType len);

    Fw::Success writeGuestMemory(WasmSequencer_HostFunction::T kind, U32 addr, const U8* src, FwSizeType len);

    Fw::MemAllocator* m_allocator = nullptr;

    Config m_config;

    U8** m_heapPages;

    FwSizeType m_heapPagesUsed;

    bool m_heapPoisoned;

    U8* m_guestPool;

    FwSizeType m_guestPoolOffset;

    spacewasm_t* m_wasm;

    spacewasm_allocator_t* m_guest_allocator;

    struct WaitingCmd {
        FwOpcodeType opCode;
        U32 cmdSeq;

        WaitingCmd() : opCode(0), cmdSeq(0) {}
        WaitingCmd(FwOpcodeType opCode_, U32 cmdSeq_) : opCode(opCode_), cmdSeq(cmdSeq_) {}
    };

    Fw::FifoQueue<WaitingCmd, WasmSequencerConfig::MAX_CONCURRENT_WAIT_COMMANDS> m_waiting;

    Svc::SeqArgs m_args;

    Fw::FileNameString m_lastLoadFileName;

    WasmSequencer_RequestContext m_executingContext;
    bool m_hasExecutingContext;

    Fw::Time m_pendingTimer;
    bool m_hasPendingTimer;

    Fw::Time m_hostFunctionStart;
    bool m_hasHostFunctionStart;

    bool m_dequeueSucceeded;

    spacewasm_status_t m_invokeStatus;

    bool m_pendingPause;

    bool m_cancelRequested;

    struct Telemetry {
        U64 sequencesSucceeded{0};

        U64 sequencesFailed{0};

        U64 sequencesCancelled{0};

        U64 commandsDispatched{0};

        U64 commandsFailed{0};

        Fw::FileNameString sequenceName{""};
    };

    Telemetry m_tlm;

    U32 m_sequencesStarted;

    U32 makeCmdUid() const;

    struct ExitStatus {
        WasmSequencer_ExitReason reason{WasmSequencer_ExitReason::UNKNOWN};

        I32 code{0};

        WasmSequencer_HostFunction lastHostFunction{WasmSequencer_HostFunction::NONE};

        WasmSequencer_TrapReason lastTrapReason{WasmSequencer_TrapReason::NONE};
    };

    ExitStatus m_exit;

    Fw::ExternalSerializeBuffer m_serialOutBuffer;

    Types::CircularBuffer m_serialInQueue[NUM_SERIALIN_INPUT_PORTS];

    Os::Mutex m_serialInMutex;

    struct PendingHostFunction {
        PendingHostFunction() = default;
        bool isPending() const { return kind != WasmSequencer_HostFunction::NONE; }
        void clear() { kind = WasmSequencer_HostFunction::NONE; }

        WasmSequencer_HostFunction kind{WasmSequencer_HostFunction::NONE};

        // Handle that holds the Wasm guest memory pointer
        spacewasm_caller_t* caller{nullptr};

        union Args {
            // COMMAND: encoded command payload in guest memory
            struct {
                U32 ptr;
                U32 len;
            } command;

            // TELEMETRY: channel id plus where to write the serialized time and value
            struct {
                FwChanIdType chanId;
                U32 timePtr;
                U32 timeLen;
                U32 valuePtr;
                U32 valueLen;
            } telemetry;

            // PARAMETER: parameter id plus where to write the serialized value
            struct {
                FwPrmIdType prmId;
                U32 ptr;
                U32 len;
            } parameter;

            // EVENT: raw guest-requested severity (may be out of range) plus the message
            struct {
                U32 rawSeverity;
                U32 msgPtr;
                U32 msgLen;
            } event;

            // RSLEEP: relative sleep duration
            struct {
                U64 us;
            } rsleep;

            // ASLEEP: absolute sleep time
            struct {
                U64 us;
            } asleep;

            // ARGS: where to write the stored sequence arguments
            struct {
                U32 ptr;
                U32 len;
            } args;

            // TIME: where to write the serialized current time
            struct {
                U32 ptr;
                U32 len;
            } time;

            // SERIAL_OUT: serial output port index plus payload in guest memory
            struct {
                U32 index;
                U32 ptr;
                U32 len;
            } serialOut;

            // SERIAL_RECV: Read a message from the serialIn port queue given a port index
            struct {
                U32 index;
                U32 dataPtr;
                U32 dataSize;
                U32 actualSizePtr;
                Svc::BlockState::T blockingType;
            } serialRecv;

            Args() : command{0, 0} {}
        } u;
    };

    PendingHostFunction m_pendingHostFunction;

    spacewasm_status_t validateModuleMain(WasmSequencer_ModuleIdx moduleIdx) const;

    void reportSequenceRuntimeFailure(WasmSequencer_ModuleIdx moduleIdx, WasmSequencer_SequencePhase phase);

    void respondToRequest(const Svc::WasmSequencer_RequestContext& value, const Fw::CmdResponse& response);

    void respondToWaiting(const Fw::CmdResponse& response);

    void reportSeqDone(const Svc::WasmSequencer_RequestContext& value, const Fw::CmdResponse& response);

    spacewasm_status_t setGlobal(const Fw::StringBase& moduleName, const Fw::StringBase& name, spacewasm_value_t value);

    spacewasm_status_t getGlobal(const Fw::StringBase& moduleName,
                                 const Fw::StringBase& name,
                                 spacewasm_value_t& value);

    void hostFprimeV1(spacewasm_host_t*);

    spacewasm_hostcall_result_t wasmExit(struct spacewasm_caller_t* caller,
                                         const struct spacewasm_value_t* params,
                                         size_t n_params,
                                         struct spacewasm_value_t* out_result);

    spacewasm_hostcall_result_t wasmPanic(struct spacewasm_caller_t* caller,
                                          const struct spacewasm_value_t* params,
                                          size_t n_params,
                                          struct spacewasm_value_t* out_result);

    spacewasm_hostcall_result_t wasmArgs(struct spacewasm_caller_t* caller,
                                         const struct spacewasm_value_t* params,
                                         size_t n_params,
                                         struct spacewasm_value_t* out_result);

    spacewasm_hostcall_result_t wasmTime(struct spacewasm_caller_t* caller,
                                         const struct spacewasm_value_t* params,
                                         size_t n_params,
                                         struct spacewasm_value_t* out_result);

    spacewasm_hostcall_result_t wasmReadTelemetry(struct spacewasm_caller_t* caller,
                                                  const struct spacewasm_value_t* params,
                                                  size_t n_params,
                                                  struct spacewasm_value_t* out_result);

    spacewasm_hostcall_result_t wasmReadParameter(struct spacewasm_caller_t* caller,
                                                  const struct spacewasm_value_t* params,
                                                  size_t n_params,
                                                  struct spacewasm_value_t* out_result);

    spacewasm_hostcall_result_t wasmCommand(struct spacewasm_caller_t* caller,
                                            const struct spacewasm_value_t* params,
                                            size_t n_params,
                                            struct spacewasm_value_t* out_result);

    spacewasm_hostcall_result_t wasmEvent(struct spacewasm_caller_t* caller,
                                          const struct spacewasm_value_t* params,
                                          size_t n_params,
                                          struct spacewasm_value_t* out_result);

    spacewasm_hostcall_result_t wasmRsleep(struct spacewasm_caller_t* caller,
                                           const struct spacewasm_value_t* params,
                                           size_t n_params,
                                           struct spacewasm_value_t* out_result);

    spacewasm_hostcall_result_t wasmAsleep(struct spacewasm_caller_t* caller,
                                           const struct spacewasm_value_t* params,
                                           size_t n_params,
                                           struct spacewasm_value_t* out_result);

    spacewasm_hostcall_result_t wasmSerialOut(struct spacewasm_caller_t* caller,
                                              const struct spacewasm_value_t* params,
                                              size_t n_params,
                                              struct spacewasm_value_t* out_result);

    spacewasm_hostcall_result_t wasmSerialRecv(struct spacewasm_caller_t* caller,
                                               const struct spacewasm_value_t* params,
                                               size_t n_params,
                                               struct spacewasm_value_t* out_result);

    void dispatchCommand();

    void dispatchTelemetry();

    void dispatchParameter();

    void dispatchEvent();

    void dispatchRelativeSleep();

    void dispatchAbsoluteSleep();

    void dispatchArgs();

    void dispatchTime();

    void dispatchSerialOut();

    void dispatchSerialRecv();

    // A global static lock. This is needed to allow the global allocator in spacewasm
    // to not require to pass context to fine grained context to allocations.
    // Read more about this in the SDD.
    static Os::Mutex* getGlobalAllocatorLock();
};

}  // namespace Svc

#endif