Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
be6e6707 | 2 | /* RxRPC remote transport endpoint record management |
17926a79 | 3 | * |
be6e6707 | 4 | * Copyright (C) 2007, 2016 Red Hat, Inc. All Rights Reserved. |
17926a79 | 5 | * Written by David Howells (dhowells@redhat.com) |
17926a79 DH |
6 | */ |
7 | ||
9b6d5398 JP |
8 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
9 | ||
17926a79 DH |
10 | #include <linux/module.h> |
11 | #include <linux/net.h> | |
12 | #include <linux/skbuff.h> | |
13 | #include <linux/udp.h> | |
14 | #include <linux/in.h> | |
75b54cb5 | 15 | #include <linux/in6.h> |
5a0e3ad6 | 16 | #include <linux/slab.h> |
be6e6707 | 17 | #include <linux/hashtable.h> |
17926a79 DH |
18 | #include <net/sock.h> |
19 | #include <net/af_rxrpc.h> | |
20 | #include <net/ip.h> | |
224711df | 21 | #include <net/route.h> |
75b54cb5 | 22 | #include <net/ip6_route.h> |
17926a79 DH |
23 | #include "ar-internal.h" |
24 | ||
be6e6707 DH |
25 | /* |
26 | * Hash a peer key. | |
27 | */ | |
28 | static unsigned long rxrpc_peer_hash_key(struct rxrpc_local *local, | |
29 | const struct sockaddr_rxrpc *srx) | |
30 | { | |
31 | const u16 *p; | |
32 | unsigned int i, size; | |
33 | unsigned long hash_key; | |
34 | ||
35 | _enter(""); | |
36 | ||
37 | hash_key = (unsigned long)local / __alignof__(*local); | |
38 | hash_key += srx->transport_type; | |
39 | hash_key += srx->transport_len; | |
40 | hash_key += srx->transport.family; | |
41 | ||
42 | switch (srx->transport.family) { | |
43 | case AF_INET: | |
44 | hash_key += (u16 __force)srx->transport.sin.sin_port; | |
45 | size = sizeof(srx->transport.sin.sin_addr); | |
46 | p = (u16 *)&srx->transport.sin.sin_addr; | |
47 | break; | |
d1912747 | 48 | #ifdef CONFIG_AF_RXRPC_IPV6 |
75b54cb5 DH |
49 | case AF_INET6: |
50 | hash_key += (u16 __force)srx->transport.sin.sin_port; | |
51 | size = sizeof(srx->transport.sin6.sin6_addr); | |
52 | p = (u16 *)&srx->transport.sin6.sin6_addr; | |
53 | break; | |
d1912747 | 54 | #endif |
2f9f9f52 AB |
55 | default: |
56 | WARN(1, "AF_RXRPC: Unsupported transport address family\n"); | |
57 | return 0; | |
be6e6707 DH |
58 | } |
59 | ||
60 | /* Step through the peer address in 16-bit portions for speed */ | |
61 | for (i = 0; i < size; i += sizeof(*p), p++) | |
62 | hash_key += *p; | |
63 | ||
64 | _leave(" 0x%lx", hash_key); | |
65 | return hash_key; | |
66 | } | |
67 | ||
68 | /* | |
69 | * Compare a peer to a key. Return -ve, 0 or +ve to indicate less than, same | |
70 | * or greater than. | |
71 | * | |
72 | * Unfortunately, the primitives in linux/hashtable.h don't allow for sorted | |
73 | * buckets and mid-bucket insertion, so we don't make full use of this | |
74 | * information at this point. | |
75 | */ | |
76 | static long rxrpc_peer_cmp_key(const struct rxrpc_peer *peer, | |
77 | struct rxrpc_local *local, | |
78 | const struct sockaddr_rxrpc *srx, | |
79 | unsigned long hash_key) | |
80 | { | |
81 | long diff; | |
82 | ||
83 | diff = ((peer->hash_key - hash_key) ?: | |
84 | ((unsigned long)peer->local - (unsigned long)local) ?: | |
85 | (peer->srx.transport_type - srx->transport_type) ?: | |
86 | (peer->srx.transport_len - srx->transport_len) ?: | |
87 | (peer->srx.transport.family - srx->transport.family)); | |
88 | if (diff != 0) | |
89 | return diff; | |
90 | ||
91 | switch (srx->transport.family) { | |
92 | case AF_INET: | |
93 | return ((u16 __force)peer->srx.transport.sin.sin_port - | |
94 | (u16 __force)srx->transport.sin.sin_port) ?: | |
95 | memcmp(&peer->srx.transport.sin.sin_addr, | |
96 | &srx->transport.sin.sin_addr, | |
97 | sizeof(struct in_addr)); | |
d1912747 | 98 | #ifdef CONFIG_AF_RXRPC_IPV6 |
75b54cb5 DH |
99 | case AF_INET6: |
100 | return ((u16 __force)peer->srx.transport.sin6.sin6_port - | |
101 | (u16 __force)srx->transport.sin6.sin6_port) ?: | |
102 | memcmp(&peer->srx.transport.sin6.sin6_addr, | |
103 | &srx->transport.sin6.sin6_addr, | |
104 | sizeof(struct in6_addr)); | |
d1912747 | 105 | #endif |
be6e6707 DH |
106 | default: |
107 | BUG(); | |
108 | } | |
109 | } | |
110 | ||
111 | /* | |
112 | * Look up a remote transport endpoint for the specified address using RCU. | |
113 | */ | |
114 | static struct rxrpc_peer *__rxrpc_lookup_peer_rcu( | |
115 | struct rxrpc_local *local, | |
116 | const struct sockaddr_rxrpc *srx, | |
117 | unsigned long hash_key) | |
118 | { | |
119 | struct rxrpc_peer *peer; | |
2baec2c3 | 120 | struct rxrpc_net *rxnet = local->rxnet; |
be6e6707 | 121 | |
2baec2c3 | 122 | hash_for_each_possible_rcu(rxnet->peer_hash, peer, hash_link, hash_key) { |
0099dc58 | 123 | if (rxrpc_peer_cmp_key(peer, local, srx, hash_key) == 0 && |
a0575429 | 124 | refcount_read(&peer->ref) > 0) |
be6e6707 | 125 | return peer; |
be6e6707 DH |
126 | } |
127 | ||
128 | return NULL; | |
129 | } | |
130 | ||
131 | /* | |
132 | * Look up a remote transport endpoint for the specified address using RCU. | |
133 | */ | |
134 | struct rxrpc_peer *rxrpc_lookup_peer_rcu(struct rxrpc_local *local, | |
135 | const struct sockaddr_rxrpc *srx) | |
136 | { | |
137 | struct rxrpc_peer *peer; | |
138 | unsigned long hash_key = rxrpc_peer_hash_key(local, srx); | |
139 | ||
140 | peer = __rxrpc_lookup_peer_rcu(local, srx, hash_key); | |
e969c92c | 141 | if (peer) |
a0575429 | 142 | _leave(" = %p {u=%d}", peer, refcount_read(&peer->ref)); |
be6e6707 DH |
143 | return peer; |
144 | } | |
17926a79 | 145 | |
224711df DH |
146 | /* |
147 | * assess the MTU size for the network interface through which this peer is | |
148 | * reached | |
149 | */ | |
8a758d98 | 150 | static void rxrpc_assess_MTU_size(struct rxrpc_local *local, |
5e33a23b | 151 | struct rxrpc_peer *peer) |
224711df | 152 | { |
8a758d98 | 153 | struct net *net = local->net; |
75b54cb5 | 154 | struct dst_entry *dst; |
224711df | 155 | struct rtable *rt; |
75b54cb5 DH |
156 | struct flowi fl; |
157 | struct flowi4 *fl4 = &fl.u.ip4; | |
d1912747 | 158 | #ifdef CONFIG_AF_RXRPC_IPV6 |
75b54cb5 | 159 | struct flowi6 *fl6 = &fl.u.ip6; |
d1912747 | 160 | #endif |
224711df DH |
161 | |
162 | peer->if_mtu = 1500; | |
163 | ||
75b54cb5 DH |
164 | memset(&fl, 0, sizeof(fl)); |
165 | switch (peer->srx.transport.family) { | |
166 | case AF_INET: | |
167 | rt = ip_route_output_ports( | |
5e33a23b | 168 | net, fl4, NULL, |
75b54cb5 DH |
169 | peer->srx.transport.sin.sin_addr.s_addr, 0, |
170 | htons(7000), htons(7001), IPPROTO_UDP, 0, 0); | |
171 | if (IS_ERR(rt)) { | |
172 | _leave(" [route err %ld]", PTR_ERR(rt)); | |
173 | return; | |
174 | } | |
175 | dst = &rt->dst; | |
176 | break; | |
177 | ||
d1912747 | 178 | #ifdef CONFIG_AF_RXRPC_IPV6 |
75b54cb5 DH |
179 | case AF_INET6: |
180 | fl6->flowi6_iif = LOOPBACK_IFINDEX; | |
181 | fl6->flowi6_scope = RT_SCOPE_UNIVERSE; | |
182 | fl6->flowi6_proto = IPPROTO_UDP; | |
183 | memcpy(&fl6->daddr, &peer->srx.transport.sin6.sin6_addr, | |
184 | sizeof(struct in6_addr)); | |
185 | fl6->fl6_dport = htons(7001); | |
186 | fl6->fl6_sport = htons(7000); | |
5e33a23b | 187 | dst = ip6_route_output(net, NULL, fl6); |
07096f61 DH |
188 | if (dst->error) { |
189 | _leave(" [route err %d]", dst->error); | |
75b54cb5 DH |
190 | return; |
191 | } | |
192 | break; | |
d1912747 | 193 | #endif |
75b54cb5 DH |
194 | |
195 | default: | |
196 | BUG(); | |
224711df DH |
197 | } |
198 | ||
75b54cb5 DH |
199 | peer->if_mtu = dst_mtu(dst); |
200 | dst_release(dst); | |
224711df | 201 | |
a6a62b69 | 202 | _leave(" [if_mtu %u]", peer->if_mtu); |
224711df DH |
203 | } |
204 | ||
17926a79 | 205 | /* |
be6e6707 | 206 | * Allocate a peer. |
17926a79 | 207 | */ |
47c810a7 DH |
208 | struct rxrpc_peer *rxrpc_alloc_peer(struct rxrpc_local *local, gfp_t gfp, |
209 | enum rxrpc_peer_trace why) | |
17926a79 DH |
210 | { |
211 | struct rxrpc_peer *peer; | |
212 | ||
213 | _enter(""); | |
214 | ||
215 | peer = kzalloc(sizeof(struct rxrpc_peer), gfp); | |
216 | if (peer) { | |
a0575429 | 217 | refcount_set(&peer->ref, 1); |
0fde882f | 218 | peer->local = rxrpc_get_local(local, rxrpc_local_get_peer); |
f66d7490 | 219 | INIT_HLIST_HEAD(&peer->error_targets); |
aa390bbe | 220 | peer->service_conns = RB_ROOT; |
8496af50 | 221 | seqlock_init(&peer->service_conn_lock); |
17926a79 | 222 | spin_lock_init(&peer->lock); |
c1e15b49 | 223 | spin_lock_init(&peer->rtt_input_lock); |
17926a79 | 224 | peer->debug_id = atomic_inc_return(&rxrpc_debug_id); |
f7aec129 | 225 | |
c410bf01 DH |
226 | rxrpc_peer_init_rtt(peer); |
227 | ||
1fc4fa2a | 228 | peer->cong_ssthresh = RXRPC_TX_MAX_WINDOW; |
c838f1a7 | 229 | trace_rxrpc_peer(peer->debug_id, 1, why); |
be6e6707 DH |
230 | } |
231 | ||
232 | _leave(" = %p", peer); | |
233 | return peer; | |
234 | } | |
235 | ||
248f219c DH |
236 | /* |
237 | * Initialise peer record. | |
238 | */ | |
8a758d98 | 239 | static void rxrpc_init_peer(struct rxrpc_local *local, struct rxrpc_peer *peer, |
5e33a23b | 240 | unsigned long hash_key) |
248f219c | 241 | { |
08a39685 | 242 | peer->hash_key = hash_key; |
8a758d98 | 243 | rxrpc_assess_MTU_size(local, peer); |
248f219c | 244 | peer->mtu = peer->if_mtu; |
0d4b103c | 245 | peer->rtt_last_req = ktime_get_real(); |
248f219c | 246 | |
75b54cb5 DH |
247 | switch (peer->srx.transport.family) { |
248 | case AF_INET: | |
248f219c | 249 | peer->hdrsize = sizeof(struct iphdr); |
75b54cb5 | 250 | break; |
d1912747 | 251 | #ifdef CONFIG_AF_RXRPC_IPV6 |
75b54cb5 DH |
252 | case AF_INET6: |
253 | peer->hdrsize = sizeof(struct ipv6hdr); | |
254 | break; | |
d1912747 | 255 | #endif |
75b54cb5 DH |
256 | default: |
257 | BUG(); | |
258 | } | |
259 | ||
260 | switch (peer->srx.transport_type) { | |
261 | case SOCK_DGRAM: | |
262 | peer->hdrsize += sizeof(struct udphdr); | |
263 | break; | |
264 | default: | |
248f219c DH |
265 | BUG(); |
266 | } | |
267 | ||
268 | peer->hdrsize += sizeof(struct rxrpc_wire_header); | |
269 | peer->maxdata = peer->mtu - peer->hdrsize; | |
270 | } | |
271 | ||
be6e6707 DH |
272 | /* |
273 | * Set up a new peer. | |
274 | */ | |
8a758d98 | 275 | static struct rxrpc_peer *rxrpc_create_peer(struct rxrpc_local *local, |
be6e6707 DH |
276 | struct sockaddr_rxrpc *srx, |
277 | unsigned long hash_key, | |
278 | gfp_t gfp) | |
279 | { | |
280 | struct rxrpc_peer *peer; | |
281 | ||
282 | _enter(""); | |
283 | ||
47c810a7 | 284 | peer = rxrpc_alloc_peer(local, gfp, rxrpc_peer_new_client); |
be6e6707 | 285 | if (peer) { |
17926a79 | 286 | memcpy(&peer->srx, srx, sizeof(*srx)); |
8a758d98 | 287 | rxrpc_init_peer(local, peer, hash_key); |
248f219c | 288 | } |
17926a79 | 289 | |
248f219c DH |
290 | _leave(" = %p", peer); |
291 | return peer; | |
292 | } | |
17926a79 | 293 | |
beacff50 ET |
294 | static void rxrpc_free_peer(struct rxrpc_peer *peer) |
295 | { | |
47c810a7 | 296 | trace_rxrpc_peer(peer->debug_id, 0, rxrpc_peer_free); |
0fde882f | 297 | rxrpc_put_local(peer->local, rxrpc_local_put_peer); |
beacff50 ET |
298 | kfree_rcu(peer, rcu); |
299 | } | |
300 | ||
248f219c | 301 | /* |
0099dc58 DH |
302 | * Set up a new incoming peer. There shouldn't be any other matching peers |
303 | * since we've already done a search in the list from the non-reentrant context | |
304 | * (the data_ready handler) that is the only place we can add new peers. | |
248f219c | 305 | */ |
8a758d98 | 306 | void rxrpc_new_incoming_peer(struct rxrpc_local *local, struct rxrpc_peer *peer) |
248f219c | 307 | { |
2baec2c3 | 308 | struct rxrpc_net *rxnet = local->rxnet; |
248f219c DH |
309 | unsigned long hash_key; |
310 | ||
0099dc58 | 311 | hash_key = rxrpc_peer_hash_key(local, &peer->srx); |
8a758d98 | 312 | rxrpc_init_peer(local, peer, hash_key); |
248f219c | 313 | |
2baec2c3 | 314 | spin_lock(&rxnet->peer_hash_lock); |
0099dc58 DH |
315 | hash_add_rcu(rxnet->peer_hash, &peer->hash_link, hash_key); |
316 | list_add_tail(&peer->keepalive_link, &rxnet->peer_keepalive_new); | |
2baec2c3 | 317 | spin_unlock(&rxnet->peer_hash_lock); |
17926a79 DH |
318 | } |
319 | ||
320 | /* | |
321 | * obtain a remote transport endpoint for the specified address | |
322 | */ | |
8a758d98 | 323 | struct rxrpc_peer *rxrpc_lookup_peer(struct rxrpc_local *local, |
be6e6707 | 324 | struct sockaddr_rxrpc *srx, gfp_t gfp) |
17926a79 DH |
325 | { |
326 | struct rxrpc_peer *peer, *candidate; | |
2baec2c3 | 327 | struct rxrpc_net *rxnet = local->rxnet; |
be6e6707 | 328 | unsigned long hash_key = rxrpc_peer_hash_key(local, srx); |
17926a79 | 329 | |
75b54cb5 | 330 | _enter("{%pISp}", &srx->transport); |
17926a79 DH |
331 | |
332 | /* search the peer list first */ | |
be6e6707 DH |
333 | rcu_read_lock(); |
334 | peer = __rxrpc_lookup_peer_rcu(local, srx, hash_key); | |
47c810a7 | 335 | if (peer && !rxrpc_get_peer_maybe(peer, rxrpc_peer_get_lookup_client)) |
be6e6707 DH |
336 | peer = NULL; |
337 | rcu_read_unlock(); | |
338 | ||
339 | if (!peer) { | |
340 | /* The peer is not yet present in hash - create a candidate | |
341 | * for a new record and then redo the search. | |
342 | */ | |
8a758d98 | 343 | candidate = rxrpc_create_peer(local, srx, hash_key, gfp); |
be6e6707 DH |
344 | if (!candidate) { |
345 | _leave(" = NULL [nomem]"); | |
346 | return NULL; | |
347 | } | |
17926a79 | 348 | |
3dd9c8b5 | 349 | spin_lock(&rxnet->peer_hash_lock); |
17926a79 | 350 | |
be6e6707 DH |
351 | /* Need to check that we aren't racing with someone else */ |
352 | peer = __rxrpc_lookup_peer_rcu(local, srx, hash_key); | |
47c810a7 | 353 | if (peer && !rxrpc_get_peer_maybe(peer, rxrpc_peer_get_lookup_client)) |
be6e6707 | 354 | peer = NULL; |
ace45bec | 355 | if (!peer) { |
2baec2c3 | 356 | hash_add_rcu(rxnet->peer_hash, |
be6e6707 | 357 | &candidate->hash_link, hash_key); |
330bdcfa DH |
358 | list_add_tail(&candidate->keepalive_link, |
359 | &rxnet->peer_keepalive_new); | |
ace45bec | 360 | } |
17926a79 | 361 | |
3dd9c8b5 | 362 | spin_unlock(&rxnet->peer_hash_lock); |
17926a79 | 363 | |
be6e6707 | 364 | if (peer) |
beacff50 | 365 | rxrpc_free_peer(candidate); |
be6e6707 DH |
366 | else |
367 | peer = candidate; | |
368 | } | |
17926a79 | 369 | |
a0575429 | 370 | _leave(" = %p {u=%d}", peer, refcount_read(&peer->ref)); |
17926a79 | 371 | return peer; |
17926a79 DH |
372 | } |
373 | ||
374 | /* | |
1159d4b4 | 375 | * Get a ref on a peer record. |
17926a79 | 376 | */ |
47c810a7 | 377 | struct rxrpc_peer *rxrpc_get_peer(struct rxrpc_peer *peer, enum rxrpc_peer_trace why) |
1159d4b4 | 378 | { |
a0575429 | 379 | int r; |
1159d4b4 | 380 | |
a0575429 | 381 | __refcount_inc(&peer->ref, &r); |
c838f1a7 | 382 | trace_rxrpc_peer(peer->debug_id, r + 1, why); |
1159d4b4 DH |
383 | return peer; |
384 | } | |
385 | ||
386 | /* | |
387 | * Get a ref on a peer record unless its usage has already reached 0. | |
388 | */ | |
47c810a7 DH |
389 | struct rxrpc_peer *rxrpc_get_peer_maybe(struct rxrpc_peer *peer, |
390 | enum rxrpc_peer_trace why) | |
1159d4b4 | 391 | { |
a0575429 | 392 | int r; |
1159d4b4 DH |
393 | |
394 | if (peer) { | |
a0575429 | 395 | if (__refcount_inc_not_zero(&peer->ref, &r)) |
47c810a7 | 396 | trace_rxrpc_peer(peer->debug_id, r + 1, why); |
1159d4b4 DH |
397 | else |
398 | peer = NULL; | |
399 | } | |
400 | return peer; | |
401 | } | |
402 | ||
1159d4b4 DH |
403 | /* |
404 | * Discard a peer record. | |
405 | */ | |
406 | static void __rxrpc_put_peer(struct rxrpc_peer *peer) | |
17926a79 | 407 | { |
2baec2c3 DH |
408 | struct rxrpc_net *rxnet = peer->local->rxnet; |
409 | ||
f66d7490 | 410 | ASSERT(hlist_empty(&peer->error_targets)); |
17926a79 | 411 | |
3dd9c8b5 | 412 | spin_lock(&rxnet->peer_hash_lock); |
be6e6707 | 413 | hash_del_rcu(&peer->hash_link); |
330bdcfa | 414 | list_del_init(&peer->keepalive_link); |
3dd9c8b5 | 415 | spin_unlock(&rxnet->peer_hash_lock); |
17926a79 | 416 | |
beacff50 | 417 | rxrpc_free_peer(peer); |
17926a79 | 418 | } |
8324f0bc | 419 | |
1159d4b4 DH |
420 | /* |
421 | * Drop a ref on a peer record. | |
422 | */ | |
47c810a7 | 423 | void rxrpc_put_peer(struct rxrpc_peer *peer, enum rxrpc_peer_trace why) |
1159d4b4 | 424 | { |
55f6c98e | 425 | unsigned int debug_id; |
a0575429 DH |
426 | bool dead; |
427 | int r; | |
1159d4b4 DH |
428 | |
429 | if (peer) { | |
55f6c98e | 430 | debug_id = peer->debug_id; |
a0575429 | 431 | dead = __refcount_dec_and_test(&peer->ref, &r); |
47c810a7 | 432 | trace_rxrpc_peer(debug_id, r - 1, why); |
a0575429 | 433 | if (dead) |
1159d4b4 DH |
434 | __rxrpc_put_peer(peer); |
435 | } | |
436 | } | |
437 | ||
17226f12 DH |
438 | /* |
439 | * Make sure all peer records have been discarded. | |
440 | */ | |
441 | void rxrpc_destroy_all_peers(struct rxrpc_net *rxnet) | |
442 | { | |
443 | struct rxrpc_peer *peer; | |
444 | int i; | |
445 | ||
446 | for (i = 0; i < HASH_SIZE(rxnet->peer_hash); i++) { | |
447 | if (hlist_empty(&rxnet->peer_hash[i])) | |
448 | continue; | |
449 | ||
450 | hlist_for_each_entry(peer, &rxnet->peer_hash[i], hash_link) { | |
451 | pr_err("Leaked peer %u {%u} %pISp\n", | |
452 | peer->debug_id, | |
a0575429 | 453 | refcount_read(&peer->ref), |
17226f12 DH |
454 | &peer->srx.transport); |
455 | } | |
456 | } | |
457 | } | |
458 | ||
8324f0bc DH |
459 | /** |
460 | * rxrpc_kernel_get_peer - Get the peer address of a call | |
461 | * @sock: The socket on which the call is in progress. | |
462 | * @call: The call to query | |
463 | * @_srx: Where to place the result | |
464 | * | |
465 | * Get the address of the remote peer in a call. | |
466 | */ | |
467 | void rxrpc_kernel_get_peer(struct socket *sock, struct rxrpc_call *call, | |
468 | struct sockaddr_rxrpc *_srx) | |
469 | { | |
470 | *_srx = call->peer->srx; | |
471 | } | |
472 | EXPORT_SYMBOL(rxrpc_kernel_get_peer); | |
f4d15fb6 DH |
473 | |
474 | /** | |
c410bf01 | 475 | * rxrpc_kernel_get_srtt - Get a call's peer smoothed RTT |
f4d15fb6 DH |
476 | * @sock: The socket on which the call is in progress. |
477 | * @call: The call to query | |
1d4adfaf | 478 | * @_srtt: Where to store the SRTT value. |
f4d15fb6 | 479 | * |
1d4adfaf | 480 | * Get the call's peer smoothed RTT in uS. |
f4d15fb6 | 481 | */ |
1d4adfaf DH |
482 | bool rxrpc_kernel_get_srtt(struct socket *sock, struct rxrpc_call *call, |
483 | u32 *_srtt) | |
f4d15fb6 | 484 | { |
1d4adfaf DH |
485 | struct rxrpc_peer *peer = call->peer; |
486 | ||
487 | if (peer->rtt_count == 0) { | |
488 | *_srtt = 1000000; /* 1S */ | |
489 | return false; | |
490 | } | |
491 | ||
492 | *_srtt = call->peer->srtt_us >> 3; | |
493 | return true; | |
f4d15fb6 | 494 | } |
c410bf01 | 495 | EXPORT_SYMBOL(rxrpc_kernel_get_srtt); |