]>
Commit | Line | Data |
---|---|---|
b4d0d230 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
87563616 | 2 | /* Local endpoint object management |
17926a79 | 3 | * |
4f95dd78 | 4 | * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved. |
17926a79 | 5 | * Written by David Howells (dhowells@redhat.com) |
17926a79 DH |
6 | */ |
7 | ||
9b6d5398 JP |
8 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
9 | ||
17926a79 DH |
10 | #include <linux/module.h> |
11 | #include <linux/net.h> | |
12 | #include <linux/skbuff.h> | |
5a0e3ad6 | 13 | #include <linux/slab.h> |
44ba0698 DH |
14 | #include <linux/udp.h> |
15 | #include <linux/ip.h> | |
4f95dd78 | 16 | #include <linux/hashtable.h> |
17926a79 | 17 | #include <net/sock.h> |
5271953c | 18 | #include <net/udp.h> |
17926a79 DH |
19 | #include <net/af_rxrpc.h> |
20 | #include "ar-internal.h" | |
21 | ||
4f95dd78 DH |
22 | static void rxrpc_local_processor(struct work_struct *); |
23 | static void rxrpc_local_rcu(struct rcu_head *); | |
17926a79 | 24 | |
17926a79 | 25 | /* |
4f95dd78 DH |
26 | * Compare a local to an address. Return -ve, 0 or +ve to indicate less than, |
27 | * same or greater than. | |
28 | * | |
29 | * We explicitly don't compare the RxRPC service ID as we want to reject | |
30 | * conflicting uses by differing services. Further, we don't want to share | |
31 | * addresses with different options (IPv6), so we don't compare those bits | |
32 | * either. | |
17926a79 | 33 | */ |
4f95dd78 DH |
34 | static long rxrpc_local_cmp_key(const struct rxrpc_local *local, |
35 | const struct sockaddr_rxrpc *srx) | |
36 | { | |
37 | long diff; | |
38 | ||
39 | diff = ((local->srx.transport_type - srx->transport_type) ?: | |
40 | (local->srx.transport_len - srx->transport_len) ?: | |
41 | (local->srx.transport.family - srx->transport.family)); | |
42 | if (diff != 0) | |
43 | return diff; | |
44 | ||
45 | switch (srx->transport.family) { | |
46 | case AF_INET: | |
47 | /* If the choice of UDP port is left up to the transport, then | |
48 | * the endpoint record doesn't match. | |
49 | */ | |
50 | return ((u16 __force)local->srx.transport.sin.sin_port - | |
51 | (u16 __force)srx->transport.sin.sin_port) ?: | |
52 | memcmp(&local->srx.transport.sin.sin_addr, | |
53 | &srx->transport.sin.sin_addr, | |
54 | sizeof(struct in_addr)); | |
d1912747 | 55 | #ifdef CONFIG_AF_RXRPC_IPV6 |
75b54cb5 DH |
56 | case AF_INET6: |
57 | /* If the choice of UDP6 port is left up to the transport, then | |
58 | * the endpoint record doesn't match. | |
59 | */ | |
60 | return ((u16 __force)local->srx.transport.sin6.sin6_port - | |
61 | (u16 __force)srx->transport.sin6.sin6_port) ?: | |
62 | memcmp(&local->srx.transport.sin6.sin6_addr, | |
63 | &srx->transport.sin6.sin6_addr, | |
64 | sizeof(struct in6_addr)); | |
d1912747 | 65 | #endif |
4f95dd78 DH |
66 | default: |
67 | BUG(); | |
68 | } | |
69 | } | |
70 | ||
71 | /* | |
72 | * Allocate a new local endpoint. | |
73 | */ | |
2baec2c3 DH |
74 | static struct rxrpc_local *rxrpc_alloc_local(struct rxrpc_net *rxnet, |
75 | const struct sockaddr_rxrpc *srx) | |
17926a79 DH |
76 | { |
77 | struct rxrpc_local *local; | |
78 | ||
79 | local = kzalloc(sizeof(struct rxrpc_local), GFP_KERNEL); | |
80 | if (local) { | |
4f95dd78 | 81 | atomic_set(&local->usage, 1); |
730c5fd4 | 82 | atomic_set(&local->active_users, 1); |
2baec2c3 | 83 | local->rxnet = rxnet; |
17926a79 | 84 | INIT_LIST_HEAD(&local->link); |
4f95dd78 | 85 | INIT_WORK(&local->processor, rxrpc_local_processor); |
17926a79 | 86 | init_rwsem(&local->defrag_sem); |
17926a79 | 87 | skb_queue_head_init(&local->reject_queue); |
44ba0698 | 88 | skb_queue_head_init(&local->event_queue); |
999b69f8 DH |
89 | local->client_conns = RB_ROOT; |
90 | spin_lock_init(&local->client_conns_lock); | |
17926a79 DH |
91 | spin_lock_init(&local->lock); |
92 | rwlock_init(&local->services_lock); | |
17926a79 DH |
93 | local->debug_id = atomic_inc_return(&rxrpc_debug_id); |
94 | memcpy(&local->srx, srx, sizeof(*srx)); | |
28036f44 | 95 | local->srx.srx_service = 0; |
06d9532f | 96 | trace_rxrpc_local(local->debug_id, rxrpc_local_new, 1, NULL); |
17926a79 DH |
97 | } |
98 | ||
99 | _leave(" = %p", local); | |
100 | return local; | |
101 | } | |
102 | ||
103 | /* | |
104 | * create the local socket | |
4f95dd78 | 105 | * - must be called with rxrpc_local_mutex locked |
17926a79 | 106 | */ |
2baec2c3 | 107 | static int rxrpc_open_socket(struct rxrpc_local *local, struct net *net) |
17926a79 | 108 | { |
5271953c | 109 | struct sock *usk; |
17926a79 DH |
110 | int ret, opt; |
111 | ||
75b54cb5 DH |
112 | _enter("%p{%d,%d}", |
113 | local, local->srx.transport_type, local->srx.transport.family); | |
17926a79 DH |
114 | |
115 | /* create a socket to represent the local endpoint */ | |
2baec2c3 | 116 | ret = sock_create_kern(net, local->srx.transport.family, |
aaa31cbc | 117 | local->srx.transport_type, 0, &local->socket); |
17926a79 DH |
118 | if (ret < 0) { |
119 | _leave(" = %d [socket]", ret); | |
120 | return ret; | |
121 | } | |
122 | ||
2cfa2271 | 123 | /* set the socket up */ |
5271953c DH |
124 | usk = local->socket->sk; |
125 | inet_sk(usk)->mc_loop = 0; | |
126 | ||
127 | /* Enable CHECKSUM_UNNECESSARY to CHECKSUM_COMPLETE conversion */ | |
128 | inet_inc_convert_csum(usk); | |
129 | ||
130 | rcu_assign_sk_user_data(usk, local); | |
131 | ||
132 | udp_sk(usk)->encap_type = UDP_ENCAP_RXRPC; | |
133 | udp_sk(usk)->encap_rcv = rxrpc_input_packet; | |
134 | udp_sk(usk)->encap_destroy = NULL; | |
135 | udp_sk(usk)->gro_receive = NULL; | |
136 | udp_sk(usk)->gro_complete = NULL; | |
137 | ||
138 | udp_encap_enable(); | |
7ec8dc96 | 139 | #if IS_ENABLED(CONFIG_AF_RXRPC_IPV6) |
5271953c DH |
140 | if (local->srx.transport.family == AF_INET6) |
141 | udpv6_encap_enable(); | |
142 | #endif | |
143 | usk->sk_error_report = rxrpc_error_report; | |
2cfa2271 | 144 | |
17926a79 DH |
145 | /* if a local address was supplied then bind it */ |
146 | if (local->srx.transport_len > sizeof(sa_family_t)) { | |
147 | _debug("bind"); | |
148 | ret = kernel_bind(local->socket, | |
4f95dd78 | 149 | (struct sockaddr *)&local->srx.transport, |
17926a79 DH |
150 | local->srx.transport_len); |
151 | if (ret < 0) { | |
4f95dd78 | 152 | _debug("bind failed %d", ret); |
17926a79 DH |
153 | goto error; |
154 | } | |
155 | } | |
156 | ||
f2aeed3a | 157 | switch (local->srx.transport.family) { |
37a675e7 DH |
158 | case AF_INET6: |
159 | /* we want to receive ICMPv6 errors */ | |
f2aeed3a | 160 | opt = 1; |
37a675e7 | 161 | ret = kernel_setsockopt(local->socket, SOL_IPV6, IPV6_RECVERR, |
f2aeed3a DH |
162 | (char *) &opt, sizeof(opt)); |
163 | if (ret < 0) { | |
164 | _debug("setsockopt failed"); | |
165 | goto error; | |
166 | } | |
17926a79 | 167 | |
f2aeed3a | 168 | /* we want to set the don't fragment bit */ |
37a675e7 DH |
169 | opt = IPV6_PMTUDISC_DO; |
170 | ret = kernel_setsockopt(local->socket, SOL_IPV6, IPV6_MTU_DISCOVER, | |
f2aeed3a DH |
171 | (char *) &opt, sizeof(opt)); |
172 | if (ret < 0) { | |
173 | _debug("setsockopt failed"); | |
174 | goto error; | |
175 | } | |
f2aeed3a | 176 | |
37a675e7 DH |
177 | /* Fall through and set IPv4 options too otherwise we don't get |
178 | * errors from IPv4 packets sent through the IPv6 socket. | |
179 | */ | |
936ee65f | 180 | /* Fall through */ |
37a675e7 | 181 | case AF_INET: |
f2aeed3a DH |
182 | /* we want to receive ICMP errors */ |
183 | opt = 1; | |
37a675e7 | 184 | ret = kernel_setsockopt(local->socket, SOL_IP, IP_RECVERR, |
f2aeed3a DH |
185 | (char *) &opt, sizeof(opt)); |
186 | if (ret < 0) { | |
187 | _debug("setsockopt failed"); | |
188 | goto error; | |
189 | } | |
190 | ||
191 | /* we want to set the don't fragment bit */ | |
37a675e7 DH |
192 | opt = IP_PMTUDISC_DO; |
193 | ret = kernel_setsockopt(local->socket, SOL_IP, IP_MTU_DISCOVER, | |
f2aeed3a DH |
194 | (char *) &opt, sizeof(opt)); |
195 | if (ret < 0) { | |
196 | _debug("setsockopt failed"); | |
197 | goto error; | |
198 | } | |
b604dd98 DH |
199 | |
200 | /* We want receive timestamps. */ | |
201 | opt = 1; | |
7f1bc6e9 | 202 | ret = kernel_setsockopt(local->socket, SOL_SOCKET, SO_TIMESTAMPNS_OLD, |
b604dd98 DH |
203 | (char *)&opt, sizeof(opt)); |
204 | if (ret < 0) { | |
205 | _debug("setsockopt failed"); | |
206 | goto error; | |
207 | } | |
f2aeed3a DH |
208 | break; |
209 | ||
210 | default: | |
211 | BUG(); | |
17926a79 DH |
212 | } |
213 | ||
17926a79 DH |
214 | _leave(" = 0"); |
215 | return 0; | |
216 | ||
217 | error: | |
91cf45f0 | 218 | kernel_sock_shutdown(local->socket, SHUT_RDWR); |
17926a79 DH |
219 | local->socket->sk->sk_user_data = NULL; |
220 | sock_release(local->socket); | |
221 | local->socket = NULL; | |
222 | ||
223 | _leave(" = %d", ret); | |
224 | return ret; | |
225 | } | |
226 | ||
227 | /* | |
4f95dd78 | 228 | * Look up or create a new local endpoint using the specified local address. |
17926a79 | 229 | */ |
2baec2c3 DH |
230 | struct rxrpc_local *rxrpc_lookup_local(struct net *net, |
231 | const struct sockaddr_rxrpc *srx) | |
17926a79 DH |
232 | { |
233 | struct rxrpc_local *local; | |
2baec2c3 | 234 | struct rxrpc_net *rxnet = rxrpc_net(net); |
4f95dd78 DH |
235 | struct list_head *cursor; |
236 | const char *age; | |
237 | long diff; | |
17926a79 DH |
238 | int ret; |
239 | ||
75b54cb5 DH |
240 | _enter("{%d,%d,%pISp}", |
241 | srx->transport_type, srx->transport.family, &srx->transport); | |
17926a79 | 242 | |
2baec2c3 | 243 | mutex_lock(&rxnet->local_mutex); |
17926a79 | 244 | |
2baec2c3 DH |
245 | for (cursor = rxnet->local_endpoints.next; |
246 | cursor != &rxnet->local_endpoints; | |
4f95dd78 DH |
247 | cursor = cursor->next) { |
248 | local = list_entry(cursor, struct rxrpc_local, link); | |
17926a79 | 249 | |
4f95dd78 DH |
250 | diff = rxrpc_local_cmp_key(local, srx); |
251 | if (diff < 0) | |
17926a79 | 252 | continue; |
4f95dd78 DH |
253 | if (diff > 0) |
254 | break; | |
255 | ||
256 | /* Services aren't allowed to share transport sockets, so | |
257 | * reject that here. It is possible that the object is dying - | |
258 | * but it may also still have the local transport address that | |
259 | * we want bound. | |
260 | */ | |
261 | if (srx->srx_service) { | |
262 | local = NULL; | |
263 | goto addr_in_use; | |
264 | } | |
17926a79 | 265 | |
4f95dd78 DH |
266 | /* Found a match. We replace a dying object. Attempting to |
267 | * bind the transport socket may still fail if we're attempting | |
268 | * to use a local address that the dying object is still using. | |
269 | */ | |
730c5fd4 | 270 | if (!rxrpc_use_local(local)) |
4f95dd78 | 271 | break; |
17926a79 | 272 | |
4f95dd78 DH |
273 | age = "old"; |
274 | goto found; | |
275 | } | |
17926a79 | 276 | |
2baec2c3 | 277 | local = rxrpc_alloc_local(rxnet, srx); |
4f95dd78 DH |
278 | if (!local) |
279 | goto nomem; | |
17926a79 | 280 | |
2baec2c3 | 281 | ret = rxrpc_open_socket(local, net); |
4f95dd78 DH |
282 | if (ret < 0) |
283 | goto sock_error; | |
284 | ||
730c5fd4 | 285 | if (cursor != &rxnet->local_endpoints) |
b00df840 | 286 | list_replace_init(cursor, &local->link); |
730c5fd4 DH |
287 | else |
288 | list_add_tail(&local->link, cursor); | |
4f95dd78 | 289 | age = "new"; |
17926a79 | 290 | |
4f95dd78 | 291 | found: |
2baec2c3 | 292 | mutex_unlock(&rxnet->local_mutex); |
17926a79 | 293 | |
75b54cb5 DH |
294 | _net("LOCAL %s %d {%pISp}", |
295 | age, local->debug_id, &local->srx.transport); | |
17926a79 | 296 | |
4f95dd78 | 297 | _leave(" = %p", local); |
17926a79 DH |
298 | return local; |
299 | ||
4f95dd78 DH |
300 | nomem: |
301 | ret = -ENOMEM; | |
302 | sock_error: | |
2baec2c3 | 303 | mutex_unlock(&rxnet->local_mutex); |
032be5f1 ED |
304 | if (local) |
305 | call_rcu(&local->rcu, rxrpc_local_rcu); | |
4f95dd78 DH |
306 | _leave(" = %d", ret); |
307 | return ERR_PTR(ret); | |
17926a79 | 308 | |
4f95dd78 | 309 | addr_in_use: |
2baec2c3 | 310 | mutex_unlock(&rxnet->local_mutex); |
4f95dd78 DH |
311 | _leave(" = -EADDRINUSE"); |
312 | return ERR_PTR(-EADDRINUSE); | |
313 | } | |
17926a79 | 314 | |
09d2bf59 DH |
315 | /* |
316 | * Get a ref on a local endpoint. | |
317 | */ | |
318 | struct rxrpc_local *rxrpc_get_local(struct rxrpc_local *local) | |
319 | { | |
320 | const void *here = __builtin_return_address(0); | |
321 | int n; | |
322 | ||
323 | n = atomic_inc_return(&local->usage); | |
06d9532f | 324 | trace_rxrpc_local(local->debug_id, rxrpc_local_got, n, here); |
09d2bf59 DH |
325 | return local; |
326 | } | |
327 | ||
328 | /* | |
329 | * Get a ref on a local endpoint unless its usage has already reached 0. | |
330 | */ | |
331 | struct rxrpc_local *rxrpc_get_local_maybe(struct rxrpc_local *local) | |
332 | { | |
333 | const void *here = __builtin_return_address(0); | |
334 | ||
335 | if (local) { | |
bfc18e38 | 336 | int n = atomic_fetch_add_unless(&local->usage, 1, 0); |
09d2bf59 | 337 | if (n > 0) |
06d9532f DH |
338 | trace_rxrpc_local(local->debug_id, rxrpc_local_got, |
339 | n + 1, here); | |
09d2bf59 DH |
340 | else |
341 | local = NULL; | |
342 | } | |
343 | return local; | |
344 | } | |
345 | ||
346 | /* | |
06d9532f | 347 | * Queue a local endpoint and pass the caller's reference to the work item. |
09d2bf59 DH |
348 | */ |
349 | void rxrpc_queue_local(struct rxrpc_local *local) | |
350 | { | |
351 | const void *here = __builtin_return_address(0); | |
06d9532f DH |
352 | unsigned int debug_id = local->debug_id; |
353 | int n = atomic_read(&local->usage); | |
09d2bf59 DH |
354 | |
355 | if (rxrpc_queue_work(&local->processor)) | |
06d9532f | 356 | trace_rxrpc_local(debug_id, rxrpc_local_queued, n, here); |
730c5fd4 DH |
357 | else |
358 | rxrpc_put_local(local); | |
17926a79 DH |
359 | } |
360 | ||
09d2bf59 DH |
361 | /* |
362 | * Drop a ref on a local endpoint. | |
363 | */ | |
364 | void rxrpc_put_local(struct rxrpc_local *local) | |
365 | { | |
366 | const void *here = __builtin_return_address(0); | |
367 | int n; | |
368 | ||
369 | if (local) { | |
370 | n = atomic_dec_return(&local->usage); | |
06d9532f | 371 | trace_rxrpc_local(local->debug_id, rxrpc_local_put, n, here); |
09d2bf59 DH |
372 | |
373 | if (n == 0) | |
730c5fd4 | 374 | call_rcu(&local->rcu, rxrpc_local_rcu); |
09d2bf59 DH |
375 | } |
376 | } | |
377 | ||
730c5fd4 DH |
378 | /* |
379 | * Start using a local endpoint. | |
380 | */ | |
381 | struct rxrpc_local *rxrpc_use_local(struct rxrpc_local *local) | |
382 | { | |
383 | unsigned int au; | |
384 | ||
385 | local = rxrpc_get_local_maybe(local); | |
386 | if (!local) | |
387 | return NULL; | |
388 | ||
389 | au = atomic_fetch_add_unless(&local->active_users, 1, 0); | |
390 | if (au == 0) { | |
391 | rxrpc_put_local(local); | |
392 | return NULL; | |
393 | } | |
394 | ||
395 | return local; | |
396 | } | |
397 | ||
398 | /* | |
399 | * Cease using a local endpoint. Once the number of active users reaches 0, we | |
400 | * start the closure of the transport in the work processor. | |
401 | */ | |
402 | void rxrpc_unuse_local(struct rxrpc_local *local) | |
403 | { | |
404 | unsigned int au; | |
405 | ||
68553f1a DH |
406 | if (local) { |
407 | au = atomic_dec_return(&local->active_users); | |
408 | if (au == 0) | |
409 | rxrpc_queue_local(local); | |
410 | else | |
411 | rxrpc_put_local(local); | |
412 | } | |
730c5fd4 DH |
413 | } |
414 | ||
17926a79 | 415 | /* |
4f95dd78 DH |
416 | * Destroy a local endpoint's socket and then hand the record to RCU to dispose |
417 | * of. | |
418 | * | |
419 | * Closing the socket cannot be done from bottom half context or RCU callback | |
420 | * context because it might sleep. | |
17926a79 | 421 | */ |
4f95dd78 | 422 | static void rxrpc_local_destroyer(struct rxrpc_local *local) |
17926a79 | 423 | { |
4f95dd78 | 424 | struct socket *socket = local->socket; |
2baec2c3 | 425 | struct rxrpc_net *rxnet = local->rxnet; |
17926a79 | 426 | |
4f95dd78 | 427 | _enter("%d", local->debug_id); |
17926a79 | 428 | |
d12040b6 DH |
429 | local->dead = true; |
430 | ||
2baec2c3 | 431 | mutex_lock(&rxnet->local_mutex); |
4f95dd78 | 432 | list_del_init(&local->link); |
2baec2c3 | 433 | mutex_unlock(&rxnet->local_mutex); |
4f95dd78 | 434 | |
d12040b6 DH |
435 | rxrpc_clean_up_local_conns(local); |
436 | rxrpc_service_connection_reaper(&rxnet->service_conn_reaper); | |
1e9e5c95 | 437 | ASSERT(!local->service); |
4f95dd78 DH |
438 | |
439 | if (socket) { | |
440 | local->socket = NULL; | |
441 | kernel_sock_shutdown(socket, SHUT_RDWR); | |
442 | socket->sk->sk_user_data = NULL; | |
443 | sock_release(socket); | |
444 | } | |
445 | ||
446 | /* At this point, there should be no more packets coming in to the | |
447 | * local endpoint. | |
448 | */ | |
4f95dd78 DH |
449 | rxrpc_purge_queue(&local->reject_queue); |
450 | rxrpc_purge_queue(&local->event_queue); | |
17926a79 DH |
451 | } |
452 | ||
453 | /* | |
730c5fd4 DH |
454 | * Process events on an endpoint. The work item carries a ref which |
455 | * we must release. | |
17926a79 | 456 | */ |
4f95dd78 | 457 | static void rxrpc_local_processor(struct work_struct *work) |
17926a79 DH |
458 | { |
459 | struct rxrpc_local *local = | |
4f95dd78 DH |
460 | container_of(work, struct rxrpc_local, processor); |
461 | bool again; | |
17926a79 | 462 | |
06d9532f | 463 | trace_rxrpc_local(local->debug_id, rxrpc_local_processing, |
09d2bf59 | 464 | atomic_read(&local->usage), NULL); |
17926a79 | 465 | |
4f95dd78 DH |
466 | do { |
467 | again = false; | |
730c5fd4 DH |
468 | if (atomic_read(&local->active_users) == 0) { |
469 | rxrpc_local_destroyer(local); | |
470 | break; | |
471 | } | |
17926a79 | 472 | |
4f95dd78 DH |
473 | if (!skb_queue_empty(&local->reject_queue)) { |
474 | rxrpc_reject_packets(local); | |
475 | again = true; | |
476 | } | |
17926a79 | 477 | |
4f95dd78 DH |
478 | if (!skb_queue_empty(&local->event_queue)) { |
479 | rxrpc_process_local_events(local); | |
480 | again = true; | |
481 | } | |
482 | } while (again); | |
730c5fd4 DH |
483 | |
484 | rxrpc_put_local(local); | |
4f95dd78 | 485 | } |
17926a79 | 486 | |
4f95dd78 DH |
487 | /* |
488 | * Destroy a local endpoint after the RCU grace period expires. | |
489 | */ | |
490 | static void rxrpc_local_rcu(struct rcu_head *rcu) | |
491 | { | |
492 | struct rxrpc_local *local = container_of(rcu, struct rxrpc_local, rcu); | |
17926a79 | 493 | |
4f95dd78 | 494 | _enter("%d", local->debug_id); |
17926a79 | 495 | |
4f95dd78 | 496 | ASSERT(!work_pending(&local->processor)); |
17926a79 DH |
497 | |
498 | _net("DESTROY LOCAL %d", local->debug_id); | |
499 | kfree(local); | |
17926a79 DH |
500 | _leave(""); |
501 | } | |
502 | ||
503 | /* | |
4f95dd78 | 504 | * Verify the local endpoint list is empty by this point. |
17926a79 | 505 | */ |
2baec2c3 | 506 | void rxrpc_destroy_all_locals(struct rxrpc_net *rxnet) |
17926a79 | 507 | { |
4f95dd78 | 508 | struct rxrpc_local *local; |
17926a79 DH |
509 | |
510 | _enter(""); | |
511 | ||
dee46364 | 512 | flush_workqueue(rxrpc_workqueue); |
17926a79 | 513 | |
2baec2c3 DH |
514 | if (!list_empty(&rxnet->local_endpoints)) { |
515 | mutex_lock(&rxnet->local_mutex); | |
516 | list_for_each_entry(local, &rxnet->local_endpoints, link) { | |
dee46364 DH |
517 | pr_err("AF_RXRPC: Leaked local %p {%d}\n", |
518 | local, atomic_read(&local->usage)); | |
519 | } | |
2baec2c3 | 520 | mutex_unlock(&rxnet->local_mutex); |
dee46364 | 521 | BUG(); |
17926a79 | 522 | } |
17926a79 | 523 | } |