]>
git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blob - net/rxrpc/local_object.c
1 /* Local endpoint object management
3 * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public Licence
8 * as published by the Free Software Foundation; either version
9 * 2 of the Licence, or (at your option) any later version.
12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 #include <linux/module.h>
15 #include <linux/net.h>
16 #include <linux/skbuff.h>
17 #include <linux/slab.h>
18 #include <linux/udp.h>
20 #include <linux/hashtable.h>
23 #include <net/af_rxrpc.h>
24 #include "ar-internal.h"
26 static void rxrpc_local_processor(struct work_struct
*);
27 static void rxrpc_local_rcu(struct rcu_head
*);
30 * Compare a local to an address. Return -ve, 0 or +ve to indicate less than,
31 * same or greater than.
33 * We explicitly don't compare the RxRPC service ID as we want to reject
34 * conflicting uses by differing services. Further, we don't want to share
35 * addresses with different options (IPv6), so we don't compare those bits
38 static long rxrpc_local_cmp_key(const struct rxrpc_local
*local
,
39 const struct sockaddr_rxrpc
*srx
)
43 diff
= ((local
->srx
.transport_type
- srx
->transport_type
) ?:
44 (local
->srx
.transport_len
- srx
->transport_len
) ?:
45 (local
->srx
.transport
.family
- srx
->transport
.family
));
49 switch (srx
->transport
.family
) {
51 /* If the choice of UDP port is left up to the transport, then
52 * the endpoint record doesn't match.
54 return ((u16 __force
)local
->srx
.transport
.sin
.sin_port
-
55 (u16 __force
)srx
->transport
.sin
.sin_port
) ?:
56 memcmp(&local
->srx
.transport
.sin
.sin_addr
,
57 &srx
->transport
.sin
.sin_addr
,
58 sizeof(struct in_addr
));
59 #ifdef CONFIG_AF_RXRPC_IPV6
61 /* If the choice of UDP6 port is left up to the transport, then
62 * the endpoint record doesn't match.
64 return ((u16 __force
)local
->srx
.transport
.sin6
.sin6_port
-
65 (u16 __force
)srx
->transport
.sin6
.sin6_port
) ?:
66 memcmp(&local
->srx
.transport
.sin6
.sin6_addr
,
67 &srx
->transport
.sin6
.sin6_addr
,
68 sizeof(struct in6_addr
));
76 * Allocate a new local endpoint.
78 static struct rxrpc_local
*rxrpc_alloc_local(struct rxrpc_net
*rxnet
,
79 const struct sockaddr_rxrpc
*srx
)
81 struct rxrpc_local
*local
;
83 local
= kzalloc(sizeof(struct rxrpc_local
), GFP_KERNEL
);
85 atomic_set(&local
->usage
, 1);
87 INIT_LIST_HEAD(&local
->link
);
88 INIT_WORK(&local
->processor
, rxrpc_local_processor
);
89 init_rwsem(&local
->defrag_sem
);
90 skb_queue_head_init(&local
->reject_queue
);
91 skb_queue_head_init(&local
->event_queue
);
92 local
->client_conns
= RB_ROOT
;
93 spin_lock_init(&local
->client_conns_lock
);
94 spin_lock_init(&local
->lock
);
95 rwlock_init(&local
->services_lock
);
96 local
->debug_id
= atomic_inc_return(&rxrpc_debug_id
);
97 memcpy(&local
->srx
, srx
, sizeof(*srx
));
98 local
->srx
.srx_service
= 0;
99 trace_rxrpc_local(local
, rxrpc_local_new
, 1, NULL
);
102 _leave(" = %p", local
);
107 * create the local socket
108 * - must be called with rxrpc_local_mutex locked
110 static int rxrpc_open_socket(struct rxrpc_local
*local
, struct net
*net
)
116 local
, local
->srx
.transport_type
, local
->srx
.transport
.family
);
118 /* create a socket to represent the local endpoint */
119 ret
= sock_create_kern(net
, local
->srx
.transport
.family
,
120 local
->srx
.transport_type
, 0, &local
->socket
);
122 _leave(" = %d [socket]", ret
);
126 /* set the socket up */
127 usk
= local
->socket
->sk
;
128 inet_sk(usk
)->mc_loop
= 0;
130 /* Enable CHECKSUM_UNNECESSARY to CHECKSUM_COMPLETE conversion */
131 inet_inc_convert_csum(usk
);
133 rcu_assign_sk_user_data(usk
, local
);
135 udp_sk(usk
)->encap_type
= UDP_ENCAP_RXRPC
;
136 udp_sk(usk
)->encap_rcv
= rxrpc_input_packet
;
137 udp_sk(usk
)->encap_destroy
= NULL
;
138 udp_sk(usk
)->gro_receive
= NULL
;
139 udp_sk(usk
)->gro_complete
= NULL
;
142 #if IS_ENABLED(CONFIG_AF_RXRPC_IPV6)
143 if (local
->srx
.transport
.family
== AF_INET6
)
144 udpv6_encap_enable();
146 usk
->sk_error_report
= rxrpc_error_report
;
148 /* if a local address was supplied then bind it */
149 if (local
->srx
.transport_len
> sizeof(sa_family_t
)) {
151 ret
= kernel_bind(local
->socket
,
152 (struct sockaddr
*)&local
->srx
.transport
,
153 local
->srx
.transport_len
);
155 _debug("bind failed %d", ret
);
160 switch (local
->srx
.transport
.family
) {
162 /* we want to receive ICMPv6 errors */
164 ret
= kernel_setsockopt(local
->socket
, SOL_IPV6
, IPV6_RECVERR
,
165 (char *) &opt
, sizeof(opt
));
167 _debug("setsockopt failed");
171 /* we want to set the don't fragment bit */
172 opt
= IPV6_PMTUDISC_DO
;
173 ret
= kernel_setsockopt(local
->socket
, SOL_IPV6
, IPV6_MTU_DISCOVER
,
174 (char *) &opt
, sizeof(opt
));
176 _debug("setsockopt failed");
180 /* Fall through and set IPv4 options too otherwise we don't get
181 * errors from IPv4 packets sent through the IPv6 socket.
185 /* we want to receive ICMP errors */
187 ret
= kernel_setsockopt(local
->socket
, SOL_IP
, IP_RECVERR
,
188 (char *) &opt
, sizeof(opt
));
190 _debug("setsockopt failed");
194 /* we want to set the don't fragment bit */
195 opt
= IP_PMTUDISC_DO
;
196 ret
= kernel_setsockopt(local
->socket
, SOL_IP
, IP_MTU_DISCOVER
,
197 (char *) &opt
, sizeof(opt
));
199 _debug("setsockopt failed");
203 /* We want receive timestamps. */
205 ret
= kernel_setsockopt(local
->socket
, SOL_SOCKET
, SO_TIMESTAMPNS
,
206 (char *)&opt
, sizeof(opt
));
208 _debug("setsockopt failed");
221 kernel_sock_shutdown(local
->socket
, SHUT_RDWR
);
222 local
->socket
->sk
->sk_user_data
= NULL
;
223 sock_release(local
->socket
);
224 local
->socket
= NULL
;
226 _leave(" = %d", ret
);
231 * Look up or create a new local endpoint using the specified local address.
233 struct rxrpc_local
*rxrpc_lookup_local(struct net
*net
,
234 const struct sockaddr_rxrpc
*srx
)
236 struct rxrpc_local
*local
;
237 struct rxrpc_net
*rxnet
= rxrpc_net(net
);
238 struct list_head
*cursor
;
243 _enter("{%d,%d,%pISp}",
244 srx
->transport_type
, srx
->transport
.family
, &srx
->transport
);
246 mutex_lock(&rxnet
->local_mutex
);
248 for (cursor
= rxnet
->local_endpoints
.next
;
249 cursor
!= &rxnet
->local_endpoints
;
250 cursor
= cursor
->next
) {
251 local
= list_entry(cursor
, struct rxrpc_local
, link
);
253 diff
= rxrpc_local_cmp_key(local
, srx
);
259 /* Services aren't allowed to share transport sockets, so
260 * reject that here. It is possible that the object is dying -
261 * but it may also still have the local transport address that
264 if (srx
->srx_service
) {
269 /* Found a match. We replace a dying object. Attempting to
270 * bind the transport socket may still fail if we're attempting
271 * to use a local address that the dying object is still using.
273 if (!rxrpc_get_local_maybe(local
)) {
274 cursor
= cursor
->next
;
275 list_del_init(&local
->link
);
283 local
= rxrpc_alloc_local(rxnet
, srx
);
287 ret
= rxrpc_open_socket(local
, net
);
291 list_add_tail(&local
->link
, cursor
);
295 mutex_unlock(&rxnet
->local_mutex
);
297 _net("LOCAL %s %d {%pISp}",
298 age
, local
->debug_id
, &local
->srx
.transport
);
300 _leave(" = %p", local
);
306 mutex_unlock(&rxnet
->local_mutex
);
308 _leave(" = %d", ret
);
312 mutex_unlock(&rxnet
->local_mutex
);
313 _leave(" = -EADDRINUSE");
314 return ERR_PTR(-EADDRINUSE
);
318 * Get a ref on a local endpoint.
320 struct rxrpc_local
*rxrpc_get_local(struct rxrpc_local
*local
)
322 const void *here
= __builtin_return_address(0);
325 n
= atomic_inc_return(&local
->usage
);
326 trace_rxrpc_local(local
, rxrpc_local_got
, n
, here
);
331 * Get a ref on a local endpoint unless its usage has already reached 0.
333 struct rxrpc_local
*rxrpc_get_local_maybe(struct rxrpc_local
*local
)
335 const void *here
= __builtin_return_address(0);
338 int n
= atomic_fetch_add_unless(&local
->usage
, 1, 0);
340 trace_rxrpc_local(local
, rxrpc_local_got
, n
+ 1, here
);
348 * Queue a local endpoint.
350 void rxrpc_queue_local(struct rxrpc_local
*local
)
352 const void *here
= __builtin_return_address(0);
354 if (rxrpc_queue_work(&local
->processor
))
355 trace_rxrpc_local(local
, rxrpc_local_queued
,
356 atomic_read(&local
->usage
), here
);
360 * A local endpoint reached its end of life.
362 static void __rxrpc_put_local(struct rxrpc_local
*local
)
364 _enter("%d", local
->debug_id
);
365 rxrpc_queue_work(&local
->processor
);
369 * Drop a ref on a local endpoint.
371 void rxrpc_put_local(struct rxrpc_local
*local
)
373 const void *here
= __builtin_return_address(0);
377 n
= atomic_dec_return(&local
->usage
);
378 trace_rxrpc_local(local
, rxrpc_local_put
, n
, here
);
381 __rxrpc_put_local(local
);
386 * Destroy a local endpoint's socket and then hand the record to RCU to dispose
389 * Closing the socket cannot be done from bottom half context or RCU callback
390 * context because it might sleep.
392 static void rxrpc_local_destroyer(struct rxrpc_local
*local
)
394 struct socket
*socket
= local
->socket
;
395 struct rxrpc_net
*rxnet
= local
->rxnet
;
397 _enter("%d", local
->debug_id
);
399 /* We can get a race between an incoming call packet queueing the
400 * processor again and the work processor starting the destruction
401 * process which will shut down the UDP socket.
404 _leave(" [already dead]");
409 mutex_lock(&rxnet
->local_mutex
);
410 list_del_init(&local
->link
);
411 mutex_unlock(&rxnet
->local_mutex
);
413 ASSERT(RB_EMPTY_ROOT(&local
->client_conns
));
414 ASSERT(!local
->service
);
417 local
->socket
= NULL
;
418 kernel_sock_shutdown(socket
, SHUT_RDWR
);
419 socket
->sk
->sk_user_data
= NULL
;
420 sock_release(socket
);
423 /* At this point, there should be no more packets coming in to the
426 rxrpc_purge_queue(&local
->reject_queue
);
427 rxrpc_purge_queue(&local
->event_queue
);
429 _debug("rcu local %d", local
->debug_id
);
430 call_rcu(&local
->rcu
, rxrpc_local_rcu
);
434 * Process events on an endpoint
436 static void rxrpc_local_processor(struct work_struct
*work
)
438 struct rxrpc_local
*local
=
439 container_of(work
, struct rxrpc_local
, processor
);
442 trace_rxrpc_local(local
, rxrpc_local_processing
,
443 atomic_read(&local
->usage
), NULL
);
447 if (atomic_read(&local
->usage
) == 0)
448 return rxrpc_local_destroyer(local
);
450 if (!skb_queue_empty(&local
->reject_queue
)) {
451 rxrpc_reject_packets(local
);
455 if (!skb_queue_empty(&local
->event_queue
)) {
456 rxrpc_process_local_events(local
);
463 * Destroy a local endpoint after the RCU grace period expires.
465 static void rxrpc_local_rcu(struct rcu_head
*rcu
)
467 struct rxrpc_local
*local
= container_of(rcu
, struct rxrpc_local
, rcu
);
469 _enter("%d", local
->debug_id
);
471 ASSERT(!work_pending(&local
->processor
));
473 _net("DESTROY LOCAL %d", local
->debug_id
);
479 * Verify the local endpoint list is empty by this point.
481 void rxrpc_destroy_all_locals(struct rxrpc_net
*rxnet
)
483 struct rxrpc_local
*local
;
487 flush_workqueue(rxrpc_workqueue
);
489 if (!list_empty(&rxnet
->local_endpoints
)) {
490 mutex_lock(&rxnet
->local_mutex
);
491 list_for_each_entry(local
, &rxnet
->local_endpoints
, link
) {
492 pr_err("AF_RXRPC: Leaked local %p {%d}\n",
493 local
, atomic_read(&local
->usage
));
495 mutex_unlock(&rxnet
->local_mutex
);