[email protected] | d0d49dd8 | 2012-01-26 00:03:59 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
[email protected] | 7556ea2 | 2011-12-08 19:29:15 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include "net/dns/dns_session.h" |
| 6 | |
avi | 6516805 | 2015-12-01 19:27:07 | [diff] [blame] | 7 | #include <stdint.h> |
danakj | 22f90e7 | 2016-04-16 01:55:40 | [diff] [blame] | 8 | |
dalyk | 6ab72db | 2019-09-04 23:12:11 | [diff] [blame] | 9 | #include <cstdlib> |
avi | 6516805 | 2015-12-01 19:27:07 | [diff] [blame] | 10 | #include <limits> |
dalyk | 6ab72db | 2019-09-04 23:12:11 | [diff] [blame] | 11 | #include <string> |
dcheng | c7eeda42 | 2015-12-26 03:56:48 | [diff] [blame] | 12 | #include <utility> |
avi | 6516805 | 2015-12-01 19:27:07 | [diff] [blame] | 13 | |
[email protected] | 7556ea2 | 2011-12-08 19:29:15 | [diff] [blame] | 14 | #include "base/bind.h" |
[email protected] | a6c84f4 | 2013-06-07 20:39:38 | [diff] [blame] | 15 | #include "base/lazy_instance.h" |
Avi Drissman | 13fc893 | 2015-12-20 04:40:46 | [diff] [blame] | 16 | #include "base/macros.h" |
dalyk | 6ab72db | 2019-09-04 23:12:11 | [diff] [blame] | 17 | #include "base/metrics/histogram_functions.h" |
asvitkine | c3c9372 | 2015-06-17 14:48:37 | [diff] [blame] | 18 | #include "base/metrics/histogram_macros.h" |
[email protected] | ae1b30b | 2013-05-23 23:06:03 | [diff] [blame] | 19 | #include "base/metrics/sample_vector.h" |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 20 | #include "base/rand_util.h" |
| 21 | #include "base/stl_util.h" |
dalyk | 6ab72db | 2019-09-04 23:12:11 | [diff] [blame] | 22 | #include "base/strings/stringprintf.h" |
[email protected] | 66e96c4 | 2013-06-28 15:20:31 | [diff] [blame] | 23 | #include "base/time/time.h" |
[email protected] | 7556ea2 | 2011-12-08 19:29:15 | [diff] [blame] | 24 | #include "net/base/ip_endpoint.h" |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 25 | #include "net/base/net_errors.h" |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 26 | #include "net/dns/dns_config.h" |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 27 | #include "net/dns/dns_socket_pool.h" |
ttuttle | cf1158bf | 2016-03-18 16:37:44 | [diff] [blame] | 28 | #include "net/dns/dns_util.h" |
mikecirone | 8b85c43 | 2016-09-08 19:11:00 | [diff] [blame] | 29 | #include "net/log/net_log_event_type.h" |
mikecirone | f22f981 | 2016-10-04 03:40:19 | [diff] [blame] | 30 | #include "net/log/net_log_source.h" |
| 31 | #include "net/log/net_log_with_source.h" |
tfarina | 5dd13c2 | 2016-11-16 12:08:26 | [diff] [blame] | 32 | #include "net/socket/datagram_client_socket.h" |
[email protected] | bdb6598 | 2012-12-20 20:44:59 | [diff] [blame] | 33 | #include "net/socket/stream_socket.h" |
[email protected] | 7556ea2 | 2011-12-08 19:29:15 | [diff] [blame] | 34 | |
| 35 | namespace net { |
| 36 | |
[email protected] | ae1b30b | 2013-05-23 23:06:03 | [diff] [blame] | 37 | namespace { |
ttuttle | cf1158bf | 2016-03-18 16:37:44 | [diff] [blame] | 38 | |
[email protected] | ae1b30b | 2013-05-23 23:06:03 | [diff] [blame] | 39 | // Set min timeout, in case we are talking to a local DNS proxy. |
| 40 | const unsigned kMinTimeoutMs = 10; |
| 41 | |
ttuttle | cf1158bf | 2016-03-18 16:37:44 | [diff] [blame] | 42 | // Default maximum timeout between queries, even with exponential backoff. |
| 43 | // (Can be overridden by field trial.) |
| 44 | const unsigned kDefaultMaxTimeoutMs = 5000; |
| 45 | |
| 46 | // Maximum RTT that will fit in the RTT histograms. |
| 47 | const int32_t kRTTMaxMs = 30000; |
[email protected] | ae1b30b | 2013-05-23 23:06:03 | [diff] [blame] | 48 | // Number of buckets in the histogram of observed RTTs. |
ttuttle | cf1158bf | 2016-03-18 16:37:44 | [diff] [blame] | 49 | const size_t kRTTBucketCount = 350; |
[email protected] | ae1b30b | 2013-05-23 23:06:03 | [diff] [blame] | 50 | // Target percentile in the RTT histogram used for retransmission timeout. |
| 51 | const unsigned kRTOPercentile = 99; |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 52 | // Number of samples to seed the histogram with. |
| 53 | const unsigned kNumSeeds = 2; |
ttuttle | cf1158bf | 2016-03-18 16:37:44 | [diff] [blame] | 54 | |
[email protected] | ae1b30b | 2013-05-23 23:06:03 | [diff] [blame] | 55 | } // namespace |
| 56 | |
[email protected] | a6c84f4 | 2013-06-07 20:39:38 | [diff] [blame] | 57 | // Runtime statistics of DNS server. |
| 58 | struct DnsSession::ServerStats { |
| 59 | ServerStats(base::TimeDelta rtt_estimate_param, RttBuckets* buckets) |
| 60 | : last_failure_count(0), rtt_estimate(rtt_estimate_param) { |
| 61 | rtt_histogram.reset(new base::SampleVector(buckets)); |
[email protected] | a144bd2 | 2013-07-29 21:53:10 | [diff] [blame] | 62 | // Seed histogram with 2 samples at |rtt_estimate| timeout. |
pkasting | 6b68a16 | 2014-12-01 22:10:29 | [diff] [blame] | 63 | rtt_histogram->Accumulate( |
| 64 | static_cast<base::HistogramBase::Sample>(rtt_estimate.InMilliseconds()), |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 65 | kNumSeeds); |
[email protected] | a6c84f4 | 2013-06-07 20:39:38 | [diff] [blame] | 66 | } |
| 67 | |
| 68 | // Count of consecutive failures after last success. |
| 69 | int last_failure_count; |
| 70 | |
| 71 | // Last time when server returned failure or timeout. |
| 72 | base::Time last_failure; |
| 73 | // Last time when server returned success. |
| 74 | base::Time last_success; |
| 75 | |
| 76 | // Estimated RTT using moving average. |
| 77 | base::TimeDelta rtt_estimate; |
| 78 | // Estimated error in the above. |
| 79 | base::TimeDelta rtt_deviation; |
| 80 | |
| 81 | // A histogram of observed RTT . |
danakj | 22f90e7 | 2016-04-16 01:55:40 | [diff] [blame] | 82 | std::unique_ptr<base::SampleVector> rtt_histogram; |
[email protected] | a6c84f4 | 2013-06-07 20:39:38 | [diff] [blame] | 83 | |
| 84 | DISALLOW_COPY_AND_ASSIGN(ServerStats); |
| 85 | }; |
| 86 | |
| 87 | // static |
| 88 | base::LazyInstance<DnsSession::RttBuckets>::Leaky DnsSession::rtt_buckets_ = |
| 89 | LAZY_INSTANCE_INITIALIZER; |
| 90 | |
| 91 | DnsSession::RttBuckets::RttBuckets() : base::BucketRanges(kRTTBucketCount + 1) { |
ttuttle | cf1158bf | 2016-03-18 16:37:44 | [diff] [blame] | 92 | base::Histogram::InitializeBucketRanges(1, kRTTMaxMs, this); |
[email protected] | a6c84f4 | 2013-06-07 20:39:38 | [diff] [blame] | 93 | } |
| 94 | |
danakj | 22f90e7 | 2016-04-16 01:55:40 | [diff] [blame] | 95 | DnsSession::SocketLease::SocketLease( |
| 96 | scoped_refptr<DnsSession> session, |
| 97 | unsigned server_index, |
| 98 | std::unique_ptr<DatagramClientSocket> socket) |
dcheng | c7eeda42 | 2015-12-26 03:56:48 | [diff] [blame] | 99 | : session_(session), |
| 100 | server_index_(server_index), |
| 101 | socket_(std::move(socket)) {} |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 102 | |
| 103 | DnsSession::SocketLease::~SocketLease() { |
dcheng | c7eeda42 | 2015-12-26 03:56:48 | [diff] [blame] | 104 | session_->FreeSocket(server_index_, std::move(socket_)); |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 105 | } |
| 106 | |
[email protected] | 7556ea2 | 2011-12-08 19:29:15 | [diff] [blame] | 107 | DnsSession::DnsSession(const DnsConfig& config, |
danakj | 22f90e7 | 2016-04-16 01:55:40 | [diff] [blame] | 108 | std::unique_ptr<DnsSocketPool> socket_pool, |
[email protected] | 7556ea2 | 2011-12-08 19:29:15 | [diff] [blame] | 109 | const RandIntCallback& rand_int_callback, |
| 110 | NetLog* net_log) |
| 111 | : config_(config), |
dcheng | c7eeda42 | 2015-12-26 03:56:48 | [diff] [blame] | 112 | socket_pool_(std::move(socket_pool)), |
avi | 6516805 | 2015-12-01 19:27:07 | [diff] [blame] | 113 | rand_callback_(base::Bind(rand_int_callback, |
| 114 | 0, |
| 115 | std::numeric_limits<uint16_t>::max())), |
[email protected] | 7556ea2 | 2011-12-08 19:29:15 | [diff] [blame] | 116 | net_log_(net_log), |
[email protected] | a6c84f4 | 2013-06-07 20:39:38 | [diff] [blame] | 117 | server_index_(0) { |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 118 | socket_pool_->Initialize(&config_.nameservers, net_log); |
drbasic | f0d1b26 | 2016-08-23 06:10:42 | [diff] [blame] | 119 | UMA_HISTOGRAM_CUSTOM_COUNTS("AsyncDNS.ServerCount", |
| 120 | config_.nameservers.size(), 1, 10, 11); |
ttuttle | cf1158bf | 2016-03-18 16:37:44 | [diff] [blame] | 121 | UpdateTimeouts(NetworkChangeNotifier::GetConnectionType()); |
| 122 | InitializeServerStats(); |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 123 | } |
| 124 | |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 125 | DnsSession::~DnsSession() = default; |
ttuttle | cf1158bf | 2016-03-18 16:37:44 | [diff] [blame] | 126 | |
| 127 | void DnsSession::UpdateTimeouts(NetworkChangeNotifier::ConnectionType type) { |
| 128 | initial_timeout_ = GetTimeDeltaForConnectionTypeFromFieldTrialOrDefault( |
| 129 | "AsyncDnsInitialTimeoutMsByConnectionType", config_.timeout, type); |
| 130 | max_timeout_ = GetTimeDeltaForConnectionTypeFromFieldTrialOrDefault( |
| 131 | "AsyncDnsMaxTimeoutMsByConnectionType", |
| 132 | base::TimeDelta::FromMilliseconds(kDefaultMaxTimeoutMs), type); |
| 133 | } |
| 134 | |
| 135 | void DnsSession::InitializeServerStats() { |
| 136 | server_stats_.clear(); |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 137 | for (size_t i = 0; i < config_.nameservers.size(); ++i) { |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 138 | server_stats_.push_back(std::make_unique<ServerStats>( |
ricea | 2deef68 | 2016-09-09 08:04:07 | [diff] [blame] | 139 | initial_timeout_, rtt_buckets_.Pointer())); |
ttuttle | cf1158bf | 2016-03-18 16:37:44 | [diff] [blame] | 140 | } |
ttuttle | cf1158bf | 2016-03-18 16:37:44 | [diff] [blame] | 141 | |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 142 | doh_server_stats_.clear(); |
| 143 | for (size_t i = 0; i < config_.dns_over_https_servers.size(); ++i) { |
| 144 | doh_server_stats_.push_back(std::make_pair( |
| 145 | std::make_unique<ServerStats>(initial_timeout_, rtt_buckets_.Pointer()), |
| 146 | false)); |
ttuttle | cf1158bf | 2016-03-18 16:37:44 | [diff] [blame] | 147 | } |
[email protected] | a6c84f4 | 2013-06-07 20:39:38 | [diff] [blame] | 148 | } |
[email protected] | 7556ea2 | 2011-12-08 19:29:15 | [diff] [blame] | 149 | |
avi | 6516805 | 2015-12-01 19:27:07 | [diff] [blame] | 150 | uint16_t DnsSession::NextQueryId() const { |
| 151 | return static_cast<uint16_t>(rand_callback_.Run()); |
pkasting | 6b68a16 | 2014-12-01 22:10:29 | [diff] [blame] | 152 | } |
[email protected] | 7556ea2 | 2011-12-08 19:29:15 | [diff] [blame] | 153 | |
[email protected] | a6c84f4 | 2013-06-07 20:39:38 | [diff] [blame] | 154 | unsigned DnsSession::NextFirstServerIndex() { |
| 155 | unsigned index = NextGoodServerIndex(server_index_); |
[email protected] | 7556ea2 | 2011-12-08 19:29:15 | [diff] [blame] | 156 | if (config_.rotate) |
| 157 | server_index_ = (server_index_ + 1) % config_.nameservers.size(); |
[email protected] | d0d49dd8 | 2012-01-26 00:03:59 | [diff] [blame] | 158 | return index; |
[email protected] | 7556ea2 | 2011-12-08 19:29:15 | [diff] [blame] | 159 | } |
| 160 | |
[email protected] | a6c84f4 | 2013-06-07 20:39:38 | [diff] [blame] | 161 | unsigned DnsSession::NextGoodServerIndex(unsigned server_index) { |
Brad Lassey | 786929ad | 2018-02-21 20:54:27 | [diff] [blame] | 162 | DCHECK_GE(server_index, 0u); |
| 163 | DCHECK_LT(server_index, config_.nameservers.size()); |
[email protected] | a6c84f4 | 2013-06-07 20:39:38 | [diff] [blame] | 164 | unsigned index = server_index; |
| 165 | base::Time oldest_server_failure(base::Time::Now()); |
| 166 | unsigned oldest_server_failure_index = 0; |
| 167 | |
[email protected] | a6c84f4 | 2013-06-07 20:39:38 | [diff] [blame] | 168 | do { |
[email protected] | a6c84f4 | 2013-06-07 20:39:38 | [diff] [blame] | 169 | // If number of failures on this server doesn't exceed number of allowed |
| 170 | // attempts, return its index. |
| 171 | if (server_stats_[server_index]->last_failure_count < config_.attempts) { |
| 172 | return index; |
| 173 | } |
| 174 | // Track oldest failed server. |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 175 | base::Time cur_server_failure = server_stats_[index]->last_failure; |
[email protected] | a6c84f4 | 2013-06-07 20:39:38 | [diff] [blame] | 176 | if (cur_server_failure < oldest_server_failure) { |
| 177 | oldest_server_failure = cur_server_failure; |
| 178 | oldest_server_failure_index = index; |
| 179 | } |
| 180 | index = (index + 1) % config_.nameservers.size(); |
| 181 | } while (index != server_index); |
| 182 | |
| 183 | // If we are here it means that there are no successful servers, so we have |
| 184 | // to use one that has failed oldest. |
| 185 | return oldest_server_failure_index; |
| 186 | } |
| 187 | |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 188 | int DnsSession::NextGoodDohServerIndex( |
| 189 | unsigned doh_server_index, |
| 190 | DnsConfig::SecureDnsMode secure_dns_mode) { |
| 191 | DCHECK_GE(doh_server_index, 0u); |
| 192 | DCHECK_LT(doh_server_index, config_.dns_over_https_servers.size()); |
| 193 | unsigned index = doh_server_index; |
Brad Lassey | 786929ad | 2018-02-21 20:54:27 | [diff] [blame] | 194 | base::Time oldest_server_failure(base::Time::Now()); |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 195 | int oldest_available_server_failure_index = -1; |
Brad Lassey | 786929ad | 2018-02-21 20:54:27 | [diff] [blame] | 196 | |
| 197 | do { |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 198 | // For a server to be considered "available", the server must have a |
| 199 | // successful probe status if we are in AUTOMATIC mode. |
| 200 | if (secure_dns_mode == DnsConfig::SecureDnsMode::SECURE || |
| 201 | doh_server_stats_[index].second) { |
| 202 | // If number of failures on this server doesn't exceed |config_.attempts|, |
| 203 | // return its index. |config_.attempts| will generally be more restrictive |
| 204 | // than |kAutomaticModeFailureLimit|, although this is not guaranteed. |
| 205 | const ServerStats* stats = |
| 206 | GetServerStats(index, true /* is_doh_server */); |
| 207 | if (stats->last_failure_count < config_.attempts) { |
| 208 | return index; |
| 209 | } |
| 210 | // Track oldest failed available server. |
| 211 | base::Time cur_server_failure = stats->last_failure; |
| 212 | if (cur_server_failure < oldest_server_failure) { |
| 213 | oldest_server_failure = cur_server_failure; |
| 214 | oldest_available_server_failure_index = index; |
| 215 | } |
Brad Lassey | 786929ad | 2018-02-21 20:54:27 | [diff] [blame] | 216 | } |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 217 | index = (index + 1) % config_.dns_over_https_servers.size(); |
| 218 | } while (index != doh_server_index); |
Brad Lassey | 786929ad | 2018-02-21 20:54:27 | [diff] [blame] | 219 | |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 220 | // If we are here it means that there are either no available DoH servers or |
| 221 | // that all available DoH servers have at least |config_.attempts| consecutive |
| 222 | // failures. In the latter case, we'll return the available DoH server that |
| 223 | // failed least recently. In the former case we return -1. |
| 224 | return oldest_available_server_failure_index; |
Brad Lassey | 786929ad | 2018-02-21 20:54:27 | [diff] [blame] | 225 | } |
| 226 | |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 227 | bool DnsSession::HasAvailableDohServer() { |
| 228 | for (const auto& doh_stats_ : doh_server_stats_) { |
| 229 | if (doh_stats_.second) |
| 230 | return true; |
| 231 | } |
| 232 | return false; |
[email protected] | a6c84f4 | 2013-06-07 20:39:38 | [diff] [blame] | 233 | } |
| 234 | |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 235 | unsigned DnsSession::NumAvailableDohServers() { |
| 236 | unsigned count = 0; |
| 237 | for (const auto& doh_stats_ : doh_server_stats_) { |
| 238 | if (doh_stats_.second) |
| 239 | count++; |
| 240 | } |
| 241 | return count; |
[email protected] | a6c84f4 | 2013-06-07 20:39:38 | [diff] [blame] | 242 | } |
| 243 | |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 244 | DnsSession::ServerStats* DnsSession::GetServerStats(unsigned server_index, |
| 245 | bool is_doh_server) { |
| 246 | DCHECK_GE(server_index, 0u); |
| 247 | if (!is_doh_server) { |
| 248 | DCHECK_LT(server_index, config_.nameservers.size()); |
| 249 | return server_stats_[server_index].get(); |
| 250 | } else { |
| 251 | DCHECK_LT(server_index, config_.dns_over_https_servers.size()); |
| 252 | return doh_server_stats_[server_index].first.get(); |
| 253 | } |
| 254 | } |
| 255 | |
| 256 | void DnsSession::RecordServerFailure(unsigned server_index, |
| 257 | bool is_doh_server) { |
| 258 | ServerStats* stats = GetServerStats(server_index, is_doh_server); |
| 259 | ++(stats->last_failure_count); |
| 260 | stats->last_failure = base::Time::Now(); |
| 261 | |
| 262 | if (is_doh_server && |
| 263 | stats->last_failure_count >= kAutomaticModeFailureLimit) { |
| 264 | SetProbeSuccess(server_index, false /* success */); |
| 265 | } |
| 266 | } |
| 267 | |
| 268 | void DnsSession::RecordServerSuccess(unsigned server_index, |
| 269 | bool is_doh_server) { |
| 270 | ServerStats* stats = GetServerStats(server_index, is_doh_server); |
| 271 | |
| 272 | // DoH queries can be sent using more than one URLRequestContext. A success |
| 273 | // from one URLRequestContext shouldn't zero out failures that may be |
| 274 | // consistently occurring for another URLRequestContext. |
| 275 | if (!is_doh_server) |
| 276 | stats->last_failure_count = 0; |
| 277 | stats->last_failure = base::Time(); |
| 278 | stats->last_success = base::Time::Now(); |
| 279 | } |
| 280 | |
| 281 | void DnsSession::SetProbeSuccess(unsigned doh_server_index, bool success) { |
| 282 | DCHECK_GE(doh_server_index, 0u); |
| 283 | DCHECK_LT(doh_server_index, config_.dns_over_https_servers.size()); |
Eric Orth | a3559ca | 2019-09-05 23:40:54 | [diff] [blame] | 284 | |
| 285 | bool doh_available_before = HasAvailableDohServer(); |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 286 | doh_server_stats_[doh_server_index].second = success; |
Eric Orth | a3559ca | 2019-09-05 23:40:54 | [diff] [blame] | 287 | |
| 288 | if (doh_available_before != HasAvailableDohServer()) |
| 289 | NetworkChangeNotifier::TriggerNonSystemDnsChange(); |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 290 | } |
| 291 | |
| 292 | void DnsSession::RecordRTT(unsigned server_index, |
| 293 | bool is_doh_server, |
dalyk | 6ab72db | 2019-09-04 23:12:11 | [diff] [blame] | 294 | base::TimeDelta rtt, |
| 295 | int rv) { |
| 296 | RecordRTTForHistogram(server_index, is_doh_server, rtt, rv); |
| 297 | |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 298 | ServerStats* stats = GetServerStats(server_index, is_doh_server); |
[email protected] | ae1b30b | 2013-05-23 23:06:03 | [diff] [blame] | 299 | |
[email protected] | ae1b30b | 2013-05-23 23:06:03 | [diff] [blame] | 300 | // Jacobson/Karels algorithm for TCP. |
| 301 | // Using parameters: alpha = 1/8, delta = 1/4, beta = 4 |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 302 | base::TimeDelta& estimate = stats->rtt_estimate; |
| 303 | base::TimeDelta& deviation = stats->rtt_deviation; |
[email protected] | ae1b30b | 2013-05-23 23:06:03 | [diff] [blame] | 304 | base::TimeDelta current_error = rtt - estimate; |
| 305 | estimate += current_error / 8; // * alpha |
| 306 | base::TimeDelta abs_error = base::TimeDelta::FromInternalValue( |
| 307 | std::abs(current_error.ToInternalValue())); |
| 308 | deviation += (abs_error - deviation) / 4; // * delta |
| 309 | |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 310 | // RTT values shouldn't be less than 0, but it shouldn't cause a crash if |
| 311 | // they are anyway, so clip to 0. See https://crbug.com/753568. |
Miriam Gershenson | 68378c6 | 2017-08-10 22:26:25 | [diff] [blame] | 312 | int32_t rtt_ms = rtt.InMilliseconds(); |
| 313 | if (rtt_ms < 0) |
| 314 | rtt_ms = 0; |
| 315 | |
[email protected] | ae1b30b | 2013-05-23 23:06:03 | [diff] [blame] | 316 | // Histogram-based method. |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 317 | stats->rtt_histogram->Accumulate( |
Miriam Gershenson | 68378c6 | 2017-08-10 22:26:25 | [diff] [blame] | 318 | static_cast<base::HistogramBase::Sample>(rtt_ms), 1); |
[email protected] | ae1b30b | 2013-05-23 23:06:03 | [diff] [blame] | 319 | } |
| 320 | |
[email protected] | ae1b30b | 2013-05-23 23:06:03 | [diff] [blame] | 321 | base::TimeDelta DnsSession::NextTimeout(unsigned server_index, int attempt) { |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 322 | return NextTimeoutHelper( |
| 323 | GetServerStats(server_index, false /* is _doh_server */), |
| 324 | attempt / config_.nameservers.size()); |
| 325 | } |
| 326 | |
| 327 | base::TimeDelta DnsSession::NextDohTimeout(unsigned doh_server_index) { |
| 328 | return NextTimeoutHelper( |
| 329 | GetServerStats(doh_server_index, true /* is _doh_server */), |
| 330 | 0 /* num_backoffs */); |
| 331 | } |
| 332 | |
| 333 | base::TimeDelta DnsSession::NextTimeoutHelper(ServerStats* server_stats, |
| 334 | int num_backoffs) { |
ttuttle | cf1158bf | 2016-03-18 16:37:44 | [diff] [blame] | 335 | // Respect initial timeout (from config or field trial) if it exceeds max. |
| 336 | if (initial_timeout_ > max_timeout_) |
| 337 | return initial_timeout_; |
Paul Jensen | f359324 | 2018-12-04 19:15:18 | [diff] [blame] | 338 | |
Paul Jensen | f359324 | 2018-12-04 19:15:18 | [diff] [blame] | 339 | static_assert(std::numeric_limits<base::HistogramBase::Count>::is_signed, |
| 340 | "histogram base count assumed to be signed"); |
| 341 | |
| 342 | // Use fixed percentile of observed samples. |
dalyk | c2adf18 | 2019-09-02 14:31:22 | [diff] [blame] | 343 | const base::SampleVector& samples = *server_stats->rtt_histogram; |
Paul Jensen | f359324 | 2018-12-04 19:15:18 | [diff] [blame] | 344 | |
| 345 | base::HistogramBase::Count total = samples.TotalCount(); |
| 346 | base::HistogramBase::Count remaining_count = kRTOPercentile * total / 100; |
| 347 | size_t index = 0; |
| 348 | while (remaining_count > 0 && index < rtt_buckets_.Get().size()) { |
| 349 | remaining_count -= samples.GetCountAtIndex(index); |
| 350 | ++index; |
| 351 | } |
| 352 | |
| 353 | base::TimeDelta timeout = |
| 354 | base::TimeDelta::FromMilliseconds(rtt_buckets_.Get().range(index)); |
| 355 | |
| 356 | timeout = std::max(timeout, base::TimeDelta::FromMilliseconds(kMinTimeoutMs)); |
| 357 | |
Paul Jensen | f359324 | 2018-12-04 19:15:18 | [diff] [blame] | 358 | return std::min(timeout * (1 << num_backoffs), max_timeout_); |
[email protected] | 7556ea2 | 2011-12-08 19:29:15 | [diff] [blame] | 359 | } |
| 360 | |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 361 | // Allocate a socket, already connected to the server address. |
danakj | 22f90e7 | 2016-04-16 01:55:40 | [diff] [blame] | 362 | std::unique_ptr<DnsSession::SocketLease> DnsSession::AllocateSocket( |
| 363 | unsigned server_index, |
mikecirone | f22f981 | 2016-10-04 03:40:19 | [diff] [blame] | 364 | const NetLogSource& source) { |
danakj | 22f90e7 | 2016-04-16 01:55:40 | [diff] [blame] | 365 | std::unique_ptr<DatagramClientSocket> socket; |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 366 | |
| 367 | socket = socket_pool_->AllocateSocket(server_index); |
[email protected] | dd946bb | 2013-06-12 22:53:01 | [diff] [blame] | 368 | if (!socket.get()) |
danakj | 22f90e7 | 2016-04-16 01:55:40 | [diff] [blame] | 369 | return std::unique_ptr<SocketLease>(); |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 370 | |
Eric Roman | 06bd974 | 2019-07-13 15:19:13 | [diff] [blame] | 371 | socket->NetLog().BeginEventReferencingSource(NetLogEventType::SOCKET_IN_USE, |
| 372 | source); |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 373 | |
dcheng | c7eeda42 | 2015-12-26 03:56:48 | [diff] [blame] | 374 | SocketLease* lease = new SocketLease(this, server_index, std::move(socket)); |
danakj | 22f90e7 | 2016-04-16 01:55:40 | [diff] [blame] | 375 | return std::unique_ptr<SocketLease>(lease); |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 376 | } |
| 377 | |
danakj | 22f90e7 | 2016-04-16 01:55:40 | [diff] [blame] | 378 | std::unique_ptr<StreamSocket> DnsSession::CreateTCPSocket( |
| 379 | unsigned server_index, |
mikecirone | f22f981 | 2016-10-04 03:40:19 | [diff] [blame] | 380 | const NetLogSource& source) { |
[email protected] | bdb6598 | 2012-12-20 20:44:59 | [diff] [blame] | 381 | return socket_pool_->CreateTCPSocket(server_index, source); |
| 382 | } |
| 383 | |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 384 | // Release a socket. |
[email protected] | ae1b30b | 2013-05-23 23:06:03 | [diff] [blame] | 385 | void DnsSession::FreeSocket(unsigned server_index, |
danakj | 22f90e7 | 2016-04-16 01:55:40 | [diff] [blame] | 386 | std::unique_ptr<DatagramClientSocket> socket) { |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 387 | DCHECK(socket.get()); |
| 388 | |
mikecirone | 8b85c43 | 2016-09-08 19:11:00 | [diff] [blame] | 389 | socket->NetLog().EndEvent(NetLogEventType::SOCKET_IN_USE); |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 390 | |
dcheng | c7eeda42 | 2015-12-26 03:56:48 | [diff] [blame] | 391 | socket_pool_->FreeSocket(server_index, std::move(socket)); |
[email protected] | 120d38d | 2012-12-14 01:42:32 | [diff] [blame] | 392 | } |
[email protected] | 7556ea2 | 2011-12-08 19:29:15 | [diff] [blame] | 393 | |
dalyk | 6ab72db | 2019-09-04 23:12:11 | [diff] [blame] | 394 | void DnsSession::RecordRTTForHistogram(unsigned server_index, |
| 395 | bool is_doh_server, |
| 396 | base::TimeDelta rtt, |
| 397 | int rv) { |
| 398 | std::string query_type; |
| 399 | std::string provider_id; |
| 400 | if (is_doh_server) { |
| 401 | // Secure queries are validated if the DoH server state is available. |
| 402 | if (doh_server_stats_[server_index].second) |
| 403 | query_type = "SecureValidated"; |
| 404 | else |
| 405 | query_type = "SecureNotValidated"; |
| 406 | provider_id = GetDohProviderIdForHistogramFromDohConfig( |
| 407 | config_.dns_over_https_servers[server_index]); |
| 408 | } else { |
| 409 | query_type = "Insecure"; |
| 410 | provider_id = GetDohProviderIdForHistogramFromNameserver( |
| 411 | config_.nameservers[server_index]); |
| 412 | } |
| 413 | if (rv == OK || rv == ERR_NAME_NOT_RESOLVED) { |
| 414 | base::UmaHistogramMediumTimes( |
| 415 | base::StringPrintf("Net.DNS.DnsTransaction.%s.%s.SuccessTime", |
| 416 | query_type.c_str(), provider_id.c_str()), |
| 417 | rtt); |
| 418 | } else { |
| 419 | base::UmaHistogramMediumTimes( |
| 420 | base::StringPrintf("Net.DNS.DnsTransaction.%s.%s.FailureTime", |
| 421 | query_type.c_str(), provider_id.c_str()), |
| 422 | rtt); |
| 423 | if (is_doh_server) { |
| 424 | base::UmaHistogramSparse( |
| 425 | base::StringPrintf("Net.DNS.DnsTransaction.%s.%s.FailureError", |
| 426 | query_type.c_str(), provider_id.c_str()), |
| 427 | std::abs(rv)); |
| 428 | } |
| 429 | } |
| 430 | } |
| 431 | |
[email protected] | 7556ea2 | 2011-12-08 19:29:15 | [diff] [blame] | 432 | } // namespace net |