| // WARNING: This file is machine generated by fidlgen. |
| |
| #pragma once |
| |
| #include <lib/fidl/internal.h> |
| #include <lib/fidl/txn_header.h> |
| #include <lib/fidl/llcpp/array.h> |
| #include <lib/fidl/llcpp/coding.h> |
| #include <lib/fidl/llcpp/connect_service.h> |
| #include <lib/fidl/llcpp/service_handler_interface.h> |
| #include <lib/fidl/llcpp/string_view.h> |
| #include <lib/fidl/llcpp/sync_call.h> |
| #include <lib/fidl/llcpp/traits.h> |
| #include <lib/fidl/llcpp/transaction.h> |
| #include <lib/fidl/llcpp/vector_view.h> |
| #include <lib/fit/function.h> |
| #include <lib/zx/channel.h> |
| #include <lib/zx/exception.h> |
| #include <lib/zx/process.h> |
| #include <lib/zx/thread.h> |
| #include <zircon/fidl.h> |
| |
| namespace llcpp { |
| |
| namespace fuchsia { |
| namespace exception { |
| |
| struct ProcessLimbo_RemoveFilters_Response; |
| struct ProcessLimbo_RemoveFilters_Result; |
| struct ProcessLimbo_ReleaseProcess_Response; |
| struct ProcessLimbo_ReleaseProcess_Result; |
| struct ProcessLimbo_AppendFilters_Response; |
| struct ProcessLimbo_AppendFilters_Result; |
| enum class ExceptionType : uint32_t { |
| GENERAL = 8u, |
| FATAL_PAGE_FAULT = 264u, |
| UNDEFINED_INSTRUCTION = 520u, |
| SW_BREAKPOINT = 776u, |
| HW_BREAKPOINT = 1032u, |
| UNALIGNED_ACCESS = 1288u, |
| THREAD_STARTING = 32776u, |
| THREAD_EXITING = 33032u, |
| POLICY_ERROR = 33288u, |
| PROCESS_STARTING = 33544u, |
| }; |
| |
| |
| struct ExceptionInfo; |
| class Handler; |
| struct ProcessExceptionMetadata; |
| struct ProcessLimbo_WatchProcessesWaitingOnException_Response; |
| struct ProcessLimbo_WatchProcessesWaitingOnException_Result; |
| struct ProcessException; |
| struct ProcessLimbo_RetrieveException_Response; |
| struct ProcessLimbo_RetrieveException_Result; |
| class ProcessLimbo; |
| |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_RemoveFilters_ResultTable; |
| |
| struct ProcessLimbo_RemoveFilters_Result { |
| ProcessLimbo_RemoveFilters_Result() : ordinal_(Ordinal::Invalid), envelope_{} {} |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; } |
| |
| bool is_response() const { return ordinal() == Ordinal::kResponse; } |
| |
| static ProcessLimbo_RemoveFilters_Result WithResponse(::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response* val) { |
| ProcessLimbo_RemoveFilters_Result result; |
| result.set_response(val); |
| return result; |
| } |
| |
| void set_response(::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response* elem) { |
| ordinal_ = Ordinal::kResponse; |
| envelope_.data = static_cast<void*>(elem); |
| } |
| |
| ::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response& mutable_response() { |
| ZX_ASSERT(ordinal() == Ordinal::kResponse); |
| return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response*>(envelope_.data); |
| } |
| const ::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response& response() const { |
| ZX_ASSERT(ordinal() == Ordinal::kResponse); |
| return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response*>(envelope_.data); |
| } |
| |
| bool is_err() const { return ordinal() == Ordinal::kErr; } |
| |
| static ProcessLimbo_RemoveFilters_Result WithErr(int32_t* val) { |
| ProcessLimbo_RemoveFilters_Result result; |
| result.set_err(val); |
| return result; |
| } |
| |
| void set_err(int32_t* elem) { |
| ordinal_ = Ordinal::kErr; |
| envelope_.data = static_cast<void*>(elem); |
| } |
| |
| int32_t& mutable_err() { |
| ZX_ASSERT(ordinal() == Ordinal::kErr); |
| return *static_cast<int32_t*>(envelope_.data); |
| } |
| const int32_t& err() const { |
| ZX_ASSERT(ordinal() == Ordinal::kErr); |
| return *static_cast<int32_t*>(envelope_.data); |
| } |
| Tag which() const { |
| ZX_ASSERT(!has_invalid_tag()); |
| return static_cast<Tag>(ordinal()); |
| } |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_RemoveFilters_ResultTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 8; |
| static constexpr bool HasPointer = true; |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| Ordinal ordinal() const { |
| return ordinal_; |
| } |
| |
| static void SizeAndOffsetAssertionHelper(); |
| Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| fidl_envelope_t envelope_; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_ReleaseProcess_ResultTable; |
| |
| struct ProcessLimbo_ReleaseProcess_Result { |
| ProcessLimbo_ReleaseProcess_Result() : ordinal_(Ordinal::Invalid), envelope_{} {} |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; } |
| |
| bool is_response() const { return ordinal() == Ordinal::kResponse; } |
| |
| static ProcessLimbo_ReleaseProcess_Result WithResponse(::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response* val) { |
| ProcessLimbo_ReleaseProcess_Result result; |
| result.set_response(val); |
| return result; |
| } |
| |
| void set_response(::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response* elem) { |
| ordinal_ = Ordinal::kResponse; |
| envelope_.data = static_cast<void*>(elem); |
| } |
| |
| ::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response& mutable_response() { |
| ZX_ASSERT(ordinal() == Ordinal::kResponse); |
| return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response*>(envelope_.data); |
| } |
| const ::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response& response() const { |
| ZX_ASSERT(ordinal() == Ordinal::kResponse); |
| return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response*>(envelope_.data); |
| } |
| |
| bool is_err() const { return ordinal() == Ordinal::kErr; } |
| |
| static ProcessLimbo_ReleaseProcess_Result WithErr(int32_t* val) { |
| ProcessLimbo_ReleaseProcess_Result result; |
| result.set_err(val); |
| return result; |
| } |
| |
| void set_err(int32_t* elem) { |
| ordinal_ = Ordinal::kErr; |
| envelope_.data = static_cast<void*>(elem); |
| } |
| |
| int32_t& mutable_err() { |
| ZX_ASSERT(ordinal() == Ordinal::kErr); |
| return *static_cast<int32_t*>(envelope_.data); |
| } |
| const int32_t& err() const { |
| ZX_ASSERT(ordinal() == Ordinal::kErr); |
| return *static_cast<int32_t*>(envelope_.data); |
| } |
| Tag which() const { |
| ZX_ASSERT(!has_invalid_tag()); |
| return static_cast<Tag>(ordinal()); |
| } |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_ReleaseProcess_ResultTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 8; |
| static constexpr bool HasPointer = true; |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| Ordinal ordinal() const { |
| return ordinal_; |
| } |
| |
| static void SizeAndOffsetAssertionHelper(); |
| Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| fidl_envelope_t envelope_; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_AppendFilters_ResultTable; |
| |
| struct ProcessLimbo_AppendFilters_Result { |
| ProcessLimbo_AppendFilters_Result() : ordinal_(Ordinal::Invalid), envelope_{} {} |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; } |
| |
| bool is_response() const { return ordinal() == Ordinal::kResponse; } |
| |
| static ProcessLimbo_AppendFilters_Result WithResponse(::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response* val) { |
| ProcessLimbo_AppendFilters_Result result; |
| result.set_response(val); |
| return result; |
| } |
| |
| void set_response(::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response* elem) { |
| ordinal_ = Ordinal::kResponse; |
| envelope_.data = static_cast<void*>(elem); |
| } |
| |
| ::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response& mutable_response() { |
| ZX_ASSERT(ordinal() == Ordinal::kResponse); |
| return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response*>(envelope_.data); |
| } |
| const ::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response& response() const { |
| ZX_ASSERT(ordinal() == Ordinal::kResponse); |
| return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response*>(envelope_.data); |
| } |
| |
| bool is_err() const { return ordinal() == Ordinal::kErr; } |
| |
| static ProcessLimbo_AppendFilters_Result WithErr(int32_t* val) { |
| ProcessLimbo_AppendFilters_Result result; |
| result.set_err(val); |
| return result; |
| } |
| |
| void set_err(int32_t* elem) { |
| ordinal_ = Ordinal::kErr; |
| envelope_.data = static_cast<void*>(elem); |
| } |
| |
| int32_t& mutable_err() { |
| ZX_ASSERT(ordinal() == Ordinal::kErr); |
| return *static_cast<int32_t*>(envelope_.data); |
| } |
| const int32_t& err() const { |
| ZX_ASSERT(ordinal() == Ordinal::kErr); |
| return *static_cast<int32_t*>(envelope_.data); |
| } |
| Tag which() const { |
| ZX_ASSERT(!has_invalid_tag()); |
| return static_cast<Tag>(ordinal()); |
| } |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_AppendFilters_ResultTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 8; |
| static constexpr bool HasPointer = true; |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| Ordinal ordinal() const { |
| return ordinal_; |
| } |
| |
| static void SizeAndOffsetAssertionHelper(); |
| Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| fidl_envelope_t envelope_; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessExceptionMetadataTable; |
| |
| // Intended to be read only metadada associated with an exception waiting in |
| // limbo. The handles provided will only have read-only access to the resource, |
| // so no modification can be done to them. |
| // |
| // NOTE: Both |process| and |thread| will be valid if present. |
| struct ProcessExceptionMetadata final : private ::fidl::VectorView<fidl_envelope_t> { |
| using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>; |
| public: |
| // Returns whether no field is set. |
| bool IsEmpty() const { return EnvelopesView::empty(); } |
| |
| const ::llcpp::fuchsia::exception::ExceptionInfo& info() const { |
| ZX_ASSERT(has_info()); |
| return *reinterpret_cast<const ::llcpp::fuchsia::exception::ExceptionInfo*>(EnvelopesView::at(1 - 1).data); |
| } |
| ::llcpp::fuchsia::exception::ExceptionInfo& info() { |
| ZX_ASSERT(has_info()); |
| return *reinterpret_cast<::llcpp::fuchsia::exception::ExceptionInfo*>(EnvelopesView::at(1 - 1).data); |
| } |
| bool has_info() const { |
| return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr; |
| } |
| |
| // Only has ZX_RIGHT_READ and ZX_RIGHT_GET_PROPERTY rights. |
| const ::zx::process& process() const { |
| ZX_ASSERT(has_process()); |
| return *reinterpret_cast<const ::zx::process*>(EnvelopesView::at(2 - 1).data); |
| } |
| ::zx::process& process() { |
| ZX_ASSERT(has_process()); |
| return *reinterpret_cast<::zx::process*>(EnvelopesView::at(2 - 1).data); |
| } |
| bool has_process() const { |
| return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr; |
| } |
| |
| // The thread that generated the exception. |
| // The process may have other threads that are not reflected here. |
| // Only has ZX_RIGHT_READ and ZX_RIGHT_GET_PROPERTY rights. |
| const ::zx::thread& thread() const { |
| ZX_ASSERT(has_thread()); |
| return *reinterpret_cast<const ::zx::thread*>(EnvelopesView::at(3 - 1).data); |
| } |
| ::zx::thread& thread() { |
| ZX_ASSERT(has_thread()); |
| return *reinterpret_cast<::zx::thread*>(EnvelopesView::at(3 - 1).data); |
| } |
| bool has_thread() const { |
| return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr; |
| } |
| |
| ProcessExceptionMetadata() = default; |
| ~ProcessExceptionMetadata() = default; |
| ProcessExceptionMetadata(ProcessExceptionMetadata&& other) noexcept = default; |
| ProcessExceptionMetadata& operator=(ProcessExceptionMetadata&& other) noexcept = default; |
| |
| class Builder; |
| friend class Builder; |
| static Builder Build(); |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessExceptionMetadataTable; |
| static constexpr uint32_t MaxNumHandles = 2; |
| static constexpr uint32_t PrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 88; |
| static constexpr bool HasPointer = true; |
| |
| private: |
| ProcessExceptionMetadata(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {} |
| }; |
| |
| class ProcessExceptionMetadata::Builder { |
| public: |
| ProcessExceptionMetadata view() { return ProcessExceptionMetadata(max_ordinal_, envelopes_.data_); } |
| ~Builder() = default; |
| Builder(Builder&& other) noexcept = default; |
| Builder& operator=(Builder&& other) noexcept = default; |
| |
| Builder&& set_info(::llcpp::fuchsia::exception::ExceptionInfo* elem); |
| |
| // Only has ZX_RIGHT_READ and ZX_RIGHT_GET_PROPERTY rights. |
| Builder&& set_process(::zx::process* elem); |
| |
| // The thread that generated the exception. |
| // The process may have other threads that are not reflected here. |
| // Only has ZX_RIGHT_READ and ZX_RIGHT_GET_PROPERTY rights. |
| Builder&& set_thread(::zx::thread* elem); |
| |
| private: |
| Builder() = default; |
| friend Builder ProcessExceptionMetadata::Build(); |
| |
| uint64_t max_ordinal_ = 0; |
| ::fidl::Array<fidl_envelope_t, 3> envelopes_ = {}; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_WatchProcessesWaitingOnException_ResultTable; |
| |
| struct ProcessLimbo_WatchProcessesWaitingOnException_Result { |
| ProcessLimbo_WatchProcessesWaitingOnException_Result() : ordinal_(Ordinal::Invalid), envelope_{} {} |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; } |
| |
| bool is_response() const { return ordinal() == Ordinal::kResponse; } |
| |
| static ProcessLimbo_WatchProcessesWaitingOnException_Result WithResponse(::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response* val) { |
| ProcessLimbo_WatchProcessesWaitingOnException_Result result; |
| result.set_response(val); |
| return result; |
| } |
| |
| void set_response(::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response* elem) { |
| ordinal_ = Ordinal::kResponse; |
| envelope_.data = static_cast<void*>(elem); |
| } |
| |
| ::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response& mutable_response() { |
| ZX_ASSERT(ordinal() == Ordinal::kResponse); |
| return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response*>(envelope_.data); |
| } |
| const ::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response& response() const { |
| ZX_ASSERT(ordinal() == Ordinal::kResponse); |
| return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response*>(envelope_.data); |
| } |
| |
| bool is_err() const { return ordinal() == Ordinal::kErr; } |
| |
| static ProcessLimbo_WatchProcessesWaitingOnException_Result WithErr(int32_t* val) { |
| ProcessLimbo_WatchProcessesWaitingOnException_Result result; |
| result.set_err(val); |
| return result; |
| } |
| |
| void set_err(int32_t* elem) { |
| ordinal_ = Ordinal::kErr; |
| envelope_.data = static_cast<void*>(elem); |
| } |
| |
| int32_t& mutable_err() { |
| ZX_ASSERT(ordinal() == Ordinal::kErr); |
| return *static_cast<int32_t*>(envelope_.data); |
| } |
| const int32_t& err() const { |
| ZX_ASSERT(ordinal() == Ordinal::kErr); |
| return *static_cast<int32_t*>(envelope_.data); |
| } |
| Tag which() const { |
| ZX_ASSERT(!has_invalid_tag()); |
| return static_cast<Tag>(ordinal()); |
| } |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_WatchProcessesWaitingOnException_ResultTable; |
| static constexpr uint32_t MaxNumHandles = 64; |
| static constexpr uint32_t PrimarySize = 24; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 3344; |
| static constexpr bool HasPointer = true; |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| Ordinal ordinal() const { |
| return ordinal_; |
| } |
| |
| static void SizeAndOffsetAssertionHelper(); |
| Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| fidl_envelope_t envelope_; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessExceptionTable; |
| |
| // Generic wrapper over a thread exception. Mirrors closely the information |
| // given by an exception channel. |
| struct ProcessException final : private ::fidl::VectorView<fidl_envelope_t> { |
| using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>; |
| public: |
| // Returns whether no field is set. |
| bool IsEmpty() const { return EnvelopesView::empty(); } |
| |
| const ::zx::exception& exception() const { |
| ZX_ASSERT(has_exception()); |
| return *reinterpret_cast<const ::zx::exception*>(EnvelopesView::at(1 - 1).data); |
| } |
| ::zx::exception& exception() { |
| ZX_ASSERT(has_exception()); |
| return *reinterpret_cast<::zx::exception*>(EnvelopesView::at(1 - 1).data); |
| } |
| bool has_exception() const { |
| return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr; |
| } |
| |
| const ::llcpp::fuchsia::exception::ExceptionInfo& info() const { |
| ZX_ASSERT(has_info()); |
| return *reinterpret_cast<const ::llcpp::fuchsia::exception::ExceptionInfo*>(EnvelopesView::at(2 - 1).data); |
| } |
| ::llcpp::fuchsia::exception::ExceptionInfo& info() { |
| ZX_ASSERT(has_info()); |
| return *reinterpret_cast<::llcpp::fuchsia::exception::ExceptionInfo*>(EnvelopesView::at(2 - 1).data); |
| } |
| bool has_info() const { |
| return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr; |
| } |
| |
| const ::zx::process& process() const { |
| ZX_ASSERT(has_process()); |
| return *reinterpret_cast<const ::zx::process*>(EnvelopesView::at(3 - 1).data); |
| } |
| ::zx::process& process() { |
| ZX_ASSERT(has_process()); |
| return *reinterpret_cast<::zx::process*>(EnvelopesView::at(3 - 1).data); |
| } |
| bool has_process() const { |
| return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr; |
| } |
| |
| const ::zx::thread& thread() const { |
| ZX_ASSERT(has_thread()); |
| return *reinterpret_cast<const ::zx::thread*>(EnvelopesView::at(4 - 1).data); |
| } |
| ::zx::thread& thread() { |
| ZX_ASSERT(has_thread()); |
| return *reinterpret_cast<::zx::thread*>(EnvelopesView::at(4 - 1).data); |
| } |
| bool has_thread() const { |
| return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr; |
| } |
| |
| ProcessException() = default; |
| ~ProcessException() = default; |
| ProcessException(ProcessException&& other) noexcept = default; |
| ProcessException& operator=(ProcessException&& other) noexcept = default; |
| |
| class Builder; |
| friend class Builder; |
| static Builder Build(); |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessExceptionTable; |
| static constexpr uint32_t MaxNumHandles = 3; |
| static constexpr uint32_t PrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 112; |
| static constexpr bool HasPointer = true; |
| |
| private: |
| ProcessException(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {} |
| }; |
| |
| class ProcessException::Builder { |
| public: |
| ProcessException view() { return ProcessException(max_ordinal_, envelopes_.data_); } |
| ~Builder() = default; |
| Builder(Builder&& other) noexcept = default; |
| Builder& operator=(Builder&& other) noexcept = default; |
| |
| Builder&& set_exception(::zx::exception* elem); |
| |
| Builder&& set_info(::llcpp::fuchsia::exception::ExceptionInfo* elem); |
| |
| Builder&& set_process(::zx::process* elem); |
| |
| Builder&& set_thread(::zx::thread* elem); |
| |
| private: |
| Builder() = default; |
| friend Builder ProcessException::Build(); |
| |
| uint64_t max_ordinal_ = 0; |
| ::fidl::Array<fidl_envelope_t, 4> envelopes_ = {}; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_RetrieveException_ResultTable; |
| |
| struct ProcessLimbo_RetrieveException_Result { |
| ProcessLimbo_RetrieveException_Result() : ordinal_(Ordinal::Invalid), envelope_{} {} |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; } |
| |
| bool is_response() const { return ordinal() == Ordinal::kResponse; } |
| |
| static ProcessLimbo_RetrieveException_Result WithResponse(::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response* val) { |
| ProcessLimbo_RetrieveException_Result result; |
| result.set_response(val); |
| return result; |
| } |
| |
| void set_response(::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response* elem) { |
| ordinal_ = Ordinal::kResponse; |
| envelope_.data = static_cast<void*>(elem); |
| } |
| |
| ::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response& mutable_response() { |
| ZX_ASSERT(ordinal() == Ordinal::kResponse); |
| return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response*>(envelope_.data); |
| } |
| const ::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response& response() const { |
| ZX_ASSERT(ordinal() == Ordinal::kResponse); |
| return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response*>(envelope_.data); |
| } |
| |
| bool is_err() const { return ordinal() == Ordinal::kErr; } |
| |
| static ProcessLimbo_RetrieveException_Result WithErr(int32_t* val) { |
| ProcessLimbo_RetrieveException_Result result; |
| result.set_err(val); |
| return result; |
| } |
| |
| void set_err(int32_t* elem) { |
| ordinal_ = Ordinal::kErr; |
| envelope_.data = static_cast<void*>(elem); |
| } |
| |
| int32_t& mutable_err() { |
| ZX_ASSERT(ordinal() == Ordinal::kErr); |
| return *static_cast<int32_t*>(envelope_.data); |
| } |
| const int32_t& err() const { |
| ZX_ASSERT(ordinal() == Ordinal::kErr); |
| return *static_cast<int32_t*>(envelope_.data); |
| } |
| Tag which() const { |
| ZX_ASSERT(!has_invalid_tag()); |
| return static_cast<Tag>(ordinal()); |
| } |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_RetrieveException_ResultTable; |
| static constexpr uint32_t MaxNumHandles = 3; |
| static constexpr uint32_t PrimarySize = 24; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 128; |
| static constexpr bool HasPointer = true; |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| Ordinal ordinal() const { |
| return ordinal_; |
| } |
| |
| static void SizeAndOffsetAssertionHelper(); |
| Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| fidl_envelope_t envelope_; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_RemoveFilters_ResponseTable; |
| |
| struct ProcessLimbo_RemoveFilters_Response { |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_RemoveFilters_ResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 1; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint8_t __reserved = {}; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_ReleaseProcess_ResponseTable; |
| |
| struct ProcessLimbo_ReleaseProcess_Response { |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_ReleaseProcess_ResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 1; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint8_t __reserved = {}; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_AppendFilters_ResponseTable; |
| |
| struct ProcessLimbo_AppendFilters_Response { |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_AppendFilters_ResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 1; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint8_t __reserved = {}; |
| }; |
| |
| constexpr uint64_t MAX_FILTER_LENGTH = 32u; |
| |
| constexpr uint64_t MAX_FILTERS_PER_CALL = 32u; |
| |
| // The maximum amount of exceptions that will be listed at any given time by a |
| // call to |ListProcessesWaitingOnException|. |
| constexpr uint64_t MAX_EXCEPTIONS_PER_CALL = 32u; |
| |
| extern "C" const fidl_type_t v1_fuchsia_exception_ExceptionInfoTable; |
| |
| // Basic exception information associated with a particular exception. |
| // Maps to `zx_exception_info_t`. |
| struct ExceptionInfo { |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ExceptionInfoTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint64_t process_koid = {}; |
| |
| uint64_t thread_koid = {}; |
| |
| ::llcpp::fuchsia::exception::ExceptionType type = {}; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_exception_HandlerOnExceptionRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_HandlerOnExceptionResponseTable; |
| |
| // Protocol meant for clients interested in handling exceptions for a |
| // particular service. |
| class Handler final { |
| Handler() = delete; |
| public: |
| static constexpr char Name[] = "fuchsia.exception.Handler"; |
| |
| using OnExceptionResponse = ::fidl::AnyZeroArgMessage; |
| struct OnExceptionRequest final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| ::zx::exception exception; |
| ::llcpp::fuchsia::exception::ExceptionInfo info; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_HandlerOnExceptionRequestTable; |
| static constexpr uint32_t MaxNumHandles = 1; |
| static constexpr uint32_t PrimarySize = 48; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr uint32_t AltPrimarySize = 48; |
| static constexpr uint32_t AltMaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| |
| // Collection of return types of FIDL calls in this interface. |
| class ResultOf final { |
| ResultOf() = delete; |
| private: |
| template <typename ResponseType> |
| class OnException_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| OnException_Impl(::zx::unowned_channel _client_end, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info); |
| ~OnException_Impl() = default; |
| OnException_Impl(OnException_Impl&& other) = default; |
| OnException_Impl& operator=(OnException_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| |
| public: |
| using OnException = OnException_Impl<OnExceptionResponse>; |
| }; |
| |
| // Collection of return types of FIDL calls in this interface, |
| // when the caller-allocate flavor or in-place call is used. |
| class UnownedResultOf final { |
| UnownedResultOf() = delete; |
| private: |
| template <typename ResponseType> |
| class OnException_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| OnException_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info, ::fidl::BytePart _response_buffer); |
| ~OnException_Impl() = default; |
| OnException_Impl(OnException_Impl&& other) = default; |
| OnException_Impl& operator=(OnException_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| |
| public: |
| using OnException = OnException_Impl<OnExceptionResponse>; |
| }; |
| |
| class SyncClient final { |
| public: |
| explicit SyncClient(::zx::channel channel) : channel_(std::move(channel)) {} |
| ~SyncClient() = default; |
| SyncClient(SyncClient&&) = default; |
| SyncClient& operator=(SyncClient&&) = default; |
| |
| const ::zx::channel& channel() const { return channel_; } |
| |
| ::zx::channel* mutable_channel() { return &channel_; } |
| |
| // This exception mirrors closely the information provided by exception |
| // channels. The design is to have clients of this API behave as closely as |
| // possible to native exception handlers that are listening to an exception |
| // channel. |
| // |
| // `exception` is an exception handle, which controls the exception's |
| // lifetime. See exception zircon docs for more information. |
| // |
| // `info` represents basic exception information as provided by the |
| // exception channel. |
| // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::OnException OnException(::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info); |
| |
| // This exception mirrors closely the information provided by exception |
| // channels. The design is to have clients of this API behave as closely as |
| // possible to native exception handlers that are listening to an exception |
| // channel. |
| // |
| // `exception` is an exception handle, which controls the exception's |
| // lifetime. See exception zircon docs for more information. |
| // |
| // `info` represents basic exception information as provided by the |
| // exception channel. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::OnException OnException(::fidl::BytePart _request_buffer, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info, ::fidl::BytePart _response_buffer); |
| |
| private: |
| ::zx::channel channel_; |
| }; |
| |
| // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client. |
| class Call final { |
| Call() = delete; |
| public: |
| |
| // This exception mirrors closely the information provided by exception |
| // channels. The design is to have clients of this API behave as closely as |
| // possible to native exception handlers that are listening to an exception |
| // channel. |
| // |
| // `exception` is an exception handle, which controls the exception's |
| // lifetime. See exception zircon docs for more information. |
| // |
| // `info` represents basic exception information as provided by the |
| // exception channel. |
| // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::OnException OnException(::zx::unowned_channel _client_end, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info); |
| |
| // This exception mirrors closely the information provided by exception |
| // channels. The design is to have clients of this API behave as closely as |
| // possible to native exception handlers that are listening to an exception |
| // channel. |
| // |
| // `exception` is an exception handle, which controls the exception's |
| // lifetime. See exception zircon docs for more information. |
| // |
| // `info` represents basic exception information as provided by the |
| // exception channel. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::OnException OnException(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info, ::fidl::BytePart _response_buffer); |
| |
| }; |
| |
| // Messages are encoded and decoded in-place when these methods are used. |
| // Additionally, requests must be already laid-out according to the FIDL wire-format. |
| class InPlace final { |
| InPlace() = delete; |
| public: |
| |
| // This exception mirrors closely the information provided by exception |
| // channels. The design is to have clients of this API behave as closely as |
| // possible to native exception handlers that are listening to an exception |
| // channel. |
| // |
| // `exception` is an exception handle, which controls the exception's |
| // lifetime. See exception zircon docs for more information. |
| // |
| // `info` represents basic exception information as provided by the |
| // exception channel. |
| static ::fidl::DecodeResult<OnExceptionResponse> OnException(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OnExceptionRequest> params, ::fidl::BytePart response_buffer); |
| |
| }; |
| |
| // Pure-virtual interface to be implemented by a server. |
| class Interface { |
| public: |
| Interface() = default; |
| virtual ~Interface() = default; |
| using _Outer = Handler; |
| using _Base = ::fidl::CompleterBase; |
| |
| class OnExceptionCompleterBase : public _Base { |
| public: |
| void Reply(); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using OnExceptionCompleter = ::fidl::Completer<OnExceptionCompleterBase>; |
| |
| virtual void OnException(::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info, OnExceptionCompleter::Sync _completer) = 0; |
| |
| }; |
| |
| // Attempts to dispatch the incoming message to a handler function in the server implementation. |
| // If there is no matching handler, it returns false, leaving the message and transaction intact. |
| // In all other cases, it consumes the message and returns true. |
| // It is possible to chain multiple TryDispatch functions in this manner. |
| static bool TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn); |
| |
| // Dispatches the incoming message to one of the handlers functions in the interface. |
| // If there is no matching handler, it closes all the handles in |msg| and closes the channel with |
| // a |ZX_ERR_NOT_SUPPORTED| epitaph, before returning false. The message should then be discarded. |
| static bool Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn); |
| |
| // Same as |Dispatch|, but takes a |void*| instead of |Interface*|. Only used with |fidl::Bind| |
| // to reduce template expansion. |
| // Do not call this method manually. Use |Dispatch| instead. |
| static bool TypeErasedDispatch(void* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) { |
| return Dispatch(static_cast<Interface*>(impl), msg, txn); |
| } |
| |
| |
| // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|. |
| class SetTransactionHeaderFor final { |
| SetTransactionHeaderFor() = delete; |
| public: |
| static void OnExceptionRequest(const ::fidl::DecodedMessage<Handler::OnExceptionRequest>& _msg); |
| static void OnExceptionResponse(const ::fidl::DecodedMessage<Handler::OnExceptionResponse>& _msg); |
| }; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_WatchProcessesWaitingOnException_ResponseTable; |
| |
| struct ProcessLimbo_WatchProcessesWaitingOnException_Response { |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_WatchProcessesWaitingOnException_ResponseTable; |
| static constexpr uint32_t MaxNumHandles = 64; |
| static constexpr uint32_t PrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 3328; |
| static constexpr bool HasPointer = true; |
| |
| ::fidl::VectorView<::llcpp::fuchsia::exception::ProcessExceptionMetadata> exception_list = {}; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_RetrieveException_ResponseTable; |
| |
| struct ProcessLimbo_RetrieveException_Response { |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_RetrieveException_ResponseTable; |
| static constexpr uint32_t MaxNumHandles = 3; |
| static constexpr uint32_t PrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t MaxOutOfLine = 112; |
| static constexpr bool HasPointer = true; |
| |
| ::llcpp::fuchsia::exception::ProcessException process_exception = {}; |
| }; |
| |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboSetActiveRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboSetActiveResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchActiveRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchActiveResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchProcessesWaitingOnExceptionRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchProcessesWaitingOnExceptionResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRetrieveExceptionRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRetrieveExceptionResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboReleaseProcessRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboReleaseProcessResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboAppendFiltersRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboAppendFiltersResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRemoveFiltersRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRemoveFiltersResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboGetFiltersRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboGetFiltersResponseTable; |
| |
| // Protocol meant for clients interested in obtaining processes that are |
| // suspended waiting for an exception handler (in limbo). This is the core |
| // feature that enables Just In Time (JIT) debugging. |
| // |
| // An example usage of this API would be having a debugger listen on limbo for |
| // new processes. Then another component (eg. a CLI tool) could activate the |
| // limbo, meaning that the system is now ready to capture crashing processes. |
| // As the debugger got a notification that the limbo is now active, it can |
| // correctly handle newly excepted processes and do its normal workflow. |
| class ProcessLimbo final { |
| ProcessLimbo() = delete; |
| public: |
| static constexpr char Name[] = "fuchsia.exception.ProcessLimbo"; |
| |
| using SetActiveResponse = ::fidl::AnyZeroArgMessage; |
| struct SetActiveRequest final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| bool active; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboSetActiveRequestTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr uint32_t AltPrimarySize = 24; |
| static constexpr uint32_t AltMaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| struct WatchActiveResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| bool is_active; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboWatchActiveResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| using WatchActiveRequest = ::fidl::AnyZeroArgMessage; |
| |
| struct WatchProcessesWaitingOnExceptionResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| ::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result result; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboWatchProcessesWaitingOnExceptionResponseTable; |
| static constexpr uint32_t MaxNumHandles = 64; |
| static constexpr uint32_t PrimarySize = 40; |
| static constexpr uint32_t MaxOutOfLine = 3344; |
| static constexpr bool HasFlexibleEnvelope = true; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| using WatchProcessesWaitingOnExceptionRequest = ::fidl::AnyZeroArgMessage; |
| |
| struct RetrieveExceptionResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| ::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result result; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboRetrieveExceptionResponseTable; |
| static constexpr uint32_t MaxNumHandles = 3; |
| static constexpr uint32_t PrimarySize = 40; |
| static constexpr uint32_t MaxOutOfLine = 128; |
| static constexpr bool HasFlexibleEnvelope = true; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| struct RetrieveExceptionRequest final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| uint64_t process_koid; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboRetrieveExceptionRequestTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr uint32_t AltPrimarySize = 24; |
| static constexpr uint32_t AltMaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| using ResponseType = RetrieveExceptionResponse; |
| }; |
| |
| struct ReleaseProcessResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| ::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result result; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboReleaseProcessResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 40; |
| static constexpr uint32_t MaxOutOfLine = 8; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| struct ReleaseProcessRequest final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| uint64_t process_koid; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboReleaseProcessRequestTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 24; |
| static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr uint32_t AltPrimarySize = 24; |
| static constexpr uint32_t AltMaxOutOfLine = 0; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = false; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| using ResponseType = ReleaseProcessResponse; |
| }; |
| |
| struct AppendFiltersResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| ::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result result; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboAppendFiltersResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 40; |
| static constexpr uint32_t MaxOutOfLine = 8; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| struct AppendFiltersRequest final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| ::fidl::VectorView<::fidl::StringView> filters; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboAppendFiltersRequestTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 32; |
| static constexpr uint32_t MaxOutOfLine = 1536; |
| static constexpr uint32_t AltPrimarySize = 32; |
| static constexpr uint32_t AltMaxOutOfLine = 1536; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| using ResponseType = AppendFiltersResponse; |
| }; |
| |
| struct RemoveFiltersResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| ::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result result; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboRemoveFiltersResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 40; |
| static constexpr uint32_t MaxOutOfLine = 8; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| struct RemoveFiltersRequest final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| ::fidl::VectorView<::fidl::StringView> filters; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboRemoveFiltersRequestTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 32; |
| static constexpr uint32_t MaxOutOfLine = 1536; |
| static constexpr uint32_t AltPrimarySize = 32; |
| static constexpr uint32_t AltMaxOutOfLine = 1536; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| using ResponseType = RemoveFiltersResponse; |
| }; |
| |
| struct GetFiltersResponse final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t _hdr; |
| ::fidl::VectorView<::fidl::StringView> filters; |
| |
| static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboGetFiltersResponseTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 32; |
| static constexpr uint32_t MaxOutOfLine = 1536; |
| static constexpr bool HasFlexibleEnvelope = false; |
| static constexpr bool HasPointer = true; |
| static constexpr bool ContainsUnion = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind MessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| using GetFiltersRequest = ::fidl::AnyZeroArgMessage; |
| |
| |
| // Collection of return types of FIDL calls in this interface. |
| class ResultOf final { |
| ResultOf() = delete; |
| private: |
| template <typename ResponseType> |
| class SetActive_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| SetActive_Impl(::zx::unowned_channel _client_end, bool active); |
| ~SetActive_Impl() = default; |
| SetActive_Impl(SetActive_Impl&& other) = default; |
| SetActive_Impl& operator=(SetActive_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class WatchActive_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| WatchActive_Impl(::zx::unowned_channel _client_end); |
| ~WatchActive_Impl() = default; |
| WatchActive_Impl(WatchActive_Impl&& other) = default; |
| WatchActive_Impl& operator=(WatchActive_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class WatchProcessesWaitingOnException_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| WatchProcessesWaitingOnException_Impl(::zx::unowned_channel _client_end); |
| ~WatchProcessesWaitingOnException_Impl() = default; |
| WatchProcessesWaitingOnException_Impl(WatchProcessesWaitingOnException_Impl&& other) = default; |
| WatchProcessesWaitingOnException_Impl& operator=(WatchProcessesWaitingOnException_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class RetrieveException_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| RetrieveException_Impl(::zx::unowned_channel _client_end, uint64_t process_koid); |
| ~RetrieveException_Impl() = default; |
| RetrieveException_Impl(RetrieveException_Impl&& other) = default; |
| RetrieveException_Impl& operator=(RetrieveException_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class ReleaseProcess_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| ReleaseProcess_Impl(::zx::unowned_channel _client_end, uint64_t process_koid); |
| ~ReleaseProcess_Impl() = default; |
| ReleaseProcess_Impl(ReleaseProcess_Impl&& other) = default; |
| ReleaseProcess_Impl& operator=(ReleaseProcess_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class AppendFilters_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| AppendFilters_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters); |
| ~AppendFilters_Impl() = default; |
| AppendFilters_Impl(AppendFilters_Impl&& other) = default; |
| AppendFilters_Impl& operator=(AppendFilters_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class RemoveFilters_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| RemoveFilters_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters); |
| ~RemoveFilters_Impl() = default; |
| RemoveFilters_Impl(RemoveFilters_Impl&& other) = default; |
| RemoveFilters_Impl& operator=(RemoveFilters_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class GetFilters_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>; |
| public: |
| GetFilters_Impl(::zx::unowned_channel _client_end); |
| ~GetFilters_Impl() = default; |
| GetFilters_Impl(GetFilters_Impl&& other) = default; |
| GetFilters_Impl& operator=(GetFilters_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| |
| public: |
| using SetActive = SetActive_Impl<SetActiveResponse>; |
| using WatchActive = WatchActive_Impl<WatchActiveResponse>; |
| using WatchProcessesWaitingOnException = WatchProcessesWaitingOnException_Impl<WatchProcessesWaitingOnExceptionResponse>; |
| using RetrieveException = RetrieveException_Impl<RetrieveExceptionResponse>; |
| using ReleaseProcess = ReleaseProcess_Impl<ReleaseProcessResponse>; |
| using AppendFilters = AppendFilters_Impl<AppendFiltersResponse>; |
| using RemoveFilters = RemoveFilters_Impl<RemoveFiltersResponse>; |
| using GetFilters = GetFilters_Impl<GetFiltersResponse>; |
| }; |
| |
| // Collection of return types of FIDL calls in this interface, |
| // when the caller-allocate flavor or in-place call is used. |
| class UnownedResultOf final { |
| UnownedResultOf() = delete; |
| private: |
| template <typename ResponseType> |
| class SetActive_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| SetActive_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool active, ::fidl::BytePart _response_buffer); |
| ~SetActive_Impl() = default; |
| SetActive_Impl(SetActive_Impl&& other) = default; |
| SetActive_Impl& operator=(SetActive_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class WatchActive_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| WatchActive_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| ~WatchActive_Impl() = default; |
| WatchActive_Impl(WatchActive_Impl&& other) = default; |
| WatchActive_Impl& operator=(WatchActive_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class WatchProcessesWaitingOnException_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| WatchProcessesWaitingOnException_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| ~WatchProcessesWaitingOnException_Impl() = default; |
| WatchProcessesWaitingOnException_Impl(WatchProcessesWaitingOnException_Impl&& other) = default; |
| WatchProcessesWaitingOnException_Impl& operator=(WatchProcessesWaitingOnException_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class RetrieveException_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| RetrieveException_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer); |
| ~RetrieveException_Impl() = default; |
| RetrieveException_Impl(RetrieveException_Impl&& other) = default; |
| RetrieveException_Impl& operator=(RetrieveException_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class ReleaseProcess_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| ReleaseProcess_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer); |
| ~ReleaseProcess_Impl() = default; |
| ReleaseProcess_Impl(ReleaseProcess_Impl&& other) = default; |
| ReleaseProcess_Impl& operator=(ReleaseProcess_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class AppendFilters_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| AppendFilters_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer); |
| ~AppendFilters_Impl() = default; |
| AppendFilters_Impl(AppendFilters_Impl&& other) = default; |
| AppendFilters_Impl& operator=(AppendFilters_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class RemoveFilters_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| RemoveFilters_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer); |
| ~RemoveFilters_Impl() = default; |
| RemoveFilters_Impl(RemoveFilters_Impl&& other) = default; |
| RemoveFilters_Impl& operator=(RemoveFilters_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| template <typename ResponseType> |
| class GetFilters_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> { |
| using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>; |
| public: |
| GetFilters_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| ~GetFilters_Impl() = default; |
| GetFilters_Impl(GetFilters_Impl&& other) = default; |
| GetFilters_Impl& operator=(GetFilters_Impl&& other) = default; |
| using Super::status; |
| using Super::error; |
| using Super::ok; |
| using Super::Unwrap; |
| using Super::value; |
| using Super::operator->; |
| using Super::operator*; |
| }; |
| |
| public: |
| using SetActive = SetActive_Impl<SetActiveResponse>; |
| using WatchActive = WatchActive_Impl<WatchActiveResponse>; |
| using WatchProcessesWaitingOnException = WatchProcessesWaitingOnException_Impl<WatchProcessesWaitingOnExceptionResponse>; |
| using RetrieveException = RetrieveException_Impl<RetrieveExceptionResponse>; |
| using ReleaseProcess = ReleaseProcess_Impl<ReleaseProcessResponse>; |
| using AppendFilters = AppendFilters_Impl<AppendFiltersResponse>; |
| using RemoveFilters = RemoveFilters_Impl<RemoveFiltersResponse>; |
| using GetFilters = GetFilters_Impl<GetFiltersResponse>; |
| }; |
| |
| class SyncClient final { |
| public: |
| explicit SyncClient(::zx::channel channel) : channel_(std::move(channel)) {} |
| ~SyncClient() = default; |
| SyncClient(SyncClient&&) = default; |
| SyncClient& operator=(SyncClient&&) = default; |
| |
| const ::zx::channel& channel() const { return channel_; } |
| |
| ::zx::channel* mutable_channel() { return &channel_; } |
| |
| // Set the active state of the limbo. Will trigger the |WatchActive| event |
| // if there was a change, meaning that any listening components will receive |
| // a notification. This includes the caller of |SetActive|. |
| // |
| // When a limbo is inactive, there will not be any processes waiting on it, |
| // meaning that any waiting processes will be freed upon deactivating the |
| // limbo. |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::SetActive SetActive(bool active); |
| |
| // Set the active state of the limbo. Will trigger the |WatchActive| event |
| // if there was a change, meaning that any listening components will receive |
| // a notification. This includes the caller of |SetActive|. |
| // |
| // When a limbo is inactive, there will not be any processes waiting on it, |
| // meaning that any waiting processes will be freed upon deactivating the |
| // limbo. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::SetActive SetActive(::fidl::BytePart _request_buffer, bool active, ::fidl::BytePart _response_buffer); |
| |
| // Watchs for changes determining whether the limbo is currently active, |
| // using a Hanging Get pattern. An active limbo could be empty (not have |
| // any processes waiting on an exception). |
| // When a limbo is inactive, there will not be any processes waiting on it. |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::WatchActive WatchActive(); |
| |
| // Watchs for changes determining whether the limbo is currently active, |
| // using a Hanging Get pattern. An active limbo could be empty (not have |
| // any processes waiting on an exception). |
| // When a limbo is inactive, there will not be any processes waiting on it. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::WatchActive WatchActive(::fidl::BytePart _response_buffer); |
| |
| // Watch for processes that are waiting on exceptions, using a Hanging Get |
| // Pattern. |
| // |
| // Returns information on all the processes currently waiting on an exception. |
| // The information provided is intended to correctly identify an exception |
| // and determine whether the caller wants to actually handle it. |
| // To retrieve an exception, use the |GetException| call. |
| // |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Returns ZX_ERR_CANCELED if there was an outstanding call and the limbo |
| // becomes inactive. |
| // |
| // NOTE: The |process| and |thread| handle will only have the ZX_RIGHT_READ |
| // right, so no modification will be able to be done on them. |
| // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated. |
| ResultOf::WatchProcessesWaitingOnException WatchProcessesWaitingOnException(); |
| |
| // Watch for processes that are waiting on exceptions, using a Hanging Get |
| // Pattern. |
| // |
| // Returns information on all the processes currently waiting on an exception. |
| // The information provided is intended to correctly identify an exception |
| // and determine whether the caller wants to actually handle it. |
| // To retrieve an exception, use the |GetException| call. |
| // |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Returns ZX_ERR_CANCELED if there was an outstanding call and the limbo |
| // becomes inactive. |
| // |
| // NOTE: The |process| and |thread| handle will only have the ZX_RIGHT_READ |
| // right, so no modification will be able to be done on them. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::WatchProcessesWaitingOnException WatchProcessesWaitingOnException(::fidl::BytePart _response_buffer); |
| |
| // Removes the process from limbo and retrieves the exception handle and |
| // associated metadata from an exception. |
| // |
| // Use |ListProcessesWaitingOnException| to choose a |process_koid| from the |
| // list of available exceptions. |
| // |
| // Returns ZX_ERR_NOT_FOUND if the process is not waiting on an exception. |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated. |
| ResultOf::RetrieveException RetrieveException(uint64_t process_koid); |
| |
| // Removes the process from limbo and retrieves the exception handle and |
| // associated metadata from an exception. |
| // |
| // Use |ListProcessesWaitingOnException| to choose a |process_koid| from the |
| // list of available exceptions. |
| // |
| // Returns ZX_ERR_NOT_FOUND if the process is not waiting on an exception. |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::RetrieveException RetrieveException(::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer); |
| |
| // Removes the process from limbo, releasing the exception. This will make |
| // it "bubble up" beyond the scope of of this limbo, making it |
| // unretrievable in the future from here. |
| // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary. |
| ResultOf::ReleaseProcess ReleaseProcess(uint64_t process_koid); |
| |
| // Removes the process from limbo, releasing the exception. This will make |
| // it "bubble up" beyond the scope of of this limbo, making it |
| // unretrievable in the future from here. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::ReleaseProcess ReleaseProcess(::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer); |
| |
| // Adds filters to the limbo. Filters determine what processes the limbo |
| // will store when receiving an exception. Repeated filters will be |
| // ignored. Filters work by "filtering out" processes. It means that if a |
| // filter matches, that process won't get included. |
| // |
| // Filters work by substring matching. This means that a process name has |
| // to have the filter as a substring in order to match it. Example: |
| // |
| // Filter = "dev". |
| // Process = "process" won't match. |
| // Process = "devcoordinator" will match. |
| // |
| // Adding filters is transactional: either all of them go in, or none at |
| // all. The maximum amount of filters is determined by |
| // |MAX_FILTERS_PER_CALL|. If the maximum is exceeded, ZX_ERR_NO_RESOURCES |
| // is returned. |
| // |
| // Changing filters have no effect on processes that are currently waiting |
| // on an exception, but rather which future processes that will remain in |
| // the limbo. |
| // |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated. |
| ResultOf::AppendFilters AppendFilters(::fidl::VectorView<::fidl::StringView> filters); |
| |
| // Adds filters to the limbo. Filters determine what processes the limbo |
| // will store when receiving an exception. Repeated filters will be |
| // ignored. Filters work by "filtering out" processes. It means that if a |
| // filter matches, that process won't get included. |
| // |
| // Filters work by substring matching. This means that a process name has |
| // to have the filter as a substring in order to match it. Example: |
| // |
| // Filter = "dev". |
| // Process = "process" won't match. |
| // Process = "devcoordinator" will match. |
| // |
| // Adding filters is transactional: either all of them go in, or none at |
| // all. The maximum amount of filters is determined by |
| // |MAX_FILTERS_PER_CALL|. If the maximum is exceeded, ZX_ERR_NO_RESOURCES |
| // is returned. |
| // |
| // Changing filters have no effect on processes that are currently waiting |
| // on an exception, but rather which future processes that will remain in |
| // the limbo. |
| // |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::AppendFilters AppendFilters(::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer); |
| |
| // Removes filters to the limbo. Any filters that are not currently present |
| // on the limbo will be ignored. |
| // |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated. |
| ResultOf::RemoveFilters RemoveFilters(::fidl::VectorView<::fidl::StringView> filters); |
| |
| // Removes filters to the limbo. Any filters that are not currently present |
| // on the limbo will be ignored. |
| // |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::RemoveFilters RemoveFilters(::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer); |
| |
| // Returns filters that are currently active within the limbo. If the limbo |
| // is inactive, it will return an empty vector. |
| // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated. |
| ResultOf::GetFilters GetFilters(); |
| |
| // Returns filters that are currently active within the limbo. If the limbo |
| // is inactive, it will return an empty vector. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| UnownedResultOf::GetFilters GetFilters(::fidl::BytePart _response_buffer); |
| |
| private: |
| ::zx::channel channel_; |
| }; |
| |
| // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client. |
| class Call final { |
| Call() = delete; |
| public: |
| |
| // Set the active state of the limbo. Will trigger the |WatchActive| event |
| // if there was a change, meaning that any listening components will receive |
| // a notification. This includes the caller of |SetActive|. |
| // |
| // When a limbo is inactive, there will not be any processes waiting on it, |
| // meaning that any waiting processes will be freed upon deactivating the |
| // limbo. |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::SetActive SetActive(::zx::unowned_channel _client_end, bool active); |
| |
| // Set the active state of the limbo. Will trigger the |WatchActive| event |
| // if there was a change, meaning that any listening components will receive |
| // a notification. This includes the caller of |SetActive|. |
| // |
| // When a limbo is inactive, there will not be any processes waiting on it, |
| // meaning that any waiting processes will be freed upon deactivating the |
| // limbo. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::SetActive SetActive(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool active, ::fidl::BytePart _response_buffer); |
| |
| // Watchs for changes determining whether the limbo is currently active, |
| // using a Hanging Get pattern. An active limbo could be empty (not have |
| // any processes waiting on an exception). |
| // When a limbo is inactive, there will not be any processes waiting on it. |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::WatchActive WatchActive(::zx::unowned_channel _client_end); |
| |
| // Watchs for changes determining whether the limbo is currently active, |
| // using a Hanging Get pattern. An active limbo could be empty (not have |
| // any processes waiting on an exception). |
| // When a limbo is inactive, there will not be any processes waiting on it. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::WatchActive WatchActive(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| |
| // Watch for processes that are waiting on exceptions, using a Hanging Get |
| // Pattern. |
| // |
| // Returns information on all the processes currently waiting on an exception. |
| // The information provided is intended to correctly identify an exception |
| // and determine whether the caller wants to actually handle it. |
| // To retrieve an exception, use the |GetException| call. |
| // |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Returns ZX_ERR_CANCELED if there was an outstanding call and the limbo |
| // becomes inactive. |
| // |
| // NOTE: The |process| and |thread| handle will only have the ZX_RIGHT_READ |
| // right, so no modification will be able to be done on them. |
| // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated. |
| static ResultOf::WatchProcessesWaitingOnException WatchProcessesWaitingOnException(::zx::unowned_channel _client_end); |
| |
| // Watch for processes that are waiting on exceptions, using a Hanging Get |
| // Pattern. |
| // |
| // Returns information on all the processes currently waiting on an exception. |
| // The information provided is intended to correctly identify an exception |
| // and determine whether the caller wants to actually handle it. |
| // To retrieve an exception, use the |GetException| call. |
| // |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Returns ZX_ERR_CANCELED if there was an outstanding call and the limbo |
| // becomes inactive. |
| // |
| // NOTE: The |process| and |thread| handle will only have the ZX_RIGHT_READ |
| // right, so no modification will be able to be done on them. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::WatchProcessesWaitingOnException WatchProcessesWaitingOnException(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| |
| // Removes the process from limbo and retrieves the exception handle and |
| // associated metadata from an exception. |
| // |
| // Use |ListProcessesWaitingOnException| to choose a |process_koid| from the |
| // list of available exceptions. |
| // |
| // Returns ZX_ERR_NOT_FOUND if the process is not waiting on an exception. |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated. |
| static ResultOf::RetrieveException RetrieveException(::zx::unowned_channel _client_end, uint64_t process_koid); |
| |
| // Removes the process from limbo and retrieves the exception handle and |
| // associated metadata from an exception. |
| // |
| // Use |ListProcessesWaitingOnException| to choose a |process_koid| from the |
| // list of available exceptions. |
| // |
| // Returns ZX_ERR_NOT_FOUND if the process is not waiting on an exception. |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::RetrieveException RetrieveException(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer); |
| |
| // Removes the process from limbo, releasing the exception. This will make |
| // it "bubble up" beyond the scope of of this limbo, making it |
| // unretrievable in the future from here. |
| // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary. |
| static ResultOf::ReleaseProcess ReleaseProcess(::zx::unowned_channel _client_end, uint64_t process_koid); |
| |
| // Removes the process from limbo, releasing the exception. This will make |
| // it "bubble up" beyond the scope of of this limbo, making it |
| // unretrievable in the future from here. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::ReleaseProcess ReleaseProcess(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer); |
| |
| // Adds filters to the limbo. Filters determine what processes the limbo |
| // will store when receiving an exception. Repeated filters will be |
| // ignored. Filters work by "filtering out" processes. It means that if a |
| // filter matches, that process won't get included. |
| // |
| // Filters work by substring matching. This means that a process name has |
| // to have the filter as a substring in order to match it. Example: |
| // |
| // Filter = "dev". |
| // Process = "process" won't match. |
| // Process = "devcoordinator" will match. |
| // |
| // Adding filters is transactional: either all of them go in, or none at |
| // all. The maximum amount of filters is determined by |
| // |MAX_FILTERS_PER_CALL|. If the maximum is exceeded, ZX_ERR_NO_RESOURCES |
| // is returned. |
| // |
| // Changing filters have no effect on processes that are currently waiting |
| // on an exception, but rather which future processes that will remain in |
| // the limbo. |
| // |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated. |
| static ResultOf::AppendFilters AppendFilters(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters); |
| |
| // Adds filters to the limbo. Filters determine what processes the limbo |
| // will store when receiving an exception. Repeated filters will be |
| // ignored. Filters work by "filtering out" processes. It means that if a |
| // filter matches, that process won't get included. |
| // |
| // Filters work by substring matching. This means that a process name has |
| // to have the filter as a substring in order to match it. Example: |
| // |
| // Filter = "dev". |
| // Process = "process" won't match. |
| // Process = "devcoordinator" will match. |
| // |
| // Adding filters is transactional: either all of them go in, or none at |
| // all. The maximum amount of filters is determined by |
| // |MAX_FILTERS_PER_CALL|. If the maximum is exceeded, ZX_ERR_NO_RESOURCES |
| // is returned. |
| // |
| // Changing filters have no effect on processes that are currently waiting |
| // on an exception, but rather which future processes that will remain in |
| // the limbo. |
| // |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::AppendFilters AppendFilters(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer); |
| |
| // Removes filters to the limbo. Any filters that are not currently present |
| // on the limbo will be ignored. |
| // |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated. |
| static ResultOf::RemoveFilters RemoveFilters(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters); |
| |
| // Removes filters to the limbo. Any filters that are not currently present |
| // on the limbo will be ignored. |
| // |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::RemoveFilters RemoveFilters(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer); |
| |
| // Returns filters that are currently active within the limbo. If the limbo |
| // is inactive, it will return an empty vector. |
| // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated. |
| static ResultOf::GetFilters GetFilters(::zx::unowned_channel _client_end); |
| |
| // Returns filters that are currently active within the limbo. If the limbo |
| // is inactive, it will return an empty vector. |
| // Caller provides the backing storage for FIDL message via request and response buffers. |
| static UnownedResultOf::GetFilters GetFilters(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer); |
| |
| }; |
| |
| // Messages are encoded and decoded in-place when these methods are used. |
| // Additionally, requests must be already laid-out according to the FIDL wire-format. |
| class InPlace final { |
| InPlace() = delete; |
| public: |
| |
| // Set the active state of the limbo. Will trigger the |WatchActive| event |
| // if there was a change, meaning that any listening components will receive |
| // a notification. This includes the caller of |SetActive|. |
| // |
| // When a limbo is inactive, there will not be any processes waiting on it, |
| // meaning that any waiting processes will be freed upon deactivating the |
| // limbo. |
| static ::fidl::DecodeResult<SetActiveResponse> SetActive(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetActiveRequest> params, ::fidl::BytePart response_buffer); |
| |
| // Watchs for changes determining whether the limbo is currently active, |
| // using a Hanging Get pattern. An active limbo could be empty (not have |
| // any processes waiting on an exception). |
| // When a limbo is inactive, there will not be any processes waiting on it. |
| static ::fidl::DecodeResult<WatchActiveResponse> WatchActive(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer); |
| |
| // Watch for processes that are waiting on exceptions, using a Hanging Get |
| // Pattern. |
| // |
| // Returns information on all the processes currently waiting on an exception. |
| // The information provided is intended to correctly identify an exception |
| // and determine whether the caller wants to actually handle it. |
| // To retrieve an exception, use the |GetException| call. |
| // |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| // Returns ZX_ERR_CANCELED if there was an outstanding call and the limbo |
| // becomes inactive. |
| // |
| // NOTE: The |process| and |thread| handle will only have the ZX_RIGHT_READ |
| // right, so no modification will be able to be done on them. |
| static ::fidl::DecodeResult<WatchProcessesWaitingOnExceptionResponse> WatchProcessesWaitingOnException(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer); |
| |
| // Removes the process from limbo and retrieves the exception handle and |
| // associated metadata from an exception. |
| // |
| // Use |ListProcessesWaitingOnException| to choose a |process_koid| from the |
| // list of available exceptions. |
| // |
| // Returns ZX_ERR_NOT_FOUND if the process is not waiting on an exception. |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| static ::fidl::DecodeResult<RetrieveExceptionResponse> RetrieveException(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RetrieveExceptionRequest> params, ::fidl::BytePart response_buffer); |
| |
| // Removes the process from limbo, releasing the exception. This will make |
| // it "bubble up" beyond the scope of of this limbo, making it |
| // unretrievable in the future from here. |
| static ::fidl::DecodeResult<ReleaseProcessResponse> ReleaseProcess(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseProcessRequest> params, ::fidl::BytePart response_buffer); |
| |
| // Adds filters to the limbo. Filters determine what processes the limbo |
| // will store when receiving an exception. Repeated filters will be |
| // ignored. Filters work by "filtering out" processes. It means that if a |
| // filter matches, that process won't get included. |
| // |
| // Filters work by substring matching. This means that a process name has |
| // to have the filter as a substring in order to match it. Example: |
| // |
| // Filter = "dev". |
| // Process = "process" won't match. |
| // Process = "devcoordinator" will match. |
| // |
| // Adding filters is transactional: either all of them go in, or none at |
| // all. The maximum amount of filters is determined by |
| // |MAX_FILTERS_PER_CALL|. If the maximum is exceeded, ZX_ERR_NO_RESOURCES |
| // is returned. |
| // |
| // Changing filters have no effect on processes that are currently waiting |
| // on an exception, but rather which future processes that will remain in |
| // the limbo. |
| // |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| static ::fidl::DecodeResult<AppendFiltersResponse> AppendFilters(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AppendFiltersRequest> params, ::fidl::BytePart response_buffer); |
| |
| // Removes filters to the limbo. Any filters that are not currently present |
| // on the limbo will be ignored. |
| // |
| // Returns ZX_ERR_UNAVAILABLE if limbo is not active. |
| static ::fidl::DecodeResult<RemoveFiltersResponse> RemoveFilters(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RemoveFiltersRequest> params, ::fidl::BytePart response_buffer); |
| |
| // Returns filters that are currently active within the limbo. If the limbo |
| // is inactive, it will return an empty vector. |
| static ::fidl::DecodeResult<GetFiltersResponse> GetFilters(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer); |
| |
| }; |
| |
| // Pure-virtual interface to be implemented by a server. |
| class Interface { |
| public: |
| Interface() = default; |
| virtual ~Interface() = default; |
| using _Outer = ProcessLimbo; |
| using _Base = ::fidl::CompleterBase; |
| |
| class SetActiveCompleterBase : public _Base { |
| public: |
| void Reply(); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using SetActiveCompleter = ::fidl::Completer<SetActiveCompleterBase>; |
| |
| virtual void SetActive(bool active, SetActiveCompleter::Sync _completer) = 0; |
| |
| class WatchActiveCompleterBase : public _Base { |
| public: |
| void Reply(bool is_active); |
| void Reply(::fidl::BytePart _buffer, bool is_active); |
| void Reply(::fidl::DecodedMessage<WatchActiveResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using WatchActiveCompleter = ::fidl::Completer<WatchActiveCompleterBase>; |
| |
| virtual void WatchActive(WatchActiveCompleter::Sync _completer) = 0; |
| |
| class WatchProcessesWaitingOnExceptionCompleterBase : public _Base { |
| public: |
| void Reply(::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result result); |
| void ReplySuccess(::fidl::VectorView<::llcpp::fuchsia::exception::ProcessExceptionMetadata> exception_list); |
| void ReplyError(int32_t error); |
| void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result result); |
| void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::exception::ProcessExceptionMetadata> exception_list); |
| void Reply(::fidl::DecodedMessage<WatchProcessesWaitingOnExceptionResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using WatchProcessesWaitingOnExceptionCompleter = ::fidl::Completer<WatchProcessesWaitingOnExceptionCompleterBase>; |
| |
| virtual void WatchProcessesWaitingOnException(WatchProcessesWaitingOnExceptionCompleter::Sync _completer) = 0; |
| |
| class RetrieveExceptionCompleterBase : public _Base { |
| public: |
| void Reply(::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result result); |
| void ReplySuccess(::llcpp::fuchsia::exception::ProcessException process_exception); |
| void ReplyError(int32_t error); |
| void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result result); |
| void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessException process_exception); |
| void Reply(::fidl::DecodedMessage<RetrieveExceptionResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using RetrieveExceptionCompleter = ::fidl::Completer<RetrieveExceptionCompleterBase>; |
| |
| virtual void RetrieveException(uint64_t process_koid, RetrieveExceptionCompleter::Sync _completer) = 0; |
| |
| class ReleaseProcessCompleterBase : public _Base { |
| public: |
| void Reply(::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result result); |
| void ReplySuccess(); |
| void ReplyError(int32_t error); |
| void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result result); |
| void ReplySuccess(::fidl::BytePart _buffer); |
| void Reply(::fidl::DecodedMessage<ReleaseProcessResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using ReleaseProcessCompleter = ::fidl::Completer<ReleaseProcessCompleterBase>; |
| |
| virtual void ReleaseProcess(uint64_t process_koid, ReleaseProcessCompleter::Sync _completer) = 0; |
| |
| class AppendFiltersCompleterBase : public _Base { |
| public: |
| void Reply(::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result result); |
| void ReplySuccess(); |
| void ReplyError(int32_t error); |
| void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result result); |
| void ReplySuccess(::fidl::BytePart _buffer); |
| void Reply(::fidl::DecodedMessage<AppendFiltersResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using AppendFiltersCompleter = ::fidl::Completer<AppendFiltersCompleterBase>; |
| |
| virtual void AppendFilters(::fidl::VectorView<::fidl::StringView> filters, AppendFiltersCompleter::Sync _completer) = 0; |
| |
| class RemoveFiltersCompleterBase : public _Base { |
| public: |
| void Reply(::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result result); |
| void ReplySuccess(); |
| void ReplyError(int32_t error); |
| void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result result); |
| void ReplySuccess(::fidl::BytePart _buffer); |
| void Reply(::fidl::DecodedMessage<RemoveFiltersResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using RemoveFiltersCompleter = ::fidl::Completer<RemoveFiltersCompleterBase>; |
| |
| virtual void RemoveFilters(::fidl::VectorView<::fidl::StringView> filters, RemoveFiltersCompleter::Sync _completer) = 0; |
| |
| class GetFiltersCompleterBase : public _Base { |
| public: |
| void Reply(::fidl::VectorView<::fidl::StringView> filters); |
| void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::fidl::StringView> filters); |
| void Reply(::fidl::DecodedMessage<GetFiltersResponse> params); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| using GetFiltersCompleter = ::fidl::Completer<GetFiltersCompleterBase>; |
| |
| virtual void GetFilters(GetFiltersCompleter::Sync _completer) = 0; |
| |
| }; |
| |
| // Attempts to dispatch the incoming message to a handler function in the server implementation. |
| // If there is no matching handler, it returns false, leaving the message and transaction intact. |
| // In all other cases, it consumes the message and returns true. |
| // It is possible to chain multiple TryDispatch functions in this manner. |
| static bool TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn); |
| |
| // Dispatches the incoming message to one of the handlers functions in the interface. |
| // If there is no matching handler, it closes all the handles in |msg| and closes the channel with |
| // a |ZX_ERR_NOT_SUPPORTED| epitaph, before returning false. The message should then be discarded. |
| static bool Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn); |
| |
| // Same as |Dispatch|, but takes a |void*| instead of |Interface*|. Only used with |fidl::Bind| |
| // to reduce template expansion. |
| // Do not call this method manually. Use |Dispatch| instead. |
| static bool TypeErasedDispatch(void* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) { |
| return Dispatch(static_cast<Interface*>(impl), msg, txn); |
| } |
| |
| |
| // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|. |
| class SetTransactionHeaderFor final { |
| SetTransactionHeaderFor() = delete; |
| public: |
| static void SetActiveRequest(const ::fidl::DecodedMessage<ProcessLimbo::SetActiveRequest>& _msg); |
| static void SetActiveResponse(const ::fidl::DecodedMessage<ProcessLimbo::SetActiveResponse>& _msg); |
| static void WatchActiveRequest(const ::fidl::DecodedMessage<ProcessLimbo::WatchActiveRequest>& _msg); |
| static void WatchActiveResponse(const ::fidl::DecodedMessage<ProcessLimbo::WatchActiveResponse>& _msg); |
| static void WatchProcessesWaitingOnExceptionRequest(const ::fidl::DecodedMessage<ProcessLimbo::WatchProcessesWaitingOnExceptionRequest>& _msg); |
| static void WatchProcessesWaitingOnExceptionResponse(const ::fidl::DecodedMessage<ProcessLimbo::WatchProcessesWaitingOnExceptionResponse>& _msg); |
| static void RetrieveExceptionRequest(const ::fidl::DecodedMessage<ProcessLimbo::RetrieveExceptionRequest>& _msg); |
| static void RetrieveExceptionResponse(const ::fidl::DecodedMessage<ProcessLimbo::RetrieveExceptionResponse>& _msg); |
| static void ReleaseProcessRequest(const ::fidl::DecodedMessage<ProcessLimbo::ReleaseProcessRequest>& _msg); |
| static void ReleaseProcessResponse(const ::fidl::DecodedMessage<ProcessLimbo::ReleaseProcessResponse>& _msg); |
| static void AppendFiltersRequest(const ::fidl::DecodedMessage<ProcessLimbo::AppendFiltersRequest>& _msg); |
| static void AppendFiltersResponse(const ::fidl::DecodedMessage<ProcessLimbo::AppendFiltersResponse>& _msg); |
| static void RemoveFiltersRequest(const ::fidl::DecodedMessage<ProcessLimbo::RemoveFiltersRequest>& _msg); |
| static void RemoveFiltersResponse(const ::fidl::DecodedMessage<ProcessLimbo::RemoveFiltersResponse>& _msg); |
| static void GetFiltersRequest(const ::fidl::DecodedMessage<ProcessLimbo::GetFiltersRequest>& _msg); |
| static void GetFiltersResponse(const ::fidl::DecodedMessage<ProcessLimbo::GetFiltersResponse>& _msg); |
| }; |
| }; |
| |
| } // namespace exception |
| } // namespace fuchsia |
| } // namespace llcpp |
| |
| namespace fidl { |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response>); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response, __reserved) == 0); |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response) == ::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result>); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response>); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response, __reserved) == 0); |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response) == ::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result>); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response>); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response, __reserved) == 0); |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response) == ::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result>); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ExceptionInfo> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ExceptionInfo>); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ExceptionInfo, process_koid) == 0); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ExceptionInfo, thread_koid) == 8); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ExceptionInfo, type) == 16); |
| static_assert(sizeof(::llcpp::fuchsia::exception::ExceptionInfo) == ::llcpp::fuchsia::exception::ExceptionInfo::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::Handler::OnExceptionRequest> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::exception::Handler::OnExceptionRequest> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::exception::Handler::OnExceptionRequest) |
| == ::llcpp::fuchsia::exception::Handler::OnExceptionRequest::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::exception::Handler::OnExceptionRequest, exception) == 16); |
| static_assert(offsetof(::llcpp::fuchsia::exception::Handler::OnExceptionRequest, info) == 24); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessExceptionMetadata> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessExceptionMetadata>); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response>); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response, exception_list) == 0); |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response) == ::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result>); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessException> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessException>); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response>); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response, process_exception) == 0); |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response) == ::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result>); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::SetActiveRequest> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::SetActiveRequest> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::SetActiveRequest) |
| == ::llcpp::fuchsia::exception::ProcessLimbo::SetActiveRequest::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::SetActiveRequest, active) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::WatchActiveResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::WatchActiveResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::WatchActiveResponse) |
| == ::llcpp::fuchsia::exception::ProcessLimbo::WatchActiveResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::WatchActiveResponse, is_active) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::WatchProcessesWaitingOnExceptionResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::WatchProcessesWaitingOnExceptionResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::WatchProcessesWaitingOnExceptionResponse) |
| == ::llcpp::fuchsia::exception::ProcessLimbo::WatchProcessesWaitingOnExceptionResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::WatchProcessesWaitingOnExceptionResponse, result) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionRequest> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionRequest> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionRequest) |
| == ::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionRequest::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionRequest, process_koid) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionResponse) |
| == ::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionResponse, result) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessRequest> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessRequest> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessRequest) |
| == ::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessRequest::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessRequest, process_koid) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessResponse) |
| == ::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessResponse, result) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersRequest> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersRequest> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersRequest) |
| == ::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersRequest::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersRequest, filters) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersResponse) |
| == ::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersResponse, result) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersRequest> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersRequest> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersRequest) |
| == ::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersRequest::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersRequest, filters) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersResponse) |
| == ::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersResponse, result) == 16); |
| |
| template <> |
| struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::GetFiltersResponse> : public std::true_type {}; |
| template <> |
| struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::GetFiltersResponse> : public std::true_type {}; |
| static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::GetFiltersResponse) |
| == ::llcpp::fuchsia::exception::ProcessLimbo::GetFiltersResponse::PrimarySize); |
| static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::GetFiltersResponse, filters) == 16); |
| |
| } // namespace fidl |