| // Copyright 2024 The Chromium 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 "quiche/quic/core/quic_connection_alarms.h" | |
| #include <algorithm> | |
| #include <cstddef> | |
| #include <cstdlib> | |
| #include <string> | |
| #include <utility> | |
| #include <vector> | |
| #include "absl/algorithm/container.h" | |
| #include "absl/base/nullability.h" | |
| #include "absl/container/inlined_vector.h" | |
| #include "absl/strings/str_format.h" | |
| #include "quiche/quic/core/quic_alarm.h" | |
| #include "quiche/quic/core/quic_alarm_factory.h" | |
| #include "quiche/quic/core/quic_connection_context.h" | |
| #include "quiche/quic/core/quic_one_block_arena.h" | |
| #include "quiche/quic/core/quic_time.h" | |
| #include "quiche/quic/platform/api/quic_flags.h" | |
| #include "quiche/common/platform/api/quiche_bug_tracker.h" | |
| #include "quiche/common/platform/api/quiche_logging.h" | |
| namespace quic { | |
| namespace { | |
| // Base class of all alarms owned by a QuicConnection. | |
| class QuicConnectionAlarmDelegate : public QuicAlarm::Delegate { | |
| public: | |
| explicit QuicConnectionAlarmDelegate(QuicConnectionAlarmsDelegate* connection) | |
| : connection_(connection) {} | |
| QuicConnectionAlarmDelegate(const QuicConnectionAlarmDelegate&) = delete; | |
| QuicConnectionAlarmDelegate& operator=(const QuicConnectionAlarmDelegate&) = | |
| delete; | |
| QuicConnectionContext* GetConnectionContext() override { | |
| return (connection_ == nullptr) ? nullptr : connection_->context(); | |
| } | |
| protected: | |
| QuicConnectionAlarmsDelegate* connection_; | |
| }; | |
| class MultiplexerAlarmDelegate : public QuicAlarm::Delegate { | |
| public: | |
| explicit MultiplexerAlarmDelegate(QuicAlarmMultiplexer* multiplexer) | |
| : multiplexer_(multiplexer) {} | |
| MultiplexerAlarmDelegate(const QuicConnectionAlarmDelegate&) = delete; | |
| MultiplexerAlarmDelegate& operator=(const MultiplexerAlarmDelegate&) = delete; | |
| QuicConnectionContext* GetConnectionContext() override { | |
| return multiplexer_->delegate()->context(); | |
| } | |
| void OnAlarm() override { multiplexer_->FireAlarms(); } | |
| protected: | |
| QuicAlarmMultiplexer* multiplexer_; | |
| }; | |
| } // namespace | |
| std::string QuicAlarmSlotName(QuicAlarmSlot slot) { | |
| switch (slot) { | |
| case QuicAlarmSlot::kAck: | |
| return "Ack"; | |
| case QuicAlarmSlot::kRetransmission: | |
| return "Retransmission"; | |
| case QuicAlarmSlot::kSend: | |
| return "Send"; | |
| case QuicAlarmSlot::kMtuDiscovery: | |
| return "MtuDiscovery"; | |
| case QuicAlarmSlot::kProcessUndecryptablePackets: | |
| return "ProcessUndecryptablePackets"; | |
| case QuicAlarmSlot::kDiscardPreviousOneRttKeys: | |
| return "DiscardPreviousOneRttKeys"; | |
| case QuicAlarmSlot::kDiscardZeroRttDecryptionKeys: | |
| return "DiscardZeroRttDecryptionKeys"; | |
| case QuicAlarmSlot::kMultiPortProbing: | |
| return "MultiPortProbing"; | |
| case QuicAlarmSlot::kIdleNetworkDetector: | |
| return "IdleNetworkDetector"; | |
| case QuicAlarmSlot::kNetworkBlackholeDetector: | |
| return "NetworkBlackholeDetector"; | |
| case QuicAlarmSlot::kPing: | |
| return "Ping"; | |
| case QuicAlarmSlot::kSlotCount: | |
| break; | |
| } | |
| return "[unknown]"; | |
| } | |
| QuicAlarmMultiplexer::QuicAlarmMultiplexer( | |
| QuicConnectionAlarmsDelegate* absl_nonnull connection, | |
| QuicConnectionArena& arena, QuicAlarmFactory& alarm_factory) | |
| : deadlines_({QuicTime::Zero(), QuicTime::Zero(), QuicTime::Zero(), | |
| QuicTime::Zero(), QuicTime::Zero(), QuicTime::Zero(), | |
| QuicTime::Zero(), QuicTime::Zero(), QuicTime::Zero(), | |
| QuicTime::Zero(), QuicTime::Zero()}), | |
| now_alarm_(alarm_factory.CreateAlarm( | |
| arena.New<MultiplexerAlarmDelegate>(this), &arena)), | |
| later_alarm_(alarm_factory.CreateAlarm( | |
| arena.New<MultiplexerAlarmDelegate>(this), &arena)), | |
| connection_(connection), | |
| underlying_alarm_granularity_(QuicTimeDelta::FromMicroseconds( | |
| GetQuicFlag(quic_multiplexer_alarm_granularity_us))) {} | |
| void QuicAlarmMultiplexer::Set(QuicAlarmSlot slot, QuicTime new_deadline) { | |
| QUICHE_DCHECK(!IsSet(slot)); | |
| QUICHE_DCHECK(new_deadline.IsInitialized()); | |
| if (permanently_cancelled_) { | |
| QUICHE_BUG(quic_alarm_multiplexer_illegal_set) | |
| << "Set called after alarms are permanently cancelled. new_deadline:" | |
| << new_deadline; | |
| return; | |
| } | |
| SetDeadlineFor(slot, new_deadline); | |
| MaybeRescheduleUnderlyingAlarms(); | |
| } | |
| void QuicAlarmMultiplexer::Update(QuicAlarmSlot slot, QuicTime new_deadline, | |
| QuicTimeDelta granularity) { | |
| if (permanently_cancelled_) { | |
| QUICHE_BUG(quic_alarm_multiplexer_illegal_update) | |
| << "Update called after alarm is permanently cancelled. new_deadline:" | |
| << new_deadline << ", granularity:" << granularity; | |
| return; | |
| } | |
| if (!new_deadline.IsInitialized()) { | |
| Cancel(slot); | |
| return; | |
| } | |
| if (std::abs((new_deadline - GetDeadline(slot)).ToMicroseconds()) < | |
| granularity.ToMicroseconds()) { | |
| return; | |
| } | |
| SetDeadlineFor(slot, new_deadline); | |
| MaybeRescheduleUnderlyingAlarms(); | |
| } | |
| void QuicAlarmMultiplexer::DeferUnderlyingAlarmScheduling() { | |
| defer_updates_of_underlying_alarms_ = true; | |
| } | |
| void QuicAlarmMultiplexer::ResumeUnderlyingAlarmScheduling() { | |
| QUICHE_DCHECK(defer_updates_of_underlying_alarms_); | |
| defer_updates_of_underlying_alarms_ = false; | |
| RescheduleUnderlyingAlarms(); | |
| } | |
| void QuicAlarmMultiplexer::FireAlarms() { | |
| if (permanently_cancelled_) { | |
| QUICHE_BUG(multiplexer_fire_alarms_permanently_cancelled) | |
| << "FireAlarms() called when all alarms have been permanently " | |
| "cancelled."; | |
| return; | |
| } | |
| QuicTime now = connection_->clock()->ApproximateNow(); | |
| // Create a fixed list of alarms that are due. | |
| absl::InlinedVector<QuicAlarmSlot, kNumberOfSlots> scheduled; | |
| for (size_t slot_number = 0; slot_number < deadlines_.size(); ++slot_number) { | |
| if (deadlines_[slot_number].IsInitialized() && | |
| deadlines_[slot_number] <= now) { | |
| scheduled.push_back(static_cast<QuicAlarmSlot>(slot_number)); | |
| } | |
| } | |
| // Execute them in order of scheduled deadlines. | |
| absl::c_sort(scheduled, [this](QuicAlarmSlot a, QuicAlarmSlot b) { | |
| return GetDeadline(a) < GetDeadline(b); | |
| }); | |
| for (QuicAlarmSlot slot : scheduled) { | |
| Fire(slot); | |
| } | |
| MaybeRescheduleUnderlyingAlarms(); | |
| } | |
| void QuicAlarmMultiplexer::RescheduleUnderlyingAlarms() { | |
| if (permanently_cancelled_) { | |
| return; | |
| } | |
| QuicTime now = connection_->clock()->ApproximateNow(); | |
| bool schedule_now = false; | |
| QuicTime later_alarm_deadline = QuicTime::Infinite(); | |
| for (const QuicTime& deadline : deadlines_) { | |
| if (!deadline.IsInitialized()) { | |
| continue; | |
| } | |
| if (deadline <= now) { | |
| schedule_now = true; | |
| } else { | |
| later_alarm_deadline = std::min(later_alarm_deadline, deadline); | |
| } | |
| } | |
| if (schedule_now && !now_alarm_->IsSet()) { | |
| now_alarm_->Set(now); | |
| } | |
| if (!schedule_now && now_alarm_->IsSet()) { | |
| now_alarm_->Cancel(); | |
| } | |
| if (later_alarm_deadline != QuicTime::Infinite()) { | |
| later_alarm_->Update(later_alarm_deadline, underlying_alarm_granularity_); | |
| } else { | |
| later_alarm_->Cancel(); | |
| } | |
| QUICHE_DVLOG(1) << "Rescheduled alarms; now = " | |
| << (schedule_now ? "true" : "false") | |
| << "; later = " << later_alarm_deadline; | |
| QUICHE_DVLOG(1) << "Alarms: " << DebugString(); | |
| } | |
| void QuicAlarmMultiplexer::Fire(QuicAlarmSlot slot) { | |
| if (!IsSet(slot)) { | |
| return; | |
| } | |
| SetDeadlineFor(slot, QuicTime::Zero()); | |
| switch (slot) { | |
| case QuicAlarmSlot::kAck: | |
| connection_->OnAckAlarm(); | |
| return; | |
| case QuicAlarmSlot::kRetransmission: | |
| connection_->OnRetransmissionAlarm(); | |
| return; | |
| case QuicAlarmSlot::kSend: | |
| connection_->OnSendAlarm(); | |
| return; | |
| case QuicAlarmSlot::kMtuDiscovery: | |
| connection_->OnMtuDiscoveryAlarm(); | |
| return; | |
| case QuicAlarmSlot::kProcessUndecryptablePackets: | |
| connection_->OnProcessUndecryptablePacketsAlarm(); | |
| return; | |
| case QuicAlarmSlot::kDiscardPreviousOneRttKeys: | |
| connection_->OnDiscardPreviousOneRttKeysAlarm(); | |
| return; | |
| case QuicAlarmSlot::kDiscardZeroRttDecryptionKeys: | |
| connection_->OnDiscardZeroRttDecryptionKeysAlarm(); | |
| return; | |
| case QuicAlarmSlot::kMultiPortProbing: | |
| connection_->MaybeProbeMultiPortPath(); | |
| return; | |
| case QuicAlarmSlot::kIdleNetworkDetector: | |
| connection_->OnIdleDetectorAlarm(); | |
| return; | |
| case QuicAlarmSlot::kNetworkBlackholeDetector: | |
| connection_->OnNetworkBlackholeDetectorAlarm(); | |
| return; | |
| case QuicAlarmSlot::kPing: | |
| connection_->OnPingAlarm(); | |
| return; | |
| case QuicAlarmSlot::kSlotCount: | |
| break; | |
| } | |
| QUICHE_NOTREACHED(); | |
| } | |
| std::string QuicAlarmMultiplexer::DebugString() { | |
| std::vector<std::pair<QuicTime, QuicAlarmSlot>> scheduled; | |
| for (size_t i = 0; i < deadlines_.size(); ++i) { | |
| if (deadlines_[i].IsInitialized()) { | |
| scheduled.emplace_back(deadlines_[i], static_cast<QuicAlarmSlot>(i)); | |
| } | |
| } | |
| absl::c_sort(scheduled); | |
| QuicTime now = connection_->clock()->Now(); | |
| std::string result; | |
| for (const auto& [deadline, slot] : scheduled) { | |
| QuicTimeDelta relative = deadline - now; | |
| absl::StrAppendFormat(&result, " %.1fms --- %s\n", | |
| relative.ToMicroseconds() / 1000.f, | |
| QuicAlarmSlotName(slot)); | |
| } | |
| return result; | |
| } | |
| void QuicAlarmMultiplexer::CancelAllAlarms() { | |
| QUICHE_DVLOG(1) << "Cancelling all QuicConnection alarms."; | |
| permanently_cancelled_ = true; | |
| deadlines_.fill(QuicTime::Zero()); | |
| now_alarm_->PermanentCancel(); | |
| later_alarm_->PermanentCancel(); | |
| } | |
| } // namespace quic |