rxrpc: Make the set of connection IDs per local endpoint
[platform/kernel/linux-rpi.git] / net / rxrpc / local_object.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Local endpoint object management
3  *
4  * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
5  * Written by David Howells (dhowells@redhat.com)
6  */
7
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10 #include <linux/module.h>
11 #include <linux/net.h>
12 #include <linux/skbuff.h>
13 #include <linux/slab.h>
14 #include <linux/udp.h>
15 #include <linux/ip.h>
16 #include <linux/hashtable.h>
17 #include <net/sock.h>
18 #include <net/udp.h>
19 #include <net/udp_tunnel.h>
20 #include <net/af_rxrpc.h>
21 #include "ar-internal.h"
22
23 static void rxrpc_local_rcu(struct rcu_head *);
24
25 /*
26  * Handle an ICMP/ICMP6 error turning up at the tunnel.  Push it through the
27  * usual mechanism so that it gets parsed and presented through the UDP
28  * socket's error_report().
29  */
30 static void rxrpc_encap_err_rcv(struct sock *sk, struct sk_buff *skb, int err,
31                                 __be16 port, u32 info, u8 *payload)
32 {
33         if (ip_hdr(skb)->version == IPVERSION)
34                 return ip_icmp_error(sk, skb, err, port, info, payload);
35         if (IS_ENABLED(CONFIG_AF_RXRPC_IPV6))
36                 return ipv6_icmp_error(sk, skb, err, port, info, payload);
37 }
38
39 /*
40  * Compare a local to an address.  Return -ve, 0 or +ve to indicate less than,
41  * same or greater than.
42  *
43  * We explicitly don't compare the RxRPC service ID as we want to reject
44  * conflicting uses by differing services.  Further, we don't want to share
45  * addresses with different options (IPv6), so we don't compare those bits
46  * either.
47  */
48 static long rxrpc_local_cmp_key(const struct rxrpc_local *local,
49                                 const struct sockaddr_rxrpc *srx)
50 {
51         long diff;
52
53         diff = ((local->srx.transport_type - srx->transport_type) ?:
54                 (local->srx.transport_len - srx->transport_len) ?:
55                 (local->srx.transport.family - srx->transport.family));
56         if (diff != 0)
57                 return diff;
58
59         switch (srx->transport.family) {
60         case AF_INET:
61                 /* If the choice of UDP port is left up to the transport, then
62                  * the endpoint record doesn't match.
63                  */
64                 return ((u16 __force)local->srx.transport.sin.sin_port -
65                         (u16 __force)srx->transport.sin.sin_port) ?:
66                         memcmp(&local->srx.transport.sin.sin_addr,
67                                &srx->transport.sin.sin_addr,
68                                sizeof(struct in_addr));
69 #ifdef CONFIG_AF_RXRPC_IPV6
70         case AF_INET6:
71                 /* If the choice of UDP6 port is left up to the transport, then
72                  * the endpoint record doesn't match.
73                  */
74                 return ((u16 __force)local->srx.transport.sin6.sin6_port -
75                         (u16 __force)srx->transport.sin6.sin6_port) ?:
76                         memcmp(&local->srx.transport.sin6.sin6_addr,
77                                &srx->transport.sin6.sin6_addr,
78                                sizeof(struct in6_addr));
79 #endif
80         default:
81                 BUG();
82         }
83 }
84
85 /*
86  * Allocate a new local endpoint.
87  */
88 static struct rxrpc_local *rxrpc_alloc_local(struct net *net,
89                                              const struct sockaddr_rxrpc *srx)
90 {
91         struct rxrpc_local *local;
92         u32 tmp;
93
94         local = kzalloc(sizeof(struct rxrpc_local), GFP_KERNEL);
95         if (local) {
96                 refcount_set(&local->ref, 1);
97                 atomic_set(&local->active_users, 1);
98                 local->net = net;
99                 local->rxnet = rxrpc_net(net);
100                 INIT_HLIST_NODE(&local->link);
101                 init_rwsem(&local->defrag_sem);
102                 init_completion(&local->io_thread_ready);
103                 skb_queue_head_init(&local->rx_queue);
104                 INIT_LIST_HEAD(&local->conn_attend_q);
105                 INIT_LIST_HEAD(&local->call_attend_q);
106                 local->client_bundles = RB_ROOT;
107                 spin_lock_init(&local->client_bundles_lock);
108                 spin_lock_init(&local->lock);
109                 rwlock_init(&local->services_lock);
110                 local->debug_id = atomic_inc_return(&rxrpc_debug_id);
111                 memcpy(&local->srx, srx, sizeof(*srx));
112                 local->srx.srx_service = 0;
113                 idr_init(&local->conn_ids);
114                 get_random_bytes(&tmp, sizeof(tmp));
115                 tmp &= 0x3fffffff;
116                 if (tmp == 0)
117                         tmp = 1;
118                 idr_set_cursor(&local->conn_ids, tmp);
119                 spin_lock_init(&local->conn_lock);
120
121                 trace_rxrpc_local(local->debug_id, rxrpc_local_new, 1, 1);
122         }
123
124         _leave(" = %p", local);
125         return local;
126 }
127
128 /*
129  * create the local socket
130  * - must be called with rxrpc_local_mutex locked
131  */
132 static int rxrpc_open_socket(struct rxrpc_local *local, struct net *net)
133 {
134         struct udp_tunnel_sock_cfg tuncfg = {NULL};
135         struct sockaddr_rxrpc *srx = &local->srx;
136         struct udp_port_cfg udp_conf = {0};
137         struct task_struct *io_thread;
138         struct sock *usk;
139         int ret;
140
141         _enter("%p{%d,%d}",
142                local, srx->transport_type, srx->transport.family);
143
144         udp_conf.family = srx->transport.family;
145         udp_conf.use_udp_checksums = true;
146         if (udp_conf.family == AF_INET) {
147                 udp_conf.local_ip = srx->transport.sin.sin_addr;
148                 udp_conf.local_udp_port = srx->transport.sin.sin_port;
149 #if IS_ENABLED(CONFIG_AF_RXRPC_IPV6)
150         } else {
151                 udp_conf.local_ip6 = srx->transport.sin6.sin6_addr;
152                 udp_conf.local_udp_port = srx->transport.sin6.sin6_port;
153                 udp_conf.use_udp6_tx_checksums = true;
154                 udp_conf.use_udp6_rx_checksums = true;
155 #endif
156         }
157         ret = udp_sock_create(net, &udp_conf, &local->socket);
158         if (ret < 0) {
159                 _leave(" = %d [socket]", ret);
160                 return ret;
161         }
162
163         tuncfg.encap_type = UDP_ENCAP_RXRPC;
164         tuncfg.encap_rcv = rxrpc_encap_rcv;
165         tuncfg.encap_err_rcv = rxrpc_encap_err_rcv;
166         tuncfg.sk_user_data = local;
167         setup_udp_tunnel_sock(net, local->socket, &tuncfg);
168
169         /* set the socket up */
170         usk = local->socket->sk;
171         usk->sk_error_report = rxrpc_error_report;
172
173         switch (srx->transport.family) {
174         case AF_INET6:
175                 /* we want to receive ICMPv6 errors */
176                 ip6_sock_set_recverr(usk);
177
178                 /* Fall through and set IPv4 options too otherwise we don't get
179                  * errors from IPv4 packets sent through the IPv6 socket.
180                  */
181                 fallthrough;
182         case AF_INET:
183                 /* we want to receive ICMP errors */
184                 ip_sock_set_recverr(usk);
185
186                 /* we want to set the don't fragment bit */
187                 ip_sock_set_mtu_discover(usk, IP_PMTUDISC_DO);
188
189                 /* We want receive timestamps. */
190                 sock_enable_timestamps(usk);
191                 break;
192
193         default:
194                 BUG();
195         }
196
197         io_thread = kthread_run(rxrpc_io_thread, local,
198                                 "krxrpcio/%u", ntohs(udp_conf.local_udp_port));
199         if (IS_ERR(io_thread)) {
200                 ret = PTR_ERR(io_thread);
201                 goto error_sock;
202         }
203
204         wait_for_completion(&local->io_thread_ready);
205         local->io_thread = io_thread;
206         _leave(" = 0");
207         return 0;
208
209 error_sock:
210         kernel_sock_shutdown(local->socket, SHUT_RDWR);
211         local->socket->sk->sk_user_data = NULL;
212         sock_release(local->socket);
213         local->socket = NULL;
214         return ret;
215 }
216
217 /*
218  * Look up or create a new local endpoint using the specified local address.
219  */
220 struct rxrpc_local *rxrpc_lookup_local(struct net *net,
221                                        const struct sockaddr_rxrpc *srx)
222 {
223         struct rxrpc_local *local;
224         struct rxrpc_net *rxnet = rxrpc_net(net);
225         struct hlist_node *cursor;
226         long diff;
227         int ret;
228
229         _enter("{%d,%d,%pISp}",
230                srx->transport_type, srx->transport.family, &srx->transport);
231
232         mutex_lock(&rxnet->local_mutex);
233
234         hlist_for_each(cursor, &rxnet->local_endpoints) {
235                 local = hlist_entry(cursor, struct rxrpc_local, link);
236
237                 diff = rxrpc_local_cmp_key(local, srx);
238                 if (diff != 0)
239                         continue;
240
241                 /* Services aren't allowed to share transport sockets, so
242                  * reject that here.  It is possible that the object is dying -
243                  * but it may also still have the local transport address that
244                  * we want bound.
245                  */
246                 if (srx->srx_service) {
247                         local = NULL;
248                         goto addr_in_use;
249                 }
250
251                 /* Found a match.  We want to replace a dying object.
252                  * Attempting to bind the transport socket may still fail if
253                  * we're attempting to use a local address that the dying
254                  * object is still using.
255                  */
256                 if (!rxrpc_use_local(local, rxrpc_local_use_lookup))
257                         break;
258
259                 goto found;
260         }
261
262         local = rxrpc_alloc_local(net, srx);
263         if (!local)
264                 goto nomem;
265
266         ret = rxrpc_open_socket(local, net);
267         if (ret < 0)
268                 goto sock_error;
269
270         if (cursor) {
271                 hlist_replace_rcu(cursor, &local->link);
272                 cursor->pprev = NULL;
273         } else {
274                 hlist_add_head_rcu(&local->link, &rxnet->local_endpoints);
275         }
276
277 found:
278         mutex_unlock(&rxnet->local_mutex);
279         _leave(" = %p", local);
280         return local;
281
282 nomem:
283         ret = -ENOMEM;
284 sock_error:
285         mutex_unlock(&rxnet->local_mutex);
286         if (local)
287                 call_rcu(&local->rcu, rxrpc_local_rcu);
288         _leave(" = %d", ret);
289         return ERR_PTR(ret);
290
291 addr_in_use:
292         mutex_unlock(&rxnet->local_mutex);
293         _leave(" = -EADDRINUSE");
294         return ERR_PTR(-EADDRINUSE);
295 }
296
297 /*
298  * Get a ref on a local endpoint.
299  */
300 struct rxrpc_local *rxrpc_get_local(struct rxrpc_local *local,
301                                     enum rxrpc_local_trace why)
302 {
303         int r, u;
304
305         u = atomic_read(&local->active_users);
306         __refcount_inc(&local->ref, &r);
307         trace_rxrpc_local(local->debug_id, why, r + 1, u);
308         return local;
309 }
310
311 /*
312  * Get a ref on a local endpoint unless its usage has already reached 0.
313  */
314 struct rxrpc_local *rxrpc_get_local_maybe(struct rxrpc_local *local,
315                                           enum rxrpc_local_trace why)
316 {
317         int r, u;
318
319         if (local && __refcount_inc_not_zero(&local->ref, &r)) {
320                 u = atomic_read(&local->active_users);
321                 trace_rxrpc_local(local->debug_id, why, r + 1, u);
322                 return local;
323         }
324
325         return NULL;
326 }
327
328 /*
329  * Drop a ref on a local endpoint.
330  */
331 void rxrpc_put_local(struct rxrpc_local *local, enum rxrpc_local_trace why)
332 {
333         unsigned int debug_id;
334         bool dead;
335         int r, u;
336
337         if (local) {
338                 debug_id = local->debug_id;
339
340                 u = atomic_read(&local->active_users);
341                 dead = __refcount_dec_and_test(&local->ref, &r);
342                 trace_rxrpc_local(debug_id, why, r, u);
343
344                 if (dead)
345                         call_rcu(&local->rcu, rxrpc_local_rcu);
346         }
347 }
348
349 /*
350  * Start using a local endpoint.
351  */
352 struct rxrpc_local *rxrpc_use_local(struct rxrpc_local *local,
353                                     enum rxrpc_local_trace why)
354 {
355         local = rxrpc_get_local_maybe(local, rxrpc_local_get_for_use);
356         if (!local)
357                 return NULL;
358
359         if (!__rxrpc_use_local(local, why)) {
360                 rxrpc_put_local(local, rxrpc_local_put_for_use);
361                 return NULL;
362         }
363
364         return local;
365 }
366
367 /*
368  * Cease using a local endpoint.  Once the number of active users reaches 0, we
369  * start the closure of the transport in the I/O thread..
370  */
371 void rxrpc_unuse_local(struct rxrpc_local *local, enum rxrpc_local_trace why)
372 {
373         unsigned int debug_id;
374         int r, u;
375
376         if (local) {
377                 debug_id = local->debug_id;
378                 r = refcount_read(&local->ref);
379                 u = atomic_dec_return(&local->active_users);
380                 trace_rxrpc_local(debug_id, why, r, u);
381                 if (u == 0)
382                         kthread_stop(local->io_thread);
383         }
384 }
385
386 /*
387  * Destroy a local endpoint's socket and then hand the record to RCU to dispose
388  * of.
389  *
390  * Closing the socket cannot be done from bottom half context or RCU callback
391  * context because it might sleep.
392  */
393 void rxrpc_destroy_local(struct rxrpc_local *local)
394 {
395         struct socket *socket = local->socket;
396         struct rxrpc_net *rxnet = local->rxnet;
397
398         _enter("%d", local->debug_id);
399
400         local->dead = true;
401
402         mutex_lock(&rxnet->local_mutex);
403         hlist_del_init_rcu(&local->link);
404         mutex_unlock(&rxnet->local_mutex);
405
406         rxrpc_clean_up_local_conns(local);
407         rxrpc_service_connection_reaper(&rxnet->service_conn_reaper);
408         ASSERT(!local->service);
409
410         if (socket) {
411                 local->socket = NULL;
412                 kernel_sock_shutdown(socket, SHUT_RDWR);
413                 socket->sk->sk_user_data = NULL;
414                 sock_release(socket);
415         }
416
417         /* At this point, there should be no more packets coming in to the
418          * local endpoint.
419          */
420         rxrpc_purge_queue(&local->rx_queue);
421         rxrpc_destroy_client_conn_ids(local);
422 }
423
424 /*
425  * Destroy a local endpoint after the RCU grace period expires.
426  */
427 static void rxrpc_local_rcu(struct rcu_head *rcu)
428 {
429         struct rxrpc_local *local = container_of(rcu, struct rxrpc_local, rcu);
430
431         rxrpc_see_local(local, rxrpc_local_free);
432         kfree(local);
433 }
434
435 /*
436  * Verify the local endpoint list is empty by this point.
437  */
438 void rxrpc_destroy_all_locals(struct rxrpc_net *rxnet)
439 {
440         struct rxrpc_local *local;
441
442         _enter("");
443
444         flush_workqueue(rxrpc_workqueue);
445
446         if (!hlist_empty(&rxnet->local_endpoints)) {
447                 mutex_lock(&rxnet->local_mutex);
448                 hlist_for_each_entry(local, &rxnet->local_endpoints, link) {
449                         pr_err("AF_RXRPC: Leaked local %p {%d}\n",
450                                local, refcount_read(&local->ref));
451                 }
452                 mutex_unlock(&rxnet->local_mutex);
453                 BUG();
454         }
455 }