| // WARNING: This file is machine generated by fidlgen. |
| |
| #include <fuchsia/kernel/llcpp/fidl.h> |
| #include <memory> |
| |
| namespace llcpp { |
| |
| namespace fuchsia { |
| namespace kernel { |
| |
| ::llcpp::fuchsia::kernel::PerCpuStats::Builder PerCpuStats::Build() { |
| return PerCpuStats::Builder(); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_cpu_number(uint32_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[1 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 1) { |
| max_ordinal_ = 1; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_flags(uint32_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[2 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 2) { |
| max_ordinal_ = 2; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_idle_time(int64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[3 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 3) { |
| max_ordinal_ = 3; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_reschedules(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[4 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 4) { |
| max_ordinal_ = 4; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_context_switches(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[5 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 5) { |
| max_ordinal_ = 5; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_irq_preempts(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[6 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 6) { |
| max_ordinal_ = 6; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_yields(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[7 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 7) { |
| max_ordinal_ = 7; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_ints(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[8 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 8) { |
| max_ordinal_ = 8; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_timer_ints(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[9 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 9) { |
| max_ordinal_ = 9; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_timers(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[10 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 10) { |
| max_ordinal_ = 10; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_page_faults(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[11 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 11) { |
| max_ordinal_ = 11; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_exceptions(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[12 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 12) { |
| max_ordinal_ = 12; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_syscalls(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[13 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 13) { |
| max_ordinal_ = 13; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_reschedule_ipis(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[14 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 14) { |
| max_ordinal_ = 14; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_generic_ipis(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[15 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 15) { |
| max_ordinal_ = 15; |
| } |
| return std::move(*this); |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kMexecBroker_PerformMexec_Ordinal = 0x2db06f5f00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kMexecBroker_PerformMexec_GenOrdinal = 0x191f56222830486flu; |
| extern "C" const fidl_type_t fuchsia_kernel_MexecBrokerPerformMexecRequestTable; |
| extern "C" const fidl_type_t fuchsia_kernel_MexecBrokerPerformMexecResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_kernel_MexecBrokerPerformMexecResponseTable; |
| |
| } // namespace |
| |
| MexecBroker::ResultOf::PerformMexec_Impl::PerformMexec_Impl(::zx::unowned_channel _client_end, ::zx::vmo kernel, ::zx::vmo bootdata) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<PerformMexecRequest, ::fidl::MessageDirection::kSending>(); |
| ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined; |
| auto& _write_bytes_array = _write_bytes_inlined; |
| uint8_t* _write_bytes = _write_bytes_array.view().data(); |
| memset(_write_bytes, 0, PerformMexecRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<PerformMexecRequest*>(_write_bytes); |
| _request.kernel = std::move(kernel); |
| _request.bootdata = std::move(bootdata); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(PerformMexecRequest)); |
| ::fidl::DecodedMessage<PerformMexecRequest> _decoded_request(std::move(_request_bytes)); |
| Super::operator=( |
| MexecBroker::InPlace::PerformMexec(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| MexecBroker::ResultOf::PerformMexec MexecBroker::SyncClient::PerformMexec(::zx::vmo kernel, ::zx::vmo bootdata) { |
| return ResultOf::PerformMexec(::zx::unowned_channel(this->channel_), std::move(kernel), std::move(bootdata)); |
| } |
| |
| MexecBroker::ResultOf::PerformMexec MexecBroker::Call::PerformMexec(::zx::unowned_channel _client_end, ::zx::vmo kernel, ::zx::vmo bootdata) { |
| return ResultOf::PerformMexec(std::move(_client_end), std::move(kernel), std::move(bootdata)); |
| } |
| |
| |
| MexecBroker::UnownedResultOf::PerformMexec_Impl::PerformMexec_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo kernel, ::zx::vmo bootdata) { |
| if (_request_buffer.capacity() < PerformMexecRequest::PrimarySize) { |
| Super::status_ = ZX_ERR_BUFFER_TOO_SMALL; |
| Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall; |
| return; |
| } |
| memset(_request_buffer.data(), 0, PerformMexecRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<PerformMexecRequest*>(_request_buffer.data()); |
| _request.kernel = std::move(kernel); |
| _request.bootdata = std::move(bootdata); |
| _request_buffer.set_actual(sizeof(PerformMexecRequest)); |
| ::fidl::DecodedMessage<PerformMexecRequest> _decoded_request(std::move(_request_buffer)); |
| Super::operator=( |
| MexecBroker::InPlace::PerformMexec(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| MexecBroker::UnownedResultOf::PerformMexec MexecBroker::SyncClient::PerformMexec(::fidl::BytePart _request_buffer, ::zx::vmo kernel, ::zx::vmo bootdata) { |
| return UnownedResultOf::PerformMexec(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(kernel), std::move(bootdata)); |
| } |
| |
| MexecBroker::UnownedResultOf::PerformMexec MexecBroker::Call::PerformMexec(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo kernel, ::zx::vmo bootdata) { |
| return UnownedResultOf::PerformMexec(std::move(_client_end), std::move(_request_buffer), std::move(kernel), std::move(bootdata)); |
| } |
| |
| ::fidl::internal::StatusAndError MexecBroker::InPlace::PerformMexec(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<PerformMexecRequest> params) { |
| MexecBroker::SetTransactionHeaderFor::PerformMexecRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::internal::StatusAndError::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| zx_status_t _write_status = |
| ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message)); |
| if (_write_status != ZX_OK) { |
| return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed); |
| } else { |
| return ::fidl::internal::StatusAndError(ZX_OK, nullptr); |
| } |
| } |
| |
| |
| bool MexecBroker::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) { |
| if (msg->num_bytes < sizeof(fidl_message_header_t)) { |
| zx_handle_close_many(msg->handles, msg->num_handles); |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes); |
| zx_status_t status = fidl_validate_txn_header(hdr); |
| if (status != ZX_OK) { |
| txn->Close(status); |
| return true; |
| } |
| switch (hdr->ordinal) { |
| case kMexecBroker_PerformMexec_Ordinal: |
| case kMexecBroker_PerformMexec_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<PerformMexecRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->PerformMexec(std::move(message->kernel), std::move(message->bootdata), |
| Interface::PerformMexecCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool MexecBroker::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) { |
| bool found = TryDispatch(impl, msg, txn); |
| if (!found) { |
| zx_handle_close_many(msg->handles, msg->num_handles); |
| txn->Close(ZX_ERR_NOT_SUPPORTED); |
| } |
| return found; |
| } |
| |
| |
| |
| void MexecBroker::SetTransactionHeaderFor::PerformMexecRequest(const ::fidl::DecodedMessage<MexecBroker::PerformMexecRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kMexecBroker_PerformMexec_GenOrdinal); |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kDebugBroker_SendDebugCommand_Ordinal = 0x3f05f48400000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kDebugBroker_SendDebugCommand_GenOrdinal = 0x1ee270f83b5d6ff6lu; |
| extern "C" const fidl_type_t fuchsia_kernel_DebugBrokerSendDebugCommandRequestTable; |
| extern "C" const fidl_type_t fuchsia_kernel_DebugBrokerSendDebugCommandResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_kernel_DebugBrokerSendDebugCommandResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kDebugBroker_SetTracingEnabled_Ordinal = 0x273cf2d900000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kDebugBroker_SetTracingEnabled_GenOrdinal = 0x12e368d05329b30elu; |
| extern "C" const fidl_type_t fuchsia_kernel_DebugBrokerSetTracingEnabledRequestTable; |
| extern "C" const fidl_type_t fuchsia_kernel_DebugBrokerSetTracingEnabledResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_kernel_DebugBrokerSetTracingEnabledResponseTable; |
| |
| } // namespace |
| template <> |
| DebugBroker::ResultOf::SendDebugCommand_Impl<DebugBroker::SendDebugCommandResponse>::SendDebugCommand_Impl(::zx::unowned_channel _client_end, ::fidl::StringView command) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SendDebugCommandRequest, ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>(); |
| auto& _write_bytes_array = *_write_bytes_boxed; |
| SendDebugCommandRequest _request = {}; |
| _request.command = std::move(command); |
| auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view()); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<SendDebugCommandRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| DebugBroker::InPlace::SendDebugCommand(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| DebugBroker::ResultOf::SendDebugCommand DebugBroker::SyncClient::SendDebugCommand(::fidl::StringView command) { |
| return ResultOf::SendDebugCommand(::zx::unowned_channel(this->channel_), std::move(command)); |
| } |
| |
| DebugBroker::ResultOf::SendDebugCommand DebugBroker::Call::SendDebugCommand(::zx::unowned_channel _client_end, ::fidl::StringView command) { |
| return ResultOf::SendDebugCommand(std::move(_client_end), std::move(command)); |
| } |
| |
| template <> |
| DebugBroker::UnownedResultOf::SendDebugCommand_Impl<DebugBroker::SendDebugCommandResponse>::SendDebugCommand_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView command, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < SendDebugCommandRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<SendDebugCommandResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| SendDebugCommandRequest _request = {}; |
| _request.command = std::move(command); |
| auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer)); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<SendDebugCommandRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| DebugBroker::InPlace::SendDebugCommand(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| DebugBroker::UnownedResultOf::SendDebugCommand DebugBroker::SyncClient::SendDebugCommand(::fidl::BytePart _request_buffer, ::fidl::StringView command, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::SendDebugCommand(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(command), std::move(_response_buffer)); |
| } |
| |
| DebugBroker::UnownedResultOf::SendDebugCommand DebugBroker::Call::SendDebugCommand(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView command, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::SendDebugCommand(std::move(_client_end), std::move(_request_buffer), std::move(command), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<DebugBroker::SendDebugCommandResponse> DebugBroker::InPlace::SendDebugCommand(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SendDebugCommandRequest> params, ::fidl::BytePart response_buffer) { |
| DebugBroker::SetTransactionHeaderFor::SendDebugCommandRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DebugBroker::SendDebugCommandResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<SendDebugCommandRequest, SendDebugCommandResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DebugBroker::SendDebugCommandResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| DebugBroker::ResultOf::SetTracingEnabled_Impl<DebugBroker::SetTracingEnabledResponse>::SetTracingEnabled_Impl(::zx::unowned_channel _client_end, bool enabled) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetTracingEnabledRequest, ::fidl::MessageDirection::kSending>(); |
| ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined; |
| auto& _write_bytes_array = _write_bytes_inlined; |
| uint8_t* _write_bytes = _write_bytes_array.view().data(); |
| memset(_write_bytes, 0, SetTracingEnabledRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<SetTracingEnabledRequest*>(_write_bytes); |
| _request.enabled = std::move(enabled); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetTracingEnabledRequest)); |
| ::fidl::DecodedMessage<SetTracingEnabledRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| DebugBroker::InPlace::SetTracingEnabled(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| DebugBroker::ResultOf::SetTracingEnabled DebugBroker::SyncClient::SetTracingEnabled(bool enabled) { |
| return ResultOf::SetTracingEnabled(::zx::unowned_channel(this->channel_), std::move(enabled)); |
| } |
| |
| DebugBroker::ResultOf::SetTracingEnabled DebugBroker::Call::SetTracingEnabled(::zx::unowned_channel _client_end, bool enabled) { |
| return ResultOf::SetTracingEnabled(std::move(_client_end), std::move(enabled)); |
| } |
| |
| template <> |
| DebugBroker::UnownedResultOf::SetTracingEnabled_Impl<DebugBroker::SetTracingEnabledResponse>::SetTracingEnabled_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < SetTracingEnabledRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<SetTracingEnabledResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| memset(_request_buffer.data(), 0, SetTracingEnabledRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<SetTracingEnabledRequest*>(_request_buffer.data()); |
| _request.enabled = std::move(enabled); |
| _request_buffer.set_actual(sizeof(SetTracingEnabledRequest)); |
| ::fidl::DecodedMessage<SetTracingEnabledRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| DebugBroker::InPlace::SetTracingEnabled(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| DebugBroker::UnownedResultOf::SetTracingEnabled DebugBroker::SyncClient::SetTracingEnabled(::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::SetTracingEnabled(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(enabled), std::move(_response_buffer)); |
| } |
| |
| DebugBroker::UnownedResultOf::SetTracingEnabled DebugBroker::Call::SetTracingEnabled(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::SetTracingEnabled(std::move(_client_end), std::move(_request_buffer), std::move(enabled), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<DebugBroker::SetTracingEnabledResponse> DebugBroker::InPlace::SetTracingEnabled(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetTracingEnabledRequest> params, ::fidl::BytePart response_buffer) { |
| DebugBroker::SetTransactionHeaderFor::SetTracingEnabledRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DebugBroker::SetTracingEnabledResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<SetTracingEnabledRequest, SetTracingEnabledResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DebugBroker::SetTracingEnabledResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool DebugBroker::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) { |
| if (msg->num_bytes < sizeof(fidl_message_header_t)) { |
| zx_handle_close_many(msg->handles, msg->num_handles); |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes); |
| zx_status_t status = fidl_validate_txn_header(hdr); |
| if (status != ZX_OK) { |
| txn->Close(status); |
| return true; |
| } |
| switch (hdr->ordinal) { |
| case kDebugBroker_SendDebugCommand_Ordinal: |
| case kDebugBroker_SendDebugCommand_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<SendDebugCommandRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->SendDebugCommand(std::move(message->command), |
| Interface::SendDebugCommandCompleter::Sync(txn)); |
| return true; |
| } |
| case kDebugBroker_SetTracingEnabled_Ordinal: |
| case kDebugBroker_SetTracingEnabled_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<SetTracingEnabledRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->SetTracingEnabled(std::move(message->enabled), |
| Interface::SetTracingEnabledCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool DebugBroker::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) { |
| bool found = TryDispatch(impl, msg, txn); |
| if (!found) { |
| zx_handle_close_many(msg->handles, msg->num_handles); |
| txn->Close(ZX_ERR_NOT_SUPPORTED); |
| } |
| return found; |
| } |
| |
| |
| void DebugBroker::Interface::SendDebugCommandCompleterBase::Reply(int32_t status) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SendDebugCommandResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<SendDebugCommandResponse*>(_write_bytes); |
| DebugBroker::SetTransactionHeaderFor::SendDebugCommandResponse( |
| ::fidl::DecodedMessage<SendDebugCommandResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| SendDebugCommandResponse::PrimarySize, |
| SendDebugCommandResponse::PrimarySize))); |
| _response.status = std::move(status); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SendDebugCommandResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<SendDebugCommandResponse>(std::move(_response_bytes))); |
| } |
| |
| void DebugBroker::Interface::SendDebugCommandCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) { |
| if (_buffer.capacity() < SendDebugCommandResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<SendDebugCommandResponse*>(_buffer.data()); |
| DebugBroker::SetTransactionHeaderFor::SendDebugCommandResponse( |
| ::fidl::DecodedMessage<SendDebugCommandResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| SendDebugCommandResponse::PrimarySize, |
| SendDebugCommandResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _buffer.set_actual(sizeof(SendDebugCommandResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<SendDebugCommandResponse>(std::move(_buffer))); |
| } |
| |
| void DebugBroker::Interface::SendDebugCommandCompleterBase::Reply(::fidl::DecodedMessage<SendDebugCommandResponse> params) { |
| DebugBroker::SetTransactionHeaderFor::SendDebugCommandResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| void DebugBroker::Interface::SetTracingEnabledCompleterBase::Reply(int32_t status) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetTracingEnabledResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<SetTracingEnabledResponse*>(_write_bytes); |
| DebugBroker::SetTransactionHeaderFor::SetTracingEnabledResponse( |
| ::fidl::DecodedMessage<SetTracingEnabledResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| SetTracingEnabledResponse::PrimarySize, |
| SetTracingEnabledResponse::PrimarySize))); |
| _response.status = std::move(status); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetTracingEnabledResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<SetTracingEnabledResponse>(std::move(_response_bytes))); |
| } |
| |
| void DebugBroker::Interface::SetTracingEnabledCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) { |
| if (_buffer.capacity() < SetTracingEnabledResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<SetTracingEnabledResponse*>(_buffer.data()); |
| DebugBroker::SetTransactionHeaderFor::SetTracingEnabledResponse( |
| ::fidl::DecodedMessage<SetTracingEnabledResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| SetTracingEnabledResponse::PrimarySize, |
| SetTracingEnabledResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _buffer.set_actual(sizeof(SetTracingEnabledResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<SetTracingEnabledResponse>(std::move(_buffer))); |
| } |
| |
| void DebugBroker::Interface::SetTracingEnabledCompleterBase::Reply(::fidl::DecodedMessage<SetTracingEnabledResponse> params) { |
| DebugBroker::SetTransactionHeaderFor::SetTracingEnabledResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void DebugBroker::SetTransactionHeaderFor::SendDebugCommandRequest(const ::fidl::DecodedMessage<DebugBroker::SendDebugCommandRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugBroker_SendDebugCommand_GenOrdinal); |
| } |
| void DebugBroker::SetTransactionHeaderFor::SendDebugCommandResponse(const ::fidl::DecodedMessage<DebugBroker::SendDebugCommandResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugBroker_SendDebugCommand_GenOrdinal); |
| } |
| |
| void DebugBroker::SetTransactionHeaderFor::SetTracingEnabledRequest(const ::fidl::DecodedMessage<DebugBroker::SetTracingEnabledRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugBroker_SetTracingEnabled_GenOrdinal); |
| } |
| void DebugBroker::SetTransactionHeaderFor::SetTracingEnabledResponse(const ::fidl::DecodedMessage<DebugBroker::SetTracingEnabledResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugBroker_SetTracingEnabled_GenOrdinal); |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kCounter_GetInspectVmo_Ordinal = 0x1ba5957d00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kCounter_GetInspectVmo_GenOrdinal = 0x6ea9b2e6b2791b81lu; |
| extern "C" const fidl_type_t fuchsia_kernel_CounterGetInspectVmoRequestTable; |
| extern "C" const fidl_type_t fuchsia_kernel_CounterGetInspectVmoResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_kernel_CounterGetInspectVmoResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kCounter_UpdateInspectVmo_Ordinal = 0x4556672400000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kCounter_UpdateInspectVmo_GenOrdinal = 0x1d25eb7995a0539flu; |
| extern "C" const fidl_type_t fuchsia_kernel_CounterUpdateInspectVmoRequestTable; |
| extern "C" const fidl_type_t fuchsia_kernel_CounterUpdateInspectVmoResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_kernel_CounterUpdateInspectVmoResponseTable; |
| |
| } // namespace |
| template <> |
| Counter::ResultOf::GetInspectVmo_Impl<Counter::GetInspectVmoResponse>::GetInspectVmo_Impl(::zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInspectVmoRequest, ::fidl::MessageDirection::kSending>(); |
| ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined; |
| auto& _write_bytes_array = _write_bytes_inlined; |
| uint8_t* _write_bytes = _write_bytes_array.view().data(); |
| memset(_write_bytes, 0, GetInspectVmoRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInspectVmoRequest)); |
| ::fidl::DecodedMessage<GetInspectVmoRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| Counter::InPlace::GetInspectVmo(std::move(_client_end), Super::response_buffer())); |
| } |
| |
| Counter::ResultOf::GetInspectVmo Counter::SyncClient::GetInspectVmo() { |
| return ResultOf::GetInspectVmo(::zx::unowned_channel(this->channel_)); |
| } |
| |
| Counter::ResultOf::GetInspectVmo Counter::Call::GetInspectVmo(::zx::unowned_channel _client_end) { |
| return ResultOf::GetInspectVmo(std::move(_client_end)); |
| } |
| |
| template <> |
| Counter::UnownedResultOf::GetInspectVmo_Impl<Counter::GetInspectVmoResponse>::GetInspectVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInspectVmoRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, GetInspectVmoRequest::PrimarySize); |
| _request_buffer.set_actual(sizeof(GetInspectVmoRequest)); |
| ::fidl::DecodedMessage<GetInspectVmoRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| Counter::InPlace::GetInspectVmo(std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| Counter::UnownedResultOf::GetInspectVmo Counter::SyncClient::GetInspectVmo(::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::GetInspectVmo(::zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| Counter::UnownedResultOf::GetInspectVmo Counter::Call::GetInspectVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::GetInspectVmo(std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<Counter::GetInspectVmoResponse> Counter::InPlace::GetInspectVmo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = sizeof(GetInspectVmoRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<GetInspectVmoRequest> params(std::move(_request_buffer)); |
| Counter::SetTransactionHeaderFor::GetInspectVmoRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Counter::GetInspectVmoResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<GetInspectVmoRequest, GetInspectVmoResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Counter::GetInspectVmoResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| Counter::ResultOf::UpdateInspectVmo_Impl<Counter::UpdateInspectVmoResponse>::UpdateInspectVmo_Impl(::zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateInspectVmoRequest, ::fidl::MessageDirection::kSending>(); |
| ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined; |
| auto& _write_bytes_array = _write_bytes_inlined; |
| uint8_t* _write_bytes = _write_bytes_array.view().data(); |
| memset(_write_bytes, 0, UpdateInspectVmoRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(UpdateInspectVmoRequest)); |
| ::fidl::DecodedMessage<UpdateInspectVmoRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| Counter::InPlace::UpdateInspectVmo(std::move(_client_end), Super::response_buffer())); |
| } |
| |
| Counter::ResultOf::UpdateInspectVmo Counter::SyncClient::UpdateInspectVmo() { |
| return ResultOf::UpdateInspectVmo(::zx::unowned_channel(this->channel_)); |
| } |
| |
| Counter::ResultOf::UpdateInspectVmo Counter::Call::UpdateInspectVmo(::zx::unowned_channel _client_end) { |
| return ResultOf::UpdateInspectVmo(std::move(_client_end)); |
| } |
| |
| template <> |
| Counter::UnownedResultOf::UpdateInspectVmo_Impl<Counter::UpdateInspectVmoResponse>::UpdateInspectVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(UpdateInspectVmoRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, UpdateInspectVmoRequest::PrimarySize); |
| _request_buffer.set_actual(sizeof(UpdateInspectVmoRequest)); |
| ::fidl::DecodedMessage<UpdateInspectVmoRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| Counter::InPlace::UpdateInspectVmo(std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| Counter::UnownedResultOf::UpdateInspectVmo Counter::SyncClient::UpdateInspectVmo(::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::UpdateInspectVmo(::zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| Counter::UnownedResultOf::UpdateInspectVmo Counter::Call::UpdateInspectVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::UpdateInspectVmo(std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<Counter::UpdateInspectVmoResponse> Counter::InPlace::UpdateInspectVmo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = sizeof(UpdateInspectVmoRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<UpdateInspectVmoRequest> params(std::move(_request_buffer)); |
| Counter::SetTransactionHeaderFor::UpdateInspectVmoRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Counter::UpdateInspectVmoResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<UpdateInspectVmoRequest, UpdateInspectVmoResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Counter::UpdateInspectVmoResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool Counter::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) { |
| if (msg->num_bytes < sizeof(fidl_message_header_t)) { |
| zx_handle_close_many(msg->handles, msg->num_handles); |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes); |
| zx_status_t status = fidl_validate_txn_header(hdr); |
| if (status != ZX_OK) { |
| txn->Close(status); |
| return true; |
| } |
| switch (hdr->ordinal) { |
| case kCounter_GetInspectVmo_Ordinal: |
| case kCounter_GetInspectVmo_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<GetInspectVmoRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| impl->GetInspectVmo( |
| Interface::GetInspectVmoCompleter::Sync(txn)); |
| return true; |
| } |
| case kCounter_UpdateInspectVmo_Ordinal: |
| case kCounter_UpdateInspectVmo_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<UpdateInspectVmoRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| impl->UpdateInspectVmo( |
| Interface::UpdateInspectVmoCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool Counter::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) { |
| bool found = TryDispatch(impl, msg, txn); |
| if (!found) { |
| zx_handle_close_many(msg->handles, msg->num_handles); |
| txn->Close(ZX_ERR_NOT_SUPPORTED); |
| } |
| return found; |
| } |
| |
| |
| void Counter::Interface::GetInspectVmoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::mem::Buffer buffer) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInspectVmoResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<GetInspectVmoResponse*>(_write_bytes); |
| Counter::SetTransactionHeaderFor::GetInspectVmoResponse( |
| ::fidl::DecodedMessage<GetInspectVmoResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetInspectVmoResponse::PrimarySize, |
| GetInspectVmoResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _response.buffer = std::move(buffer); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInspectVmoResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetInspectVmoResponse>(std::move(_response_bytes))); |
| } |
| |
| void Counter::Interface::GetInspectVmoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::mem::Buffer buffer) { |
| if (_buffer.capacity() < GetInspectVmoResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<GetInspectVmoResponse*>(_buffer.data()); |
| Counter::SetTransactionHeaderFor::GetInspectVmoResponse( |
| ::fidl::DecodedMessage<GetInspectVmoResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetInspectVmoResponse::PrimarySize, |
| GetInspectVmoResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _response.buffer = std::move(buffer); |
| _buffer.set_actual(sizeof(GetInspectVmoResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetInspectVmoResponse>(std::move(_buffer))); |
| } |
| |
| void Counter::Interface::GetInspectVmoCompleterBase::Reply(::fidl::DecodedMessage<GetInspectVmoResponse> params) { |
| Counter::SetTransactionHeaderFor::GetInspectVmoResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| void Counter::Interface::UpdateInspectVmoCompleterBase::Reply(int32_t status) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateInspectVmoResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<UpdateInspectVmoResponse*>(_write_bytes); |
| Counter::SetTransactionHeaderFor::UpdateInspectVmoResponse( |
| ::fidl::DecodedMessage<UpdateInspectVmoResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| UpdateInspectVmoResponse::PrimarySize, |
| UpdateInspectVmoResponse::PrimarySize))); |
| _response.status = std::move(status); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(UpdateInspectVmoResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<UpdateInspectVmoResponse>(std::move(_response_bytes))); |
| } |
| |
| void Counter::Interface::UpdateInspectVmoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) { |
| if (_buffer.capacity() < UpdateInspectVmoResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<UpdateInspectVmoResponse*>(_buffer.data()); |
| Counter::SetTransactionHeaderFor::UpdateInspectVmoResponse( |
| ::fidl::DecodedMessage<UpdateInspectVmoResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| UpdateInspectVmoResponse::PrimarySize, |
| UpdateInspectVmoResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _buffer.set_actual(sizeof(UpdateInspectVmoResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<UpdateInspectVmoResponse>(std::move(_buffer))); |
| } |
| |
| void Counter::Interface::UpdateInspectVmoCompleterBase::Reply(::fidl::DecodedMessage<UpdateInspectVmoResponse> params) { |
| Counter::SetTransactionHeaderFor::UpdateInspectVmoResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void Counter::SetTransactionHeaderFor::GetInspectVmoRequest(const ::fidl::DecodedMessage<Counter::GetInspectVmoRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kCounter_GetInspectVmo_GenOrdinal); |
| } |
| void Counter::SetTransactionHeaderFor::GetInspectVmoResponse(const ::fidl::DecodedMessage<Counter::GetInspectVmoResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kCounter_GetInspectVmo_GenOrdinal); |
| } |
| |
| void Counter::SetTransactionHeaderFor::UpdateInspectVmoRequest(const ::fidl::DecodedMessage<Counter::UpdateInspectVmoRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kCounter_UpdateInspectVmo_GenOrdinal); |
| } |
| void Counter::SetTransactionHeaderFor::UpdateInspectVmoResponse(const ::fidl::DecodedMessage<Counter::UpdateInspectVmoResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kCounter_UpdateInspectVmo_GenOrdinal); |
| } |
| |
| ::llcpp::fuchsia::kernel::MemoryStats::Builder MemoryStats::Build() { |
| return MemoryStats::Builder(); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_total_bytes(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[1 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 1) { |
| max_ordinal_ = 1; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_free_bytes(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[2 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 2) { |
| max_ordinal_ = 2; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_wired_bytes(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[3 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 3) { |
| max_ordinal_ = 3; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_total_heap_bytes(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[4 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 4) { |
| max_ordinal_ = 4; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_free_heap_bytes(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[5 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 5) { |
| max_ordinal_ = 5; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_vmo_bytes(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[6 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 6) { |
| max_ordinal_ = 6; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_mmu_overhead_bytes(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[7 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 7) { |
| max_ordinal_ = 7; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_ipc_bytes(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[8 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 8) { |
| max_ordinal_ = 8; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_other_bytes(uint64_t* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[9 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 9) { |
| max_ordinal_ = 9; |
| } |
| return std::move(*this); |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kStats_GetMemoryStats_Ordinal = 0x3f74d35b00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kStats_GetMemoryStats_GenOrdinal = 0x686677932ae41074lu; |
| extern "C" const fidl_type_t fuchsia_kernel_StatsGetMemoryStatsRequestTable; |
| extern "C" const fidl_type_t fuchsia_kernel_StatsGetMemoryStatsResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_kernel_StatsGetMemoryStatsResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kStats_GetCpuStats_Ordinal = 0x34c546a700000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kStats_GetCpuStats_GenOrdinal = 0x470e2684ca1ca19elu; |
| extern "C" const fidl_type_t fuchsia_kernel_StatsGetCpuStatsRequestTable; |
| extern "C" const fidl_type_t fuchsia_kernel_StatsGetCpuStatsResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_kernel_StatsGetCpuStatsResponseTable; |
| |
| } // namespace |
| template <> |
| Stats::ResultOf::GetMemoryStats_Impl<Stats::GetMemoryStatsResponse>::GetMemoryStats_Impl(::zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMemoryStatsRequest, ::fidl::MessageDirection::kSending>(); |
| ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined; |
| auto& _write_bytes_array = _write_bytes_inlined; |
| uint8_t* _write_bytes = _write_bytes_array.view().data(); |
| memset(_write_bytes, 0, GetMemoryStatsRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetMemoryStatsRequest)); |
| ::fidl::DecodedMessage<GetMemoryStatsRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| Stats::InPlace::GetMemoryStats(std::move(_client_end), Super::response_buffer())); |
| } |
| |
| Stats::ResultOf::GetMemoryStats Stats::SyncClient::GetMemoryStats() { |
| return ResultOf::GetMemoryStats(::zx::unowned_channel(this->channel_)); |
| } |
| |
| Stats::ResultOf::GetMemoryStats Stats::Call::GetMemoryStats(::zx::unowned_channel _client_end) { |
| return ResultOf::GetMemoryStats(std::move(_client_end)); |
| } |
| |
| template <> |
| Stats::UnownedResultOf::GetMemoryStats_Impl<Stats::GetMemoryStatsResponse>::GetMemoryStats_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetMemoryStatsRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, GetMemoryStatsRequest::PrimarySize); |
| _request_buffer.set_actual(sizeof(GetMemoryStatsRequest)); |
| ::fidl::DecodedMessage<GetMemoryStatsRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| Stats::InPlace::GetMemoryStats(std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| Stats::UnownedResultOf::GetMemoryStats Stats::SyncClient::GetMemoryStats(::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::GetMemoryStats(::zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| Stats::UnownedResultOf::GetMemoryStats Stats::Call::GetMemoryStats(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::GetMemoryStats(std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<Stats::GetMemoryStatsResponse> Stats::InPlace::GetMemoryStats(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = sizeof(GetMemoryStatsRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<GetMemoryStatsRequest> params(std::move(_request_buffer)); |
| Stats::SetTransactionHeaderFor::GetMemoryStatsRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Stats::GetMemoryStatsResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<GetMemoryStatsRequest, GetMemoryStatsResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Stats::GetMemoryStatsResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| Stats::ResultOf::GetCpuStats_Impl<Stats::GetCpuStatsResponse>::GetCpuStats_Impl(::zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCpuStatsRequest, ::fidl::MessageDirection::kSending>(); |
| ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined; |
| auto& _write_bytes_array = _write_bytes_inlined; |
| uint8_t* _write_bytes = _write_bytes_array.view().data(); |
| memset(_write_bytes, 0, GetCpuStatsRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetCpuStatsRequest)); |
| ::fidl::DecodedMessage<GetCpuStatsRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| Stats::InPlace::GetCpuStats(std::move(_client_end), Super::response_buffer())); |
| } |
| |
| Stats::ResultOf::GetCpuStats Stats::SyncClient::GetCpuStats() { |
| return ResultOf::GetCpuStats(::zx::unowned_channel(this->channel_)); |
| } |
| |
| Stats::ResultOf::GetCpuStats Stats::Call::GetCpuStats(::zx::unowned_channel _client_end) { |
| return ResultOf::GetCpuStats(std::move(_client_end)); |
| } |
| |
| template <> |
| Stats::UnownedResultOf::GetCpuStats_Impl<Stats::GetCpuStatsResponse>::GetCpuStats_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetCpuStatsRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, GetCpuStatsRequest::PrimarySize); |
| _request_buffer.set_actual(sizeof(GetCpuStatsRequest)); |
| ::fidl::DecodedMessage<GetCpuStatsRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| Stats::InPlace::GetCpuStats(std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| Stats::UnownedResultOf::GetCpuStats Stats::SyncClient::GetCpuStats(::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::GetCpuStats(::zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| Stats::UnownedResultOf::GetCpuStats Stats::Call::GetCpuStats(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::GetCpuStats(std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<Stats::GetCpuStatsResponse> Stats::InPlace::GetCpuStats(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = sizeof(GetCpuStatsRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<GetCpuStatsRequest> params(std::move(_request_buffer)); |
| Stats::SetTransactionHeaderFor::GetCpuStatsRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Stats::GetCpuStatsResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<GetCpuStatsRequest, GetCpuStatsResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Stats::GetCpuStatsResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool Stats::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) { |
| if (msg->num_bytes < sizeof(fidl_message_header_t)) { |
| zx_handle_close_many(msg->handles, msg->num_handles); |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes); |
| zx_status_t status = fidl_validate_txn_header(hdr); |
| if (status != ZX_OK) { |
| txn->Close(status); |
| return true; |
| } |
| switch (hdr->ordinal) { |
| case kStats_GetMemoryStats_Ordinal: |
| case kStats_GetMemoryStats_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<GetMemoryStatsRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| impl->GetMemoryStats( |
| Interface::GetMemoryStatsCompleter::Sync(txn)); |
| return true; |
| } |
| case kStats_GetCpuStats_Ordinal: |
| case kStats_GetCpuStats_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<GetCpuStatsRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| impl->GetCpuStats( |
| Interface::GetCpuStatsCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool Stats::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) { |
| bool found = TryDispatch(impl, msg, txn); |
| if (!found) { |
| zx_handle_close_many(msg->handles, msg->num_handles); |
| txn->Close(ZX_ERR_NOT_SUPPORTED); |
| } |
| return found; |
| } |
| |
| |
| void Stats::Interface::GetMemoryStatsCompleterBase::Reply(::llcpp::fuchsia::kernel::MemoryStats stats) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMemoryStatsResponse, ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]); |
| uint8_t* _write_bytes = _write_bytes_unique_ptr.get(); |
| GetMemoryStatsResponse _response = {}; |
| Stats::SetTransactionHeaderFor::GetMemoryStatsResponse( |
| ::fidl::DecodedMessage<GetMemoryStatsResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetMemoryStatsResponse::PrimarySize, |
| GetMemoryStatsResponse::PrimarySize))); |
| _response.stats = std::move(stats); |
| auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes, |
| _kWriteAllocSize)); |
| if (_linearize_result.status != ZX_OK) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| CompleterBase::SendReply(std::move(_linearize_result.message)); |
| } |
| |
| void Stats::Interface::GetMemoryStatsCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::kernel::MemoryStats stats) { |
| if (_buffer.capacity() < GetMemoryStatsResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| GetMemoryStatsResponse _response = {}; |
| Stats::SetTransactionHeaderFor::GetMemoryStatsResponse( |
| ::fidl::DecodedMessage<GetMemoryStatsResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetMemoryStatsResponse::PrimarySize, |
| GetMemoryStatsResponse::PrimarySize))); |
| _response.stats = std::move(stats); |
| auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer)); |
| if (_linearize_result.status != ZX_OK) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| CompleterBase::SendReply(std::move(_linearize_result.message)); |
| } |
| |
| void Stats::Interface::GetMemoryStatsCompleterBase::Reply(::fidl::DecodedMessage<GetMemoryStatsResponse> params) { |
| Stats::SetTransactionHeaderFor::GetMemoryStatsResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| void Stats::Interface::GetCpuStatsCompleterBase::Reply(::llcpp::fuchsia::kernel::CpuStats stats) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCpuStatsResponse, ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]); |
| uint8_t* _write_bytes = _write_bytes_unique_ptr.get(); |
| GetCpuStatsResponse _response = {}; |
| Stats::SetTransactionHeaderFor::GetCpuStatsResponse( |
| ::fidl::DecodedMessage<GetCpuStatsResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetCpuStatsResponse::PrimarySize, |
| GetCpuStatsResponse::PrimarySize))); |
| _response.stats = std::move(stats); |
| auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes, |
| _kWriteAllocSize)); |
| if (_linearize_result.status != ZX_OK) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| CompleterBase::SendReply(std::move(_linearize_result.message)); |
| } |
| |
| void Stats::Interface::GetCpuStatsCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::kernel::CpuStats stats) { |
| if (_buffer.capacity() < GetCpuStatsResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| GetCpuStatsResponse _response = {}; |
| Stats::SetTransactionHeaderFor::GetCpuStatsResponse( |
| ::fidl::DecodedMessage<GetCpuStatsResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetCpuStatsResponse::PrimarySize, |
| GetCpuStatsResponse::PrimarySize))); |
| _response.stats = std::move(stats); |
| auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer)); |
| if (_linearize_result.status != ZX_OK) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| CompleterBase::SendReply(std::move(_linearize_result.message)); |
| } |
| |
| void Stats::Interface::GetCpuStatsCompleterBase::Reply(::fidl::DecodedMessage<GetCpuStatsResponse> params) { |
| Stats::SetTransactionHeaderFor::GetCpuStatsResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void Stats::SetTransactionHeaderFor::GetMemoryStatsRequest(const ::fidl::DecodedMessage<Stats::GetMemoryStatsRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kStats_GetMemoryStats_GenOrdinal); |
| } |
| void Stats::SetTransactionHeaderFor::GetMemoryStatsResponse(const ::fidl::DecodedMessage<Stats::GetMemoryStatsResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kStats_GetMemoryStats_GenOrdinal); |
| } |
| |
| void Stats::SetTransactionHeaderFor::GetCpuStatsRequest(const ::fidl::DecodedMessage<Stats::GetCpuStatsRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kStats_GetCpuStats_GenOrdinal); |
| } |
| void Stats::SetTransactionHeaderFor::GetCpuStatsResponse(const ::fidl::DecodedMessage<Stats::GetCpuStatsResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kStats_GetCpuStats_GenOrdinal); |
| } |
| |
| } // namespace kernel |
| } // namespace fuchsia |
| } // namespace llcpp |