| // Copyright 2017 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 "src/bringup/bin/netsvc/debuglog.h" | |
| #include <lib/component/incoming/cpp/protocol.h> | |
| #include <lib/fit/defer.h> | |
| #include <lib/zx/clock.h> | |
| #include <stdio.h> | |
| #include <string.h> | |
| #include <zircon/assert.h> | |
| #include <iomanip> | |
| #include <sstream> | |
| #include "src/bringup/bin/netsvc/inet6.h" | |
| constexpr zx::duration kSendDelayShort = zx::msec(100); | |
| constexpr zx::duration kSendDelayLong = zx::sec(4); | |
| // Number of consecutive unacknowledged packets we will send before reducing send rate. | |
| constexpr unsigned kUnackedThreshold = 5; | |
| LogListener::LogListener(async_dispatcher_t* dispatcher, SendFn send, bool retransmit, | |
| size_t max_msg_size) | |
| : dispatcher_(dispatcher), | |
| retransmit_(retransmit), | |
| max_msg_size_(max_msg_size), | |
| send_delay_(kSendDelayShort), | |
| send_fn_(std::move(send)), | |
| timeout_task_([this](async_dispatcher_t* dispatcher, async::Task* task, zx_status_t status) { | |
| if (status == ZX_ERR_CANCELED) { | |
| return; | |
| } | |
| ZX_ASSERT_MSG(status == ZX_OK, "unexpected task status %s", zx_status_get_string(status)); | |
| if (pkt_.has_value()) { | |
| // No reply. If no one is listening, reduce send rate. | |
| if (++num_unacked_ >= kUnackedThreshold) { | |
| send_delay_ = kSendDelayLong; | |
| } | |
| } | |
| MaybeSendLog(); | |
| }) { | |
| ZX_ASSERT_MSG(max_msg_size <= NETBOOT_DEBUGLOG_MAX_DATA, | |
| "maximum message size %ld greater than max log data %d", max_msg_size, | |
| NETBOOT_DEBUGLOG_MAX_DATA); | |
| } | |
| void LogListener::Bind(fidl::ServerEnd<_EnclosingProtocol> server_end) { | |
| binding_.emplace(fidl::BindServer( | |
| dispatcher_, std::move(server_end), this, | |
| [](LogListener*, fidl::UnbindInfo info, fidl::ServerEnd<_EnclosingProtocol>) { | |
| if (info.status() != ZX_OK) { | |
| printf("netsvc: lost connection to system logs: %s\n", info.FormatDescription().c_str()); | |
| } | |
| })); | |
| } | |
| LogListener::StagedPacket::StagedPacket(uint32_t seqno, const char* nodename, | |
| LogListener::PendingMessage&& msg) | |
| : contents({.magic = NETBOOT_DEBUGLOG_MAGIC, .seqno = seqno}), | |
| len(sizeof(contents) - (sizeof(contents.data) - msg.log_message.size())), | |
| message(std::move(msg)) { | |
| ZX_ASSERT_MSG(message.log_message.size() <= sizeof(contents.data), "invalid message size %lu", | |
| message.log_message.size()); | |
| strncpy(contents.nodename, nodename, sizeof(contents.nodename) - 1); | |
| memcpy(contents.data, message.log_message.c_str(), message.log_message.size()); | |
| } | |
| void LogListener::Log(LogRequestView request, LogCompleter::Sync& completer) { | |
| PushLogMessage(request->log); | |
| // Store completer. | |
| pending_.back().completer = completer.ToAsync(); | |
| TryLoadNextPacket(); | |
| } | |
| void LogListener::LogMany(LogManyRequestView request, LogManyCompleter::Sync& completer) { | |
| for (const fuchsia_logger::wire::LogMessage& message : request->log) { | |
| PushLogMessage(message); | |
| } | |
| // Store completer on last queued message. | |
| pending_.back().completer = completer.ToAsync(); | |
| TryLoadNextPacket(); | |
| } | |
| void LogListener::Done(DoneCompleter::Sync&) { ZX_PANIC("unexpected call to Done"); } | |
| // Helpers to visit on pending message variants. | |
| template <class... Ts> | |
| struct overloaded : Ts... { | |
| using Ts::operator()...; | |
| }; | |
| template <class... Ts> | |
| overloaded(Ts...) -> overloaded<Ts...>; | |
| void LogListener::Ack(uint32_t seqno) { | |
| if (seqno != seqno_ || !pkt_.has_value()) { | |
| return; | |
| } | |
| // Received an ack. We have an active listener. Don't delay. | |
| num_unacked_ = 0; | |
| send_delay_ = kSendDelayShort; | |
| seqno_++; | |
| pkt_.value().message.Complete(); | |
| pkt_.reset(); | |
| TryLoadNextPacket(); | |
| } | |
| void LogListener::PendingMessage::Complete() { | |
| std::visit(overloaded{[](std::monostate&) {}, | |
| [](LogCompleter::Async& c) { | |
| c.Reply(); | |
| fidl::Status result = c.result_of_reply(); | |
| if (!result.ok()) { | |
| printf("netsvc: failed to confirm logs: %s\n", | |
| result.FormatDescription().c_str()); | |
| } | |
| }, | |
| [](LogManyCompleter::Async& c) { | |
| c.Reply(); | |
| fidl::Status result = c.result_of_reply(); | |
| if (!result.ok()) { | |
| printf("netsvc: failed to confirm logs: %s\n", | |
| result.FormatDescription().c_str()); | |
| } | |
| }}, | |
| completer); | |
| } | |
| void LogListener::PushLogMessage(const fuchsia_logger::wire::LogMessage& message) { | |
| std::stringstream ss; | |
| zx::duration timestamp(message.time.get()); | |
| // Add time in format [secs.millis]. | |
| ss << '[' << std::setw(5) << std::setfill('0') << (timestamp.to_secs()); | |
| ss << '.' << std::setw(3) << std::setfill('0') << (timestamp.to_msecs() % 1000ULL) << ']'; | |
| // Add PID and TID as "tid.pid". | |
| ss << ' ' << std::setw(5) << std::setfill('0') << message.pid; | |
| ss << '.' << std::setw(5) << std::setfill('0') << message.tid; | |
| // Add message tags. | |
| ss << " ["; | |
| for (auto tag = message.tags.begin(); tag != message.tags.end(); tag++) { | |
| if (tag != message.tags.begin()) { | |
| ss << ','; | |
| } | |
| ss << tag->get(); | |
| } | |
| ss << "] "; | |
| size_t size = ss.tellp(); | |
| ZX_ASSERT_MSG(size < max_msg_size_, "message preamble too long: %ld", size); | |
| std::string_view contents = message.msg.get(); | |
| size = std::min(max_msg_size_ - size, contents.size()); | |
| ss << contents.substr(0, size); | |
| if (static_cast<size_t>(ss.tellp()) < max_msg_size_) { | |
| ss << '\n'; | |
| pending_.push(PendingMessage{.log_message = ss.str()}); | |
| return; | |
| } | |
| pending_.push(PendingMessage{.log_message = ss.str()}); | |
| contents = contents.substr(size); | |
| while (!contents.empty()) { | |
| size_t partial = std::min(max_msg_size_, contents.size()); | |
| pending_.push(PendingMessage{.log_message = std::string(contents.substr(0, partial))}); | |
| contents = contents.substr(partial); | |
| } | |
| PendingMessage& last = pending_.back(); | |
| if (last.log_message.size() < max_msg_size_) { | |
| last.log_message += '\n'; | |
| } else { | |
| pending_.push(PendingMessage{.log_message = "\n"}); | |
| } | |
| } | |
| void LogListener::TryLoadNextPacket() { | |
| if (pkt_.has_value() || pending_.empty()) { | |
| return; | |
| } | |
| pkt_.emplace(seqno_, nodename(), std::move(pending_.front())); | |
| pending_.pop(); | |
| MaybeSendLog(); | |
| } | |
| void LogListener::MaybeSendLog() { | |
| if (!pkt_.has_value()) { | |
| return; | |
| } | |
| StagedPacket& staged = pkt_.value(); | |
| send_fn_(staged.contents, staged.len); | |
| if (retransmit_) { | |
| zx_status_t status = timeout_task_.Cancel(); | |
| ZX_ASSERT_MSG(status == ZX_OK || status == ZX_ERR_NOT_FOUND, "failed to cancel task %s", | |
| zx_status_get_string(status)); | |
| status = timeout_task_.PostDelayed(dispatcher_, send_delay_); | |
| ZX_ASSERT_MSG(status == ZX_OK, "failed to schedule timeout task %s", | |
| zx_status_get_string(status)); | |
| } | |
| } | |
| namespace { | |
| std::optional<LogListener> gListener; | |
| } | |
| zx_status_t debuglog_init(async_dispatcher_t* dispatcher) { | |
| zx::result log_client_end = component::Connect<fuchsia_logger::Log>(); | |
| if (log_client_end.is_error()) { | |
| return log_client_end.status_value(); | |
| } | |
| fidl::WireSyncClient client{std::move(log_client_end.value())}; | |
| auto [client_end, server_end] = fidl::Endpoints<fuchsia_logger::LogListenerSafe>::Create(); | |
| { | |
| fidl::Status result = client->ListenSafe( | |
| std::move(client_end), fidl::ObjectView<fuchsia_logger::wire::LogFilterOptions>(nullptr)); | |
| if (!result.ok()) { | |
| return result.status(); | |
| } | |
| } | |
| auto& listener = gListener.emplace( | |
| dispatcher, | |
| [](const netboot_debuglog_packet_t& pkt, size_t len) { | |
| zx_status_t status = udp6_send(&pkt, len, &ip6_ll_all_nodes, NETBOOT_DEBUGLOG_PORT_SERVER, | |
| NETBOOT_DEBUGLOG_PORT_ACK, false); | |
| if (status != ZX_OK) { | |
| printf("netsvc: failed to send debuglog: %s\n", zx_status_get_string(status)); | |
| } | |
| }, | |
| /* retransmit */ true, NETBOOT_DEBUGLOG_MAX_DATA); | |
| listener.Bind(std::move(server_end)); | |
| return ZX_OK; | |
| } | |
| void debuglog_recv(async_dispatcher_t* dispatcher, void* data, size_t len, bool is_mcast) { | |
| // The only message we should be receiving is acknowledgement of our last transmission | |
| if ((len != 8) || is_mcast) { | |
| return; | |
| } | |
| // Copied not cast in-place to satisfy alignment requirements flagged by ubsan (see | |
| // https://fxbug.dev/42122361). | |
| netboot_debuglog_packet_t pkt; | |
| memcpy(&pkt, data, sizeof(netboot_debuglog_packet_t)); | |
| if ((pkt.magic != NETBOOT_DEBUGLOG_MAGIC)) { | |
| return; | |
| } | |
| ZX_ASSERT_MSG(gListener.has_value(), "debuglog was not initialized"); | |
| gListener.value().Ack(pkt.seqno); | |
| } |