]>
Commit | Line | Data |
---|---|---|
87563616 | 1 | /* Local endpoint object management |
17926a79 | 2 | * |
4f95dd78 | 3 | * Copyright (C) 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 | |
87563616 | 7 | * modify it under the terms of the GNU General Public Licence |
17926a79 | 8 | * as published by the Free Software Foundation; either version |
87563616 | 9 | * 2 of the Licence, or (at your option) any later version. |
17926a79 DH |
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> | |
5a0e3ad6 | 17 | #include <linux/slab.h> |
44ba0698 DH |
18 | #include <linux/udp.h> |
19 | #include <linux/ip.h> | |
4f95dd78 | 20 | #include <linux/hashtable.h> |
17926a79 DH |
21 | #include <net/sock.h> |
22 | #include <net/af_rxrpc.h> | |
23 | #include "ar-internal.h" | |
24 | ||
4f95dd78 DH |
25 | static void rxrpc_local_processor(struct work_struct *); |
26 | static void rxrpc_local_rcu(struct rcu_head *); | |
17926a79 | 27 | |
4f95dd78 DH |
28 | static DEFINE_MUTEX(rxrpc_local_mutex); |
29 | static LIST_HEAD(rxrpc_local_endpoints); | |
17926a79 DH |
30 | |
31 | /* | |
4f95dd78 DH |
32 | * Compare a local to an address. Return -ve, 0 or +ve to indicate less than, |
33 | * same or greater than. | |
34 | * | |
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 | |
38 | * either. | |
17926a79 | 39 | */ |
4f95dd78 DH |
40 | static long rxrpc_local_cmp_key(const struct rxrpc_local *local, |
41 | const struct sockaddr_rxrpc *srx) | |
42 | { | |
43 | long diff; | |
44 | ||
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)); | |
48 | if (diff != 0) | |
49 | return diff; | |
50 | ||
51 | switch (srx->transport.family) { | |
52 | case AF_INET: | |
53 | /* If the choice of UDP port is left up to the transport, then | |
54 | * the endpoint record doesn't match. | |
55 | */ | |
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)); | |
61 | default: | |
62 | BUG(); | |
63 | } | |
64 | } | |
65 | ||
66 | /* | |
67 | * Allocate a new local endpoint. | |
68 | */ | |
69 | static struct rxrpc_local *rxrpc_alloc_local(const struct sockaddr_rxrpc *srx) | |
17926a79 DH |
70 | { |
71 | struct rxrpc_local *local; | |
72 | ||
73 | local = kzalloc(sizeof(struct rxrpc_local), GFP_KERNEL); | |
74 | if (local) { | |
4f95dd78 | 75 | atomic_set(&local->usage, 1); |
17926a79 | 76 | INIT_LIST_HEAD(&local->link); |
4f95dd78 DH |
77 | INIT_WORK(&local->processor, rxrpc_local_processor); |
78 | INIT_LIST_HEAD(&local->services); | |
17926a79 DH |
79 | init_rwsem(&local->defrag_sem); |
80 | skb_queue_head_init(&local->accept_queue); | |
81 | skb_queue_head_init(&local->reject_queue); | |
44ba0698 | 82 | skb_queue_head_init(&local->event_queue); |
999b69f8 DH |
83 | local->client_conns = RB_ROOT; |
84 | spin_lock_init(&local->client_conns_lock); | |
17926a79 DH |
85 | spin_lock_init(&local->lock); |
86 | rwlock_init(&local->services_lock); | |
17926a79 DH |
87 | local->debug_id = atomic_inc_return(&rxrpc_debug_id); |
88 | memcpy(&local->srx, srx, sizeof(*srx)); | |
89 | } | |
90 | ||
91 | _leave(" = %p", local); | |
92 | return local; | |
93 | } | |
94 | ||
95 | /* | |
96 | * create the local socket | |
4f95dd78 | 97 | * - must be called with rxrpc_local_mutex locked |
17926a79 | 98 | */ |
4f95dd78 | 99 | static int rxrpc_open_socket(struct rxrpc_local *local) |
17926a79 DH |
100 | { |
101 | struct sock *sock; | |
102 | int ret, opt; | |
103 | ||
104 | _enter("%p{%d}", local, local->srx.transport_type); | |
105 | ||
106 | /* create a socket to represent the local endpoint */ | |
eeb1bd5c EB |
107 | ret = sock_create_kern(&init_net, PF_INET, local->srx.transport_type, |
108 | IPPROTO_UDP, &local->socket); | |
17926a79 DH |
109 | if (ret < 0) { |
110 | _leave(" = %d [socket]", ret); | |
111 | return ret; | |
112 | } | |
113 | ||
114 | /* if a local address was supplied then bind it */ | |
115 | if (local->srx.transport_len > sizeof(sa_family_t)) { | |
116 | _debug("bind"); | |
117 | ret = kernel_bind(local->socket, | |
4f95dd78 | 118 | (struct sockaddr *)&local->srx.transport, |
17926a79 DH |
119 | local->srx.transport_len); |
120 | if (ret < 0) { | |
4f95dd78 | 121 | _debug("bind failed %d", ret); |
17926a79 DH |
122 | goto error; |
123 | } | |
124 | } | |
125 | ||
126 | /* we want to receive ICMP errors */ | |
127 | opt = 1; | |
128 | ret = kernel_setsockopt(local->socket, SOL_IP, IP_RECVERR, | |
129 | (char *) &opt, sizeof(opt)); | |
130 | if (ret < 0) { | |
131 | _debug("setsockopt failed"); | |
132 | goto error; | |
133 | } | |
134 | ||
135 | /* we want to set the don't fragment bit */ | |
136 | opt = IP_PMTUDISC_DO; | |
137 | ret = kernel_setsockopt(local->socket, SOL_IP, IP_MTU_DISCOVER, | |
138 | (char *) &opt, sizeof(opt)); | |
139 | if (ret < 0) { | |
140 | _debug("setsockopt failed"); | |
141 | goto error; | |
142 | } | |
143 | ||
17926a79 DH |
144 | /* set the socket up */ |
145 | sock = local->socket->sk; | |
146 | sock->sk_user_data = local; | |
147 | sock->sk_data_ready = rxrpc_data_ready; | |
abe89ef0 | 148 | sock->sk_error_report = rxrpc_error_report; |
17926a79 DH |
149 | _leave(" = 0"); |
150 | return 0; | |
151 | ||
152 | error: | |
91cf45f0 | 153 | kernel_sock_shutdown(local->socket, SHUT_RDWR); |
17926a79 DH |
154 | local->socket->sk->sk_user_data = NULL; |
155 | sock_release(local->socket); | |
156 | local->socket = NULL; | |
157 | ||
158 | _leave(" = %d", ret); | |
159 | return ret; | |
160 | } | |
161 | ||
162 | /* | |
4f95dd78 | 163 | * Look up or create a new local endpoint using the specified local address. |
17926a79 | 164 | */ |
4f95dd78 | 165 | struct rxrpc_local *rxrpc_lookup_local(const struct sockaddr_rxrpc *srx) |
17926a79 DH |
166 | { |
167 | struct rxrpc_local *local; | |
4f95dd78 DH |
168 | struct list_head *cursor; |
169 | const char *age; | |
170 | long diff; | |
17926a79 DH |
171 | int ret; |
172 | ||
4f95dd78 DH |
173 | if (srx->transport.family == AF_INET) { |
174 | _enter("{%d,%u,%pI4+%hu}", | |
175 | srx->transport_type, | |
176 | srx->transport.family, | |
177 | &srx->transport.sin.sin_addr, | |
178 | ntohs(srx->transport.sin.sin_port)); | |
179 | } else { | |
180 | _enter("{%d,%u}", | |
181 | srx->transport_type, | |
182 | srx->transport.family); | |
183 | return ERR_PTR(-EAFNOSUPPORT); | |
184 | } | |
17926a79 | 185 | |
4f95dd78 | 186 | mutex_lock(&rxrpc_local_mutex); |
17926a79 | 187 | |
4f95dd78 DH |
188 | for (cursor = rxrpc_local_endpoints.next; |
189 | cursor != &rxrpc_local_endpoints; | |
190 | cursor = cursor->next) { | |
191 | local = list_entry(cursor, struct rxrpc_local, link); | |
17926a79 | 192 | |
4f95dd78 DH |
193 | diff = rxrpc_local_cmp_key(local, srx); |
194 | if (diff < 0) | |
17926a79 | 195 | continue; |
4f95dd78 DH |
196 | if (diff > 0) |
197 | break; | |
198 | ||
199 | /* Services aren't allowed to share transport sockets, so | |
200 | * reject that here. It is possible that the object is dying - | |
201 | * but it may also still have the local transport address that | |
202 | * we want bound. | |
203 | */ | |
204 | if (srx->srx_service) { | |
205 | local = NULL; | |
206 | goto addr_in_use; | |
207 | } | |
17926a79 | 208 | |
4f95dd78 DH |
209 | /* Found a match. We replace a dying object. Attempting to |
210 | * bind the transport socket may still fail if we're attempting | |
211 | * to use a local address that the dying object is still using. | |
212 | */ | |
5627cc8b | 213 | if (!rxrpc_get_local_maybe(local)) { |
4f95dd78 DH |
214 | cursor = cursor->next; |
215 | list_del_init(&local->link); | |
216 | break; | |
17926a79 | 217 | } |
17926a79 | 218 | |
4f95dd78 DH |
219 | age = "old"; |
220 | goto found; | |
221 | } | |
17926a79 | 222 | |
17926a79 | 223 | local = rxrpc_alloc_local(srx); |
4f95dd78 DH |
224 | if (!local) |
225 | goto nomem; | |
17926a79 | 226 | |
4f95dd78 DH |
227 | ret = rxrpc_open_socket(local); |
228 | if (ret < 0) | |
229 | goto sock_error; | |
230 | ||
231 | list_add_tail(&local->link, cursor); | |
232 | age = "new"; | |
17926a79 | 233 | |
4f95dd78 DH |
234 | found: |
235 | mutex_unlock(&rxrpc_local_mutex); | |
17926a79 | 236 | |
4f95dd78 DH |
237 | _net("LOCAL %s %d {%d,%u,%pI4+%hu}", |
238 | age, | |
17926a79 DH |
239 | local->debug_id, |
240 | local->srx.transport_type, | |
241 | local->srx.transport.family, | |
21454aaa | 242 | &local->srx.transport.sin.sin_addr, |
17926a79 DH |
243 | ntohs(local->srx.transport.sin.sin_port)); |
244 | ||
4f95dd78 | 245 | _leave(" = %p", local); |
17926a79 DH |
246 | return local; |
247 | ||
4f95dd78 DH |
248 | nomem: |
249 | ret = -ENOMEM; | |
250 | sock_error: | |
251 | mutex_unlock(&rxrpc_local_mutex); | |
252 | kfree(local); | |
253 | _leave(" = %d", ret); | |
254 | return ERR_PTR(ret); | |
17926a79 | 255 | |
4f95dd78 DH |
256 | addr_in_use: |
257 | mutex_unlock(&rxrpc_local_mutex); | |
258 | _leave(" = -EADDRINUSE"); | |
259 | return ERR_PTR(-EADDRINUSE); | |
260 | } | |
17926a79 | 261 | |
4f95dd78 DH |
262 | /* |
263 | * A local endpoint reached its end of life. | |
264 | */ | |
265 | void __rxrpc_put_local(struct rxrpc_local *local) | |
266 | { | |
267 | _enter("%d", local->debug_id); | |
268 | rxrpc_queue_work(&local->processor); | |
17926a79 DH |
269 | } |
270 | ||
271 | /* | |
4f95dd78 DH |
272 | * Destroy a local endpoint's socket and then hand the record to RCU to dispose |
273 | * of. | |
274 | * | |
275 | * Closing the socket cannot be done from bottom half context or RCU callback | |
276 | * context because it might sleep. | |
17926a79 | 277 | */ |
4f95dd78 | 278 | static void rxrpc_local_destroyer(struct rxrpc_local *local) |
17926a79 | 279 | { |
4f95dd78 | 280 | struct socket *socket = local->socket; |
17926a79 | 281 | |
4f95dd78 | 282 | _enter("%d", local->debug_id); |
17926a79 | 283 | |
4f95dd78 DH |
284 | /* We can get a race between an incoming call packet queueing the |
285 | * processor again and the work processor starting the destruction | |
286 | * process which will shut down the UDP socket. | |
287 | */ | |
288 | if (local->dead) { | |
289 | _leave(" [already dead]"); | |
290 | return; | |
17926a79 | 291 | } |
4f95dd78 DH |
292 | local->dead = true; |
293 | ||
294 | mutex_lock(&rxrpc_local_mutex); | |
295 | list_del_init(&local->link); | |
296 | mutex_unlock(&rxrpc_local_mutex); | |
297 | ||
999b69f8 | 298 | ASSERT(RB_EMPTY_ROOT(&local->client_conns)); |
4f95dd78 DH |
299 | ASSERT(list_empty(&local->services)); |
300 | ||
301 | if (socket) { | |
302 | local->socket = NULL; | |
303 | kernel_sock_shutdown(socket, SHUT_RDWR); | |
304 | socket->sk->sk_user_data = NULL; | |
305 | sock_release(socket); | |
306 | } | |
307 | ||
308 | /* At this point, there should be no more packets coming in to the | |
309 | * local endpoint. | |
310 | */ | |
311 | rxrpc_purge_queue(&local->accept_queue); | |
312 | rxrpc_purge_queue(&local->reject_queue); | |
313 | rxrpc_purge_queue(&local->event_queue); | |
314 | ||
315 | _debug("rcu local %d", local->debug_id); | |
316 | call_rcu(&local->rcu, rxrpc_local_rcu); | |
17926a79 DH |
317 | } |
318 | ||
319 | /* | |
4f95dd78 | 320 | * Process events on an endpoint |
17926a79 | 321 | */ |
4f95dd78 | 322 | static void rxrpc_local_processor(struct work_struct *work) |
17926a79 DH |
323 | { |
324 | struct rxrpc_local *local = | |
4f95dd78 DH |
325 | container_of(work, struct rxrpc_local, processor); |
326 | bool again; | |
17926a79 | 327 | |
4f95dd78 | 328 | _enter("%d", local->debug_id); |
17926a79 | 329 | |
4f95dd78 DH |
330 | do { |
331 | again = false; | |
332 | if (atomic_read(&local->usage) == 0) | |
333 | return rxrpc_local_destroyer(local); | |
17926a79 | 334 | |
4f95dd78 DH |
335 | if (!skb_queue_empty(&local->accept_queue)) { |
336 | rxrpc_accept_incoming_calls(local); | |
337 | again = true; | |
338 | } | |
17926a79 | 339 | |
4f95dd78 DH |
340 | if (!skb_queue_empty(&local->reject_queue)) { |
341 | rxrpc_reject_packets(local); | |
342 | again = true; | |
343 | } | |
17926a79 | 344 | |
4f95dd78 DH |
345 | if (!skb_queue_empty(&local->event_queue)) { |
346 | rxrpc_process_local_events(local); | |
347 | again = true; | |
348 | } | |
349 | } while (again); | |
350 | } | |
17926a79 | 351 | |
4f95dd78 DH |
352 | /* |
353 | * Destroy a local endpoint after the RCU grace period expires. | |
354 | */ | |
355 | static void rxrpc_local_rcu(struct rcu_head *rcu) | |
356 | { | |
357 | struct rxrpc_local *local = container_of(rcu, struct rxrpc_local, rcu); | |
17926a79 | 358 | |
4f95dd78 | 359 | _enter("%d", local->debug_id); |
17926a79 | 360 | |
4f95dd78 | 361 | ASSERT(!work_pending(&local->processor)); |
17926a79 DH |
362 | |
363 | _net("DESTROY LOCAL %d", local->debug_id); | |
364 | kfree(local); | |
17926a79 DH |
365 | _leave(""); |
366 | } | |
367 | ||
368 | /* | |
4f95dd78 | 369 | * Verify the local endpoint list is empty by this point. |
17926a79 DH |
370 | */ |
371 | void __exit rxrpc_destroy_all_locals(void) | |
372 | { | |
4f95dd78 | 373 | struct rxrpc_local *local; |
17926a79 DH |
374 | |
375 | _enter(""); | |
376 | ||
4f95dd78 DH |
377 | if (list_empty(&rxrpc_local_endpoints)) |
378 | return; | |
17926a79 | 379 | |
4f95dd78 DH |
380 | mutex_lock(&rxrpc_local_mutex); |
381 | list_for_each_entry(local, &rxrpc_local_endpoints, link) { | |
382 | pr_err("AF_RXRPC: Leaked local %p {%d}\n", | |
383 | local, atomic_read(&local->usage)); | |
17926a79 | 384 | } |
4f95dd78 DH |
385 | mutex_unlock(&rxrpc_local_mutex); |
386 | BUG(); | |
17926a79 | 387 | } |