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