sdk/lib/ld/fuchsia-debugdata.cc - fuchsia - Git at Google

 // Copyright 2024 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "lib/ld/fuchsia-debugdata.h"

 #include <lib/fidl/txn_header.h>
 #include <zircon/fidl.h>

 #include <array>
 #include <string_view>
 #include <type_traits>

 namespace ld {

 // These are minimal hand-rolled marshalling functions for the one-way FIDL
 // fuchsia.debugdata.Publisher/Publish, fuchsia.io.Directory/Open, and
 // fuchsia.unknown.Cloneable/Clone messages.
 //
 // This code marshals FIDL wire format just as FIDL bindings would, but avoids
 // the generated FIDL C++ bindings code because it is too heavy-weight for use
 // in low-level environments.  This code uses direct marshalling code in local
 // stack buffers of minimal size, with no dynamic allocation.

 // TODO(https://fxbug.dev/42072760): This should be generated by Zither.

 namespace {

 constexpr uint64_t fuchsia_io_MAX_PATH_LENGTH = 4095;
 constexpr uint64_t fuchsia_io_MAX_NAME_LENGTH = 255;
 constexpr uint64_t fuchsia_io_Flags_PROTOCOL_SERVICE = 0x000100000000;
 constexpr uint64_t fuchsia_io_DirectoryOpen_Ordinal = 0x568ddcb9a9cbb6d9;

 constexpr std::string_view fuchsia_debugdata_Publisher_Name = "fuchsia.debugdata.Publisher";
 static_assert(fuchsia_debugdata_Publisher_Name.size() <= fuchsia_io_MAX_PATH_LENGTH);
 constexpr uint64_t fuchsia_debugdata_PublisherPublish_Ordinal = 0xf52f8806121e066;

 constexpr uint64_t fuchsia_unknown_CloneableClone_Ordinal = 0x20d8a7aba2168a79;

 fidl_message_header_t TxnHeader(uint64_t ordinal) {
   fidl_message_header_t hdr;
   fidl_init_txn_header(&hdr, 0, ordinal, 0);
   return hdr;
 }

 // To use no more stack space than needed for the request, this is specifically
 // initialized with the exact constant path string that will be needed.
 struct alignas(FIDL_ALIGNMENT) fuchsia_io_DirectoryOpenRequestForDebugdata {
   fuchsia_io_DirectoryOpenRequestForDebugdata() {
     fuchsia_debugdata_Publisher_Name.copy(path_buffer.data(), path_buffer.size());
   }

   size_t size_bytes() const { return FIDL_ALIGN(sizeof(fixed) + fixed.path.size); }

   struct alignas(FIDL_ALIGNMENT) {
     fidl_message_header_t hdr = TxnHeader(fuchsia_io_DirectoryOpen_Ordinal);
     fidl_string_t path = {
         .size = fuchsia_debugdata_Publisher_Name.size(),
         .data = reinterpret_cast<char*>(FIDL_ALLOC_PRESENT),
     };
     uint64_t flags = fuchsia_io_Flags_PROTOCOL_SERVICE;
     fidl_table_t options = {fidl_vector_t{
         .count = 0,
         .data = reinterpret_cast<void*>(FIDL_ALLOC_PRESENT),
     }};
     zx_handle_t object = FIDL_HANDLE_PRESENT;
     uint32_t padding = 0;
   } fixed;
   std::array<char, fuchsia_debugdata_Publisher_Name.size()> path_buffer;
   const std::byte padding[FIDL_ALIGN(fuchsia_debugdata_Publisher_Name.size()) -
                           fuchsia_debugdata_Publisher_Name.size()] = {};
 };

 struct alignas(FIDL_ALIGNMENT) fuchsia_debugdata_PublisherPublishRequestMessage {
   size_t size_bytes() const { return FIDL_ALIGN(sizeof(fixed) + fixed.data_sink.size); }

   struct alignas(FIDL_ALIGNMENT) {
     fidl_message_header_t hdr;
     fidl_string_t data_sink;
     zx_handle_t data;
     zx_handle_t vmo_token;
   } fixed;
   std::array<char, fuchsia_io_MAX_NAME_LENGTH> data_sink_buffer{};
   const std::byte padding[FIDL_ALIGN(fuchsia_io_MAX_NAME_LENGTH) - fuchsia_io_MAX_NAME_LENGTH] = {};
 };

 struct alignas(FIDL_ALIGNMENT) fuchsia_unknown_CloneableCloneRequest {
   static constexpr size_t size_bytes() { return sizeof(fuchsia_unknown_CloneableCloneRequest); }

   fidl_message_header_t hdr = TxnHeader(fuchsia_unknown_CloneableClone_Ordinal);
   zx_handle_t request = FIDL_HANDLE_PRESENT;
   uint32_t padding = 0;
 };

 template <class Request, size_t N>
 zx::result<> SendMessage(zx::unowned_channel client_end, const Request& request,
                          const std::array<zx_handle_t, N>& handles)
   requires std::has_unique_object_representations_v<Request>
 {
   const uint32_t nbytes = static_cast<uint32_t>(request.size_bytes());
   const uint32_t nhandles = static_cast<uint32_t>(handles.size());
   return zx::make_result(client_end->write(0u, &request, nbytes, handles.data(), nhandles));
 }

 zx::result<> fuchsia_io_DirectoryOpen_fuchsia_debugdata_Publisher(zx::unowned_channel client_end,
                                                                   zx::channel server_end) {
   return SendMessage(client_end->borrow(), fuchsia_io_DirectoryOpenRequestForDebugdata{},
                      std::array{server_end.release()});
 }

 zx::result<> fuchsia_debugdata_PublisherPublish(zx::unowned_channel client_end,
                                                 std::string_view data_sink, zx::vmo data,
                                                 zx::eventpair vmo_token) {
   fuchsia_debugdata_PublisherPublishRequestMessage request = {
       .fixed = {
           .hdr = TxnHeader(fuchsia_debugdata_PublisherPublish_Ordinal),
           .data_sink =
               {
                   .size = data_sink.size(),
                   .data = reinterpret_cast<char*>(FIDL_ALLOC_PRESENT),
               },
           .data = FIDL_HANDLE_PRESENT,
           .vmo_token = FIDL_HANDLE_PRESENT,
       }};
   if (data_sink.size() > request.data_sink_buffer.size()) [[unlikely]] {
     return zx::error{ZX_ERR_INVALID_ARGS};
   }
   data_sink.copy(request.data_sink_buffer.data(), request.data_sink_buffer.size());
   return SendMessage(client_end->borrow(), request,
                      std::array{data.release(), vmo_token.release()});
 }

 zx::result<> fuchsia_unknown_CloneableClone(zx::unowned_channel client_end,
                                             zx::channel server_end) {
   return SendMessage(client_end->borrow(), fuchsia_unknown_CloneableCloneRequest{},
                      std::array{server_end.release()});
 }

 }  // namespace

 zx::result<zx::eventpair> Debugdata::Publish(zx::unowned_channel svc_client_end) && {
   zx::channel debugdata_client_end, debugdata_server_end;
   if (zx_status_t status = zx::channel::create(0, &debugdata_client_end, &debugdata_server_end);
       status != ZX_OK) [[unlikely]] {
     return zx::error{status};
   }

   zx::eventpair vmo_token_client, vmo_token_server;
   if (zx_status_t status = zx::eventpair::create(0, &vmo_token_client, &vmo_token_server);
       status != ZX_OK) {
     return zx::error{status};
   }

   if (zx::result result = fuchsia_debugdata_PublisherPublish(
           debugdata_client_end.borrow(), data_sink_, std::move(data_), std::move(vmo_token_server));
       result.is_error()) [[unlikely]] {
     return result.take_error();
   }

   if (zx::result result = fuchsia_io_DirectoryOpen_fuchsia_debugdata_Publisher(
           svc_client_end->borrow(), std::move(debugdata_server_end));
       result.is_error()) {
     return result.take_error();
   }

   return zx::ok(std::move(vmo_token_client));
 }

 zx::result<Debugdata::Deferred> Debugdata::DeferredPublish() && {
   zx::channel svc_client_end, svc_server_end;
   if (zx_status_t status = zx::channel::create(0, &svc_client_end, &svc_server_end);
       status != ZX_OK) [[unlikely]] {
     return zx::error{status};
   }

   zx::result token = std::move(*this).Publish(svc_client_end.borrow());
   if (token.is_error()) [[unlikely]] {
     return token.take_error();
   }

   return zx::ok(Deferred{
       .vmo_token = *std::move(token),
       .svc_server_end = std::move(svc_server_end),
   });
 }

 zx::result<> Debugdata::Forward(zx::unowned_channel svc_client_end, zx::channel svc_server_end) {
   return fuchsia_unknown_CloneableClone(std::move(svc_client_end), std::move(svc_server_end));
 }

 }  // namespace ld
	// Copyright 2024 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "lib/ld/fuchsia-debugdata.h"

	#include <lib/fidl/txn_header.h>
	#include <zircon/fidl.h>

	#include <array>
	#include <string_view>
	#include <type_traits>

	namespace ld {

	// These are minimal hand-rolled marshalling functions for the one-way FIDL
	// fuchsia.debugdata.Publisher/Publish, fuchsia.io.Directory/Open, and
	// fuchsia.unknown.Cloneable/Clone messages.
	//
	// This code marshals FIDL wire format just as FIDL bindings would, but avoids
	// the generated FIDL C++ bindings code because it is too heavy-weight for use
	// in low-level environments. This code uses direct marshalling code in local
	// stack buffers of minimal size, with no dynamic allocation.

	// TODO(https://fxbug.dev/42072760): This should be generated by Zither.

	namespace {

	constexpr uint64_t fuchsia_io_MAX_PATH_LENGTH = 4095;
	constexpr uint64_t fuchsia_io_MAX_NAME_LENGTH = 255;
	constexpr uint64_t fuchsia_io_Flags_PROTOCOL_SERVICE = 0x000100000000;
	constexpr uint64_t fuchsia_io_DirectoryOpen_Ordinal = 0x568ddcb9a9cbb6d9;

	constexpr std::string_view fuchsia_debugdata_Publisher_Name = "fuchsia.debugdata.Publisher";
	static_assert(fuchsia_debugdata_Publisher_Name.size() <= fuchsia_io_MAX_PATH_LENGTH);
	constexpr uint64_t fuchsia_debugdata_PublisherPublish_Ordinal = 0xf52f8806121e066;

	constexpr uint64_t fuchsia_unknown_CloneableClone_Ordinal = 0x20d8a7aba2168a79;

	fidl_message_header_t TxnHeader(uint64_t ordinal) {
	fidl_message_header_t hdr;
	fidl_init_txn_header(&hdr, 0, ordinal, 0);
	return hdr;
	}

	// To use no more stack space than needed for the request, this is specifically
	// initialized with the exact constant path string that will be needed.
	struct alignas(FIDL_ALIGNMENT) fuchsia_io_DirectoryOpenRequestForDebugdata {
	fuchsia_io_DirectoryOpenRequestForDebugdata() {
	fuchsia_debugdata_Publisher_Name.copy(path_buffer.data(), path_buffer.size());
	}

	size_t size_bytes() const { return FIDL_ALIGN(sizeof(fixed) + fixed.path.size); }

	struct alignas(FIDL_ALIGNMENT) {
	fidl_message_header_t hdr = TxnHeader(fuchsia_io_DirectoryOpen_Ordinal);
	fidl_string_t path = {
	.size = fuchsia_debugdata_Publisher_Name.size(),
	.data = reinterpret_cast<char*>(FIDL_ALLOC_PRESENT),
	};
	uint64_t flags = fuchsia_io_Flags_PROTOCOL_SERVICE;
	fidl_table_t options = {fidl_vector_t{
	.count = 0,
	.data = reinterpret_cast<void*>(FIDL_ALLOC_PRESENT),
	}};
	zx_handle_t object = FIDL_HANDLE_PRESENT;
	uint32_t padding = 0;
	} fixed;
	std::array<char, fuchsia_debugdata_Publisher_Name.size()> path_buffer;
	const std::byte padding[FIDL_ALIGN(fuchsia_debugdata_Publisher_Name.size()) -
	fuchsia_debugdata_Publisher_Name.size()] = {};
	};

	struct alignas(FIDL_ALIGNMENT) fuchsia_debugdata_PublisherPublishRequestMessage {
	size_t size_bytes() const { return FIDL_ALIGN(sizeof(fixed) + fixed.data_sink.size); }

	struct alignas(FIDL_ALIGNMENT) {
	fidl_message_header_t hdr;
	fidl_string_t data_sink;
	zx_handle_t data;
	zx_handle_t vmo_token;
	} fixed;
	std::array<char, fuchsia_io_MAX_NAME_LENGTH> data_sink_buffer{};
	const std::byte padding[FIDL_ALIGN(fuchsia_io_MAX_NAME_LENGTH) - fuchsia_io_MAX_NAME_LENGTH] = {};
	};

	struct alignas(FIDL_ALIGNMENT) fuchsia_unknown_CloneableCloneRequest {
	static constexpr size_t size_bytes() { return sizeof(fuchsia_unknown_CloneableCloneRequest); }

	fidl_message_header_t hdr = TxnHeader(fuchsia_unknown_CloneableClone_Ordinal);
	zx_handle_t request = FIDL_HANDLE_PRESENT;
	uint32_t padding = 0;
	};

	template <class Request, size_t N>
	zx::result<> SendMessage(zx::unowned_channel client_end, const Request& request,
	const std::array<zx_handle_t, N>& handles)
	requires std::has_unique_object_representations_v<Request>
	{
	const uint32_t nbytes = static_cast<uint32_t>(request.size_bytes());
	const uint32_t nhandles = static_cast<uint32_t>(handles.size());
	return zx::make_result(client_end->write(0u, &request, nbytes, handles.data(), nhandles));
	}

	zx::result<> fuchsia_io_DirectoryOpen_fuchsia_debugdata_Publisher(zx::unowned_channel client_end,
	zx::channel server_end) {
	return SendMessage(client_end->borrow(), fuchsia_io_DirectoryOpenRequestForDebugdata{},
	std::array{server_end.release()});
	}

	zx::result<> fuchsia_debugdata_PublisherPublish(zx::unowned_channel client_end,
	std::string_view data_sink, zx::vmo data,
	zx::eventpair vmo_token) {
	fuchsia_debugdata_PublisherPublishRequestMessage request = {
	.fixed = {
	.hdr = TxnHeader(fuchsia_debugdata_PublisherPublish_Ordinal),
	.data_sink =
	{
	.size = data_sink.size(),
	.data = reinterpret_cast<char*>(FIDL_ALLOC_PRESENT),
	},
	.data = FIDL_HANDLE_PRESENT,
	.vmo_token = FIDL_HANDLE_PRESENT,
	}};
	if (data_sink.size() > request.data_sink_buffer.size()) [[unlikely]] {
	return zx::error{ZX_ERR_INVALID_ARGS};
	}
	data_sink.copy(request.data_sink_buffer.data(), request.data_sink_buffer.size());
	return SendMessage(client_end->borrow(), request,
	std::array{data.release(), vmo_token.release()});
	}

	zx::result<> fuchsia_unknown_CloneableClone(zx::unowned_channel client_end,
	zx::channel server_end) {
	return SendMessage(client_end->borrow(), fuchsia_unknown_CloneableCloneRequest{},
	std::array{server_end.release()});
	}

	} // namespace

	zx::result<zx::eventpair> Debugdata::Publish(zx::unowned_channel svc_client_end) && {
	zx::channel debugdata_client_end, debugdata_server_end;
	if (zx_status_t status = zx::channel::create(0, &debugdata_client_end, &debugdata_server_end);
	status != ZX_OK) [[unlikely]] {
	return zx::error{status};
	}

	zx::eventpair vmo_token_client, vmo_token_server;
	if (zx_status_t status = zx::eventpair::create(0, &vmo_token_client, &vmo_token_server);
	status != ZX_OK) {
	return zx::error{status};
	}

	if (zx::result result = fuchsia_debugdata_PublisherPublish(
	debugdata_client_end.borrow(), data_sink_, std::move(data_), std::move(vmo_token_server));
	result.is_error()) [[unlikely]] {
	return result.take_error();
	}

	if (zx::result result = fuchsia_io_DirectoryOpen_fuchsia_debugdata_Publisher(
	svc_client_end->borrow(), std::move(debugdata_server_end));
	result.is_error()) {
	return result.take_error();
	}

	return zx::ok(std::move(vmo_token_client));
	}

	zx::result<Debugdata::Deferred> Debugdata::DeferredPublish() && {
	zx::channel svc_client_end, svc_server_end;
	if (zx_status_t status = zx::channel::create(0, &svc_client_end, &svc_server_end);
	status != ZX_OK) [[unlikely]] {
	return zx::error{status};
	}

	zx::result token = std::move(*this).Publish(svc_client_end.borrow());
	if (token.is_error()) [[unlikely]] {
	return token.take_error();
	}

	return zx::ok(Deferred{
	.vmo_token = *std::move(token),
	.svc_server_end = std::move(svc_server_end),
	});
	}

	zx::result<> Debugdata::Forward(zx::unowned_channel svc_client_end, zx::channel svc_server_end) {
	return fuchsia_unknown_CloneableClone(std::move(svc_client_end), std::move(svc_server_end));
	}

	} // namespace ld