Linux Audio

Check our new training course

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