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>
22 #include <net/af_rxrpc.h>
23 #include "ar-internal.h"
25 static void rxrpc_local_processor(struct work_struct
*);
26 static void rxrpc_local_rcu(struct rcu_head
*);
28 static DEFINE_MUTEX(rxrpc_local_mutex
);
29 static LIST_HEAD(rxrpc_local_endpoints
);
32 * Compare a local to an address. Return -ve, 0 or +ve to indicate less than,
33 * same or greater than.
35 * We explicitly don't compare the RxRPC service ID as we want to reject
36 * conflicting uses by differing services. Further, we don't want to share
37 * addresses with different options (IPv6), so we don't compare those bits
40 static long rxrpc_local_cmp_key(const struct rxrpc_local
*local
,
41 const struct sockaddr_rxrpc
*srx
)
45 diff
= ((local
->srx
.transport_type
- srx
->transport_type
) ?:
46 (local
->srx
.transport_len
- srx
->transport_len
) ?:
47 (local
->srx
.transport
.family
- srx
->transport
.family
));
51 switch (srx
->transport
.family
) {
53 /* If the choice of UDP port is left up to the transport, then
54 * the endpoint record doesn't match.
56 return ((u16 __force
)local
->srx
.transport
.sin
.sin_port
-
57 (u16 __force
)srx
->transport
.sin
.sin_port
) ?:
58 memcmp(&local
->srx
.transport
.sin
.sin_addr
,
59 &srx
->transport
.sin
.sin_addr
,
60 sizeof(struct in_addr
));
67 * Allocate a new local endpoint.
69 static struct rxrpc_local
*rxrpc_alloc_local(const struct sockaddr_rxrpc
*srx
)
71 struct rxrpc_local
*local
;
73 local
= kzalloc(sizeof(struct rxrpc_local
), GFP_KERNEL
);
75 atomic_set(&local
->usage
, 1);
76 INIT_LIST_HEAD(&local
->link
);
77 INIT_WORK(&local
->processor
, rxrpc_local_processor
);
78 INIT_HLIST_HEAD(&local
->services
);
79 init_rwsem(&local
->defrag_sem
);
80 skb_queue_head_init(&local
->reject_queue
);
81 skb_queue_head_init(&local
->event_queue
);
82 local
->client_conns
= RB_ROOT
;
83 spin_lock_init(&local
->client_conns_lock
);
84 spin_lock_init(&local
->lock
);
85 rwlock_init(&local
->services_lock
);
86 local
->debug_id
= atomic_inc_return(&rxrpc_debug_id
);
87 memcpy(&local
->srx
, srx
, sizeof(*srx
));
90 _leave(" = %p", local
);
95 * create the local socket
96 * - must be called with rxrpc_local_mutex locked
98 static int rxrpc_open_socket(struct rxrpc_local
*local
)
103 _enter("%p{%d}", local
, local
->srx
.transport_type
);
105 /* create a socket to represent the local endpoint */
106 ret
= sock_create_kern(&init_net
, PF_INET
, local
->srx
.transport_type
,
107 IPPROTO_UDP
, &local
->socket
);
109 _leave(" = %d [socket]", ret
);
113 /* if a local address was supplied then bind it */
114 if (local
->srx
.transport_len
> sizeof(sa_family_t
)) {
116 ret
= kernel_bind(local
->socket
,
117 (struct sockaddr
*)&local
->srx
.transport
,
118 local
->srx
.transport_len
);
120 _debug("bind failed %d", ret
);
125 /* we want to receive ICMP errors */
127 ret
= kernel_setsockopt(local
->socket
, SOL_IP
, IP_RECVERR
,
128 (char *) &opt
, sizeof(opt
));
130 _debug("setsockopt failed");
134 /* we want to set the don't fragment bit */
135 opt
= IP_PMTUDISC_DO
;
136 ret
= kernel_setsockopt(local
->socket
, SOL_IP
, IP_MTU_DISCOVER
,
137 (char *) &opt
, sizeof(opt
));
139 _debug("setsockopt failed");
143 /* set the socket up */
144 sock
= local
->socket
->sk
;
145 sock
->sk_user_data
= local
;
146 sock
->sk_data_ready
= rxrpc_data_ready
;
147 sock
->sk_error_report
= rxrpc_error_report
;
152 kernel_sock_shutdown(local
->socket
, SHUT_RDWR
);
153 local
->socket
->sk
->sk_user_data
= NULL
;
154 sock_release(local
->socket
);
155 local
->socket
= NULL
;
157 _leave(" = %d", ret
);
162 * Look up or create a new local endpoint using the specified local address.
164 struct rxrpc_local
*rxrpc_lookup_local(const struct sockaddr_rxrpc
*srx
)
166 struct rxrpc_local
*local
;
167 struct list_head
*cursor
;
172 if (srx
->transport
.family
== AF_INET
) {
173 _enter("{%d,%u,%pI4+%hu}",
175 srx
->transport
.family
,
176 &srx
->transport
.sin
.sin_addr
,
177 ntohs(srx
->transport
.sin
.sin_port
));
181 srx
->transport
.family
);
182 return ERR_PTR(-EAFNOSUPPORT
);
185 mutex_lock(&rxrpc_local_mutex
);
187 for (cursor
= rxrpc_local_endpoints
.next
;
188 cursor
!= &rxrpc_local_endpoints
;
189 cursor
= cursor
->next
) {
190 local
= list_entry(cursor
, struct rxrpc_local
, link
);
192 diff
= rxrpc_local_cmp_key(local
, srx
);
198 /* Services aren't allowed to share transport sockets, so
199 * reject that here. It is possible that the object is dying -
200 * but it may also still have the local transport address that
203 if (srx
->srx_service
) {
208 /* Found a match. We replace a dying object. Attempting to
209 * bind the transport socket may still fail if we're attempting
210 * to use a local address that the dying object is still using.
212 if (!rxrpc_get_local_maybe(local
)) {
213 cursor
= cursor
->next
;
214 list_del_init(&local
->link
);
222 local
= rxrpc_alloc_local(srx
);
226 ret
= rxrpc_open_socket(local
);
230 list_add_tail(&local
->link
, cursor
);
234 mutex_unlock(&rxrpc_local_mutex
);
236 _net("LOCAL %s %d {%d,%u,%pI4+%hu}",
239 local
->srx
.transport_type
,
240 local
->srx
.transport
.family
,
241 &local
->srx
.transport
.sin
.sin_addr
,
242 ntohs(local
->srx
.transport
.sin
.sin_port
));
244 _leave(" = %p", local
);
250 mutex_unlock(&rxrpc_local_mutex
);
252 _leave(" = %d", ret
);
256 mutex_unlock(&rxrpc_local_mutex
);
257 _leave(" = -EADDRINUSE");
258 return ERR_PTR(-EADDRINUSE
);
262 * A local endpoint reached its end of life.
264 void __rxrpc_put_local(struct rxrpc_local
*local
)
266 _enter("%d", local
->debug_id
);
267 rxrpc_queue_work(&local
->processor
);
271 * Destroy a local endpoint's socket and then hand the record to RCU to dispose
274 * Closing the socket cannot be done from bottom half context or RCU callback
275 * context because it might sleep.
277 static void rxrpc_local_destroyer(struct rxrpc_local
*local
)
279 struct socket
*socket
= local
->socket
;
281 _enter("%d", local
->debug_id
);
283 /* We can get a race between an incoming call packet queueing the
284 * processor again and the work processor starting the destruction
285 * process which will shut down the UDP socket.
288 _leave(" [already dead]");
293 mutex_lock(&rxrpc_local_mutex
);
294 list_del_init(&local
->link
);
295 mutex_unlock(&rxrpc_local_mutex
);
297 ASSERT(RB_EMPTY_ROOT(&local
->client_conns
));
298 ASSERT(hlist_empty(&local
->services
));
301 local
->socket
= NULL
;
302 kernel_sock_shutdown(socket
, SHUT_RDWR
);
303 socket
->sk
->sk_user_data
= NULL
;
304 sock_release(socket
);
307 /* At this point, there should be no more packets coming in to the
310 rxrpc_purge_queue(&local
->reject_queue
);
311 rxrpc_purge_queue(&local
->event_queue
);
313 _debug("rcu local %d", local
->debug_id
);
314 call_rcu(&local
->rcu
, rxrpc_local_rcu
);
318 * Process events on an endpoint
320 static void rxrpc_local_processor(struct work_struct
*work
)
322 struct rxrpc_local
*local
=
323 container_of(work
, struct rxrpc_local
, processor
);
326 _enter("%d", local
->debug_id
);
330 if (atomic_read(&local
->usage
) == 0)
331 return rxrpc_local_destroyer(local
);
333 if (!skb_queue_empty(&local
->reject_queue
)) {
334 rxrpc_reject_packets(local
);
338 if (!skb_queue_empty(&local
->event_queue
)) {
339 rxrpc_process_local_events(local
);
346 * Destroy a local endpoint after the RCU grace period expires.
348 static void rxrpc_local_rcu(struct rcu_head
*rcu
)
350 struct rxrpc_local
*local
= container_of(rcu
, struct rxrpc_local
, rcu
);
352 _enter("%d", local
->debug_id
);
354 ASSERT(!work_pending(&local
->processor
));
356 _net("DESTROY LOCAL %d", local
->debug_id
);
362 * Verify the local endpoint list is empty by this point.
364 void __exit
rxrpc_destroy_all_locals(void)
366 struct rxrpc_local
*local
;
370 flush_workqueue(rxrpc_workqueue
);
372 if (!list_empty(&rxrpc_local_endpoints
)) {
373 mutex_lock(&rxrpc_local_mutex
);
374 list_for_each_entry(local
, &rxrpc_local_endpoints
, link
) {
375 pr_err("AF_RXRPC: Leaked local %p {%d}\n",
376 local
, atomic_read(&local
->usage
));
378 mutex_unlock(&rxrpc_local_mutex
);