1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
// Copyright (c) 2020 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 "quic/core/quic_network_blackhole_detector.h"
#include "quic/core/quic_constants.h"
namespace quic {
namespace {
class AlarmDelegate : public QuicAlarm::Delegate {
public:
explicit AlarmDelegate(QuicNetworkBlackholeDetector* detector)
: detector_(detector) {}
AlarmDelegate(const AlarmDelegate&) = delete;
AlarmDelegate& operator=(const AlarmDelegate&) = delete;
void OnAlarm() override { detector_->OnAlarm(); }
private:
QuicNetworkBlackholeDetector* detector_;
};
} // namespace
QuicNetworkBlackholeDetector::QuicNetworkBlackholeDetector(
Delegate* delegate,
QuicConnectionArena* arena,
QuicAlarmFactory* alarm_factory)
: delegate_(delegate),
alarm_(
alarm_factory->CreateAlarm(arena->New<AlarmDelegate>(this), arena)) {}
void QuicNetworkBlackholeDetector::OnAlarm() {
QuicTime next_deadline = GetEarliestDeadline();
if (!next_deadline.IsInitialized()) {
QUIC_BUG << "BlackholeDetector alarm fired unexpectedly";
return;
}
QUIC_DVLOG(1) << "BlackholeDetector alarm firing. next_deadline:"
<< next_deadline
<< ", path_degrading_deadline_:" << path_degrading_deadline_
<< ", path_mtu_reduction_deadline_:"
<< path_mtu_reduction_deadline_
<< ", blackhole_deadline_:" << blackhole_deadline_;
if (path_degrading_deadline_ == next_deadline) {
path_degrading_deadline_ = QuicTime::Zero();
delegate_->OnPathDegradingDetected();
}
if (path_mtu_reduction_deadline_ == next_deadline) {
path_mtu_reduction_deadline_ = QuicTime::Zero();
delegate_->OnPathMtuReductionDetected();
}
if (blackhole_deadline_ == next_deadline) {
blackhole_deadline_ = QuicTime::Zero();
delegate_->OnBlackholeDetected();
}
UpdateAlarm();
}
void QuicNetworkBlackholeDetector::StopDetection() {
alarm_->Cancel();
path_degrading_deadline_ = QuicTime::Zero();
blackhole_deadline_ = QuicTime::Zero();
path_mtu_reduction_deadline_ = QuicTime::Zero();
}
void QuicNetworkBlackholeDetector::RestartDetection(
QuicTime path_degrading_deadline,
QuicTime blackhole_deadline,
QuicTime path_mtu_reduction_deadline) {
path_degrading_deadline_ = path_degrading_deadline;
blackhole_deadline_ = blackhole_deadline;
path_mtu_reduction_deadline_ = path_mtu_reduction_deadline;
QUIC_BUG_IF(blackhole_deadline_.IsInitialized() &&
blackhole_deadline_ != GetLastDeadline())
<< "Blackhole detection deadline should be the last deadline.";
UpdateAlarm();
}
QuicTime QuicNetworkBlackholeDetector::GetEarliestDeadline() const {
QuicTime result = QuicTime::Zero();
for (QuicTime t : {path_degrading_deadline_, blackhole_deadline_,
path_mtu_reduction_deadline_}) {
if (!t.IsInitialized()) {
continue;
}
if (!result.IsInitialized() || t < result) {
result = t;
}
}
return result;
}
QuicTime QuicNetworkBlackholeDetector::GetLastDeadline() const {
return std::max({path_degrading_deadline_, blackhole_deadline_,
path_mtu_reduction_deadline_});
}
void QuicNetworkBlackholeDetector::UpdateAlarm() const {
QuicTime next_deadline = GetEarliestDeadline();
QUIC_DVLOG(1) << "Updating alarm. next_deadline:" << next_deadline
<< ", path_degrading_deadline_:" << path_degrading_deadline_
<< ", path_mtu_reduction_deadline_:"
<< path_mtu_reduction_deadline_
<< ", blackhole_deadline_:" << blackhole_deadline_;
alarm_->Update(next_deadline, kAlarmGranularity);
}
bool QuicNetworkBlackholeDetector::IsDetectionInProgress() const {
return alarm_->IsSet();
}
} // namespace quic
|
