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 | static DEFINE_HASHTABLE(rxrpc_peer_hash, 10); |
30 | static DEFINE_SPINLOCK(rxrpc_peer_hash_lock); | |
17926a79 | 31 | |
be6e6707 DH |
32 | /* |
33 | * Hash a peer key. | |
34 | */ | |
35 | static unsigned long rxrpc_peer_hash_key(struct rxrpc_local *local, | |
36 | const struct sockaddr_rxrpc *srx) | |
37 | { | |
38 | const u16 *p; | |
39 | unsigned int i, size; | |
40 | unsigned long hash_key; | |
41 | ||
42 | _enter(""); | |
43 | ||
44 | hash_key = (unsigned long)local / __alignof__(*local); | |
45 | hash_key += srx->transport_type; | |
46 | hash_key += srx->transport_len; | |
47 | hash_key += srx->transport.family; | |
48 | ||
49 | switch (srx->transport.family) { | |
50 | case AF_INET: | |
51 | hash_key += (u16 __force)srx->transport.sin.sin_port; | |
52 | size = sizeof(srx->transport.sin.sin_addr); | |
53 | p = (u16 *)&srx->transport.sin.sin_addr; | |
54 | break; | |
d1912747 | 55 | #ifdef CONFIG_AF_RXRPC_IPV6 |
75b54cb5 DH |
56 | case AF_INET6: |
57 | hash_key += (u16 __force)srx->transport.sin.sin_port; | |
58 | size = sizeof(srx->transport.sin6.sin6_addr); | |
59 | p = (u16 *)&srx->transport.sin6.sin6_addr; | |
60 | break; | |
d1912747 | 61 | #endif |
2f9f9f52 AB |
62 | default: |
63 | WARN(1, "AF_RXRPC: Unsupported transport address family\n"); | |
64 | return 0; | |
be6e6707 DH |
65 | } |
66 | ||
67 | /* Step through the peer address in 16-bit portions for speed */ | |
68 | for (i = 0; i < size; i += sizeof(*p), p++) | |
69 | hash_key += *p; | |
70 | ||
71 | _leave(" 0x%lx", hash_key); | |
72 | return hash_key; | |
73 | } | |
74 | ||
75 | /* | |
76 | * Compare a peer to a key. Return -ve, 0 or +ve to indicate less than, same | |
77 | * or greater than. | |
78 | * | |
79 | * Unfortunately, the primitives in linux/hashtable.h don't allow for sorted | |
80 | * buckets and mid-bucket insertion, so we don't make full use of this | |
81 | * information at this point. | |
82 | */ | |
83 | static long rxrpc_peer_cmp_key(const struct rxrpc_peer *peer, | |
84 | struct rxrpc_local *local, | |
85 | const struct sockaddr_rxrpc *srx, | |
86 | unsigned long hash_key) | |
87 | { | |
88 | long diff; | |
89 | ||
90 | diff = ((peer->hash_key - hash_key) ?: | |
91 | ((unsigned long)peer->local - (unsigned long)local) ?: | |
92 | (peer->srx.transport_type - srx->transport_type) ?: | |
93 | (peer->srx.transport_len - srx->transport_len) ?: | |
94 | (peer->srx.transport.family - srx->transport.family)); | |
95 | if (diff != 0) | |
96 | return diff; | |
97 | ||
98 | switch (srx->transport.family) { | |
99 | case AF_INET: | |
100 | return ((u16 __force)peer->srx.transport.sin.sin_port - | |
101 | (u16 __force)srx->transport.sin.sin_port) ?: | |
102 | memcmp(&peer->srx.transport.sin.sin_addr, | |
103 | &srx->transport.sin.sin_addr, | |
104 | sizeof(struct in_addr)); | |
d1912747 | 105 | #ifdef CONFIG_AF_RXRPC_IPV6 |
75b54cb5 DH |
106 | case AF_INET6: |
107 | return ((u16 __force)peer->srx.transport.sin6.sin6_port - | |
108 | (u16 __force)srx->transport.sin6.sin6_port) ?: | |
109 | memcmp(&peer->srx.transport.sin6.sin6_addr, | |
110 | &srx->transport.sin6.sin6_addr, | |
111 | sizeof(struct in6_addr)); | |
d1912747 | 112 | #endif |
be6e6707 DH |
113 | default: |
114 | BUG(); | |
115 | } | |
116 | } | |
117 | ||
118 | /* | |
119 | * Look up a remote transport endpoint for the specified address using RCU. | |
120 | */ | |
121 | static struct rxrpc_peer *__rxrpc_lookup_peer_rcu( | |
122 | struct rxrpc_local *local, | |
123 | const struct sockaddr_rxrpc *srx, | |
124 | unsigned long hash_key) | |
125 | { | |
126 | struct rxrpc_peer *peer; | |
127 | ||
128 | hash_for_each_possible_rcu(rxrpc_peer_hash, peer, hash_link, hash_key) { | |
129 | if (rxrpc_peer_cmp_key(peer, local, srx, hash_key) == 0) { | |
130 | if (atomic_read(&peer->usage) == 0) | |
131 | return NULL; | |
132 | return peer; | |
133 | } | |
134 | } | |
135 | ||
136 | return NULL; | |
137 | } | |
138 | ||
139 | /* | |
140 | * Look up a remote transport endpoint for the specified address using RCU. | |
141 | */ | |
142 | struct rxrpc_peer *rxrpc_lookup_peer_rcu(struct rxrpc_local *local, | |
143 | const struct sockaddr_rxrpc *srx) | |
144 | { | |
145 | struct rxrpc_peer *peer; | |
146 | unsigned long hash_key = rxrpc_peer_hash_key(local, srx); | |
147 | ||
148 | peer = __rxrpc_lookup_peer_rcu(local, srx, hash_key); | |
149 | if (peer) { | |
75b54cb5 | 150 | _net("PEER %d {%pISp}", peer->debug_id, &peer->srx.transport); |
be6e6707 DH |
151 | _leave(" = %p {u=%d}", peer, atomic_read(&peer->usage)); |
152 | } | |
153 | return peer; | |
154 | } | |
17926a79 | 155 | |
224711df DH |
156 | /* |
157 | * assess the MTU size for the network interface through which this peer is | |
158 | * reached | |
159 | */ | |
160 | static void rxrpc_assess_MTU_size(struct rxrpc_peer *peer) | |
161 | { | |
75b54cb5 | 162 | struct dst_entry *dst; |
224711df | 163 | struct rtable *rt; |
75b54cb5 DH |
164 | struct flowi fl; |
165 | struct flowi4 *fl4 = &fl.u.ip4; | |
d1912747 | 166 | #ifdef CONFIG_AF_RXRPC_IPV6 |
75b54cb5 | 167 | struct flowi6 *fl6 = &fl.u.ip6; |
d1912747 | 168 | #endif |
224711df DH |
169 | |
170 | peer->if_mtu = 1500; | |
171 | ||
75b54cb5 DH |
172 | memset(&fl, 0, sizeof(fl)); |
173 | switch (peer->srx.transport.family) { | |
174 | case AF_INET: | |
175 | rt = ip_route_output_ports( | |
176 | &init_net, fl4, NULL, | |
177 | peer->srx.transport.sin.sin_addr.s_addr, 0, | |
178 | htons(7000), htons(7001), IPPROTO_UDP, 0, 0); | |
179 | if (IS_ERR(rt)) { | |
180 | _leave(" [route err %ld]", PTR_ERR(rt)); | |
181 | return; | |
182 | } | |
183 | dst = &rt->dst; | |
184 | break; | |
185 | ||
d1912747 | 186 | #ifdef CONFIG_AF_RXRPC_IPV6 |
75b54cb5 DH |
187 | case AF_INET6: |
188 | fl6->flowi6_iif = LOOPBACK_IFINDEX; | |
189 | fl6->flowi6_scope = RT_SCOPE_UNIVERSE; | |
190 | fl6->flowi6_proto = IPPROTO_UDP; | |
191 | memcpy(&fl6->daddr, &peer->srx.transport.sin6.sin6_addr, | |
192 | sizeof(struct in6_addr)); | |
193 | fl6->fl6_dport = htons(7001); | |
194 | fl6->fl6_sport = htons(7000); | |
195 | dst = ip6_route_output(&init_net, NULL, fl6); | |
07096f61 DH |
196 | if (dst->error) { |
197 | _leave(" [route err %d]", dst->error); | |
75b54cb5 DH |
198 | return; |
199 | } | |
200 | break; | |
d1912747 | 201 | #endif |
75b54cb5 DH |
202 | |
203 | default: | |
204 | BUG(); | |
224711df DH |
205 | } |
206 | ||
75b54cb5 DH |
207 | peer->if_mtu = dst_mtu(dst); |
208 | dst_release(dst); | |
224711df | 209 | |
a6a62b69 | 210 | _leave(" [if_mtu %u]", peer->if_mtu); |
224711df DH |
211 | } |
212 | ||
17926a79 | 213 | /* |
be6e6707 | 214 | * Allocate a peer. |
17926a79 | 215 | */ |
be6e6707 | 216 | struct rxrpc_peer *rxrpc_alloc_peer(struct rxrpc_local *local, gfp_t gfp) |
17926a79 DH |
217 | { |
218 | struct rxrpc_peer *peer; | |
219 | ||
220 | _enter(""); | |
221 | ||
222 | peer = kzalloc(sizeof(struct rxrpc_peer), gfp); | |
223 | if (peer) { | |
be6e6707 DH |
224 | atomic_set(&peer->usage, 1); |
225 | peer->local = local; | |
f66d7490 DH |
226 | INIT_HLIST_HEAD(&peer->error_targets); |
227 | INIT_WORK(&peer->error_distributor, | |
228 | &rxrpc_peer_error_distributor); | |
aa390bbe | 229 | peer->service_conns = RB_ROOT; |
8496af50 | 230 | seqlock_init(&peer->service_conn_lock); |
17926a79 | 231 | spin_lock_init(&peer->lock); |
17926a79 | 232 | peer->debug_id = atomic_inc_return(&rxrpc_debug_id); |
be6e6707 DH |
233 | } |
234 | ||
235 | _leave(" = %p", peer); | |
236 | return peer; | |
237 | } | |
238 | ||
248f219c DH |
239 | /* |
240 | * Initialise peer record. | |
241 | */ | |
242 | static void rxrpc_init_peer(struct rxrpc_peer *peer, unsigned long hash_key) | |
243 | { | |
08a39685 | 244 | peer->hash_key = hash_key; |
248f219c DH |
245 | rxrpc_assess_MTU_size(peer); |
246 | peer->mtu = peer->if_mtu; | |
0d4b103c | 247 | peer->rtt_last_req = ktime_get_real(); |
248f219c | 248 | |
75b54cb5 DH |
249 | switch (peer->srx.transport.family) { |
250 | case AF_INET: | |
248f219c | 251 | peer->hdrsize = sizeof(struct iphdr); |
75b54cb5 | 252 | break; |
d1912747 | 253 | #ifdef CONFIG_AF_RXRPC_IPV6 |
75b54cb5 DH |
254 | case AF_INET6: |
255 | peer->hdrsize = sizeof(struct ipv6hdr); | |
256 | break; | |
d1912747 | 257 | #endif |
75b54cb5 DH |
258 | default: |
259 | BUG(); | |
260 | } | |
261 | ||
262 | switch (peer->srx.transport_type) { | |
263 | case SOCK_DGRAM: | |
264 | peer->hdrsize += sizeof(struct udphdr); | |
265 | break; | |
266 | default: | |
248f219c DH |
267 | BUG(); |
268 | } | |
269 | ||
270 | peer->hdrsize += sizeof(struct rxrpc_wire_header); | |
271 | peer->maxdata = peer->mtu - peer->hdrsize; | |
272 | } | |
273 | ||
be6e6707 DH |
274 | /* |
275 | * Set up a new peer. | |
276 | */ | |
277 | static struct rxrpc_peer *rxrpc_create_peer(struct rxrpc_local *local, | |
278 | struct sockaddr_rxrpc *srx, | |
279 | unsigned long hash_key, | |
280 | gfp_t gfp) | |
281 | { | |
282 | struct rxrpc_peer *peer; | |
283 | ||
284 | _enter(""); | |
285 | ||
286 | peer = rxrpc_alloc_peer(local, gfp); | |
287 | if (peer) { | |
17926a79 | 288 | memcpy(&peer->srx, srx, sizeof(*srx)); |
248f219c DH |
289 | rxrpc_init_peer(peer, hash_key); |
290 | } | |
17926a79 | 291 | |
248f219c DH |
292 | _leave(" = %p", peer); |
293 | return peer; | |
294 | } | |
17926a79 | 295 | |
248f219c DH |
296 | /* |
297 | * Set up a new incoming peer. The address is prestored in the preallocated | |
298 | * peer. | |
299 | */ | |
300 | struct rxrpc_peer *rxrpc_lookup_incoming_peer(struct rxrpc_local *local, | |
301 | struct rxrpc_peer *prealloc) | |
302 | { | |
303 | struct rxrpc_peer *peer; | |
304 | unsigned long hash_key; | |
305 | ||
306 | hash_key = rxrpc_peer_hash_key(local, &prealloc->srx); | |
307 | prealloc->local = local; | |
308 | rxrpc_init_peer(prealloc, hash_key); | |
309 | ||
310 | spin_lock(&rxrpc_peer_hash_lock); | |
311 | ||
312 | /* Need to check that we aren't racing with someone else */ | |
313 | peer = __rxrpc_lookup_peer_rcu(local, &prealloc->srx, hash_key); | |
314 | if (peer && !rxrpc_get_peer_maybe(peer)) | |
315 | peer = NULL; | |
316 | if (!peer) { | |
317 | peer = prealloc; | |
318 | hash_add_rcu(rxrpc_peer_hash, &peer->hash_link, hash_key); | |
17926a79 DH |
319 | } |
320 | ||
248f219c | 321 | spin_unlock(&rxrpc_peer_hash_lock); |
17926a79 DH |
322 | return peer; |
323 | } | |
324 | ||
325 | /* | |
326 | * obtain a remote transport endpoint for the specified address | |
327 | */ | |
be6e6707 DH |
328 | struct rxrpc_peer *rxrpc_lookup_peer(struct rxrpc_local *local, |
329 | struct sockaddr_rxrpc *srx, gfp_t gfp) | |
17926a79 DH |
330 | { |
331 | struct rxrpc_peer *peer, *candidate; | |
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 | */ | |
347 | candidate = rxrpc_create_peer(local, srx, hash_key, gfp); | |
348 | if (!candidate) { | |
349 | _leave(" = NULL [nomem]"); | |
350 | return NULL; | |
351 | } | |
17926a79 | 352 | |
248f219c | 353 | spin_lock_bh(&rxrpc_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; | |
359 | if (!peer) | |
360 | hash_add_rcu(rxrpc_peer_hash, | |
361 | &candidate->hash_link, hash_key); | |
17926a79 | 362 | |
248f219c | 363 | spin_unlock_bh(&rxrpc_peer_hash_lock); |
17926a79 | 364 | |
be6e6707 DH |
365 | if (peer) |
366 | kfree(candidate); | |
367 | else | |
368 | peer = candidate; | |
369 | } | |
17926a79 | 370 | |
75b54cb5 | 371 | _net("PEER %d {%pISp}", peer->debug_id, &peer->srx.transport); |
17926a79 | 372 | |
be6e6707 | 373 | _leave(" = %p {u=%d}", peer, atomic_read(&peer->usage)); |
17926a79 | 374 | return peer; |
17926a79 DH |
375 | } |
376 | ||
377 | /* | |
be6e6707 | 378 | * Discard a ref on a remote peer record. |
17926a79 | 379 | */ |
be6e6707 | 380 | void __rxrpc_put_peer(struct rxrpc_peer *peer) |
17926a79 | 381 | { |
f66d7490 | 382 | ASSERT(hlist_empty(&peer->error_targets)); |
17926a79 | 383 | |
248f219c | 384 | spin_lock_bh(&rxrpc_peer_hash_lock); |
be6e6707 | 385 | hash_del_rcu(&peer->hash_link); |
248f219c | 386 | spin_unlock_bh(&rxrpc_peer_hash_lock); |
17926a79 | 387 | |
be6e6707 | 388 | kfree_rcu(peer, rcu); |
17926a79 | 389 | } |
8324f0bc DH |
390 | |
391 | /** | |
392 | * rxrpc_kernel_get_peer - Get the peer address of a call | |
393 | * @sock: The socket on which the call is in progress. | |
394 | * @call: The call to query | |
395 | * @_srx: Where to place the result | |
396 | * | |
397 | * Get the address of the remote peer in a call. | |
398 | */ | |
399 | void rxrpc_kernel_get_peer(struct socket *sock, struct rxrpc_call *call, | |
400 | struct sockaddr_rxrpc *_srx) | |
401 | { | |
402 | *_srx = call->peer->srx; | |
403 | } | |
404 | EXPORT_SYMBOL(rxrpc_kernel_get_peer); |