[deliverable/linux.git] / net / rxrpc / local_object.c

/* Local endpoint object management
 *
 * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public Licence
 * as published by the Free Software Foundation; either version
 * 2 of the Licence, or (at your option) any later version.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/net.h>
#include <linux/skbuff.h>
#include <linux/slab.h>
#include <linux/udp.h>
#include <linux/ip.h>
#include <linux/hashtable.h>
#include <net/sock.h>
#include <net/af_rxrpc.h>
#include "ar-internal.h"

static void rxrpc_local_processor(struct work_struct *);
static void rxrpc_local_rcu(struct rcu_head *);

static DEFINE_MUTEX(rxrpc_local_mutex);
static LIST_HEAD(rxrpc_local_endpoints);

/*
 * Compare a local to an address.  Return -ve, 0 or +ve to indicate less than,
 * same or greater than.
 *
 * We explicitly don't compare the RxRPC service ID as we want to reject
 * conflicting uses by differing services.  Further, we don't want to share
 * addresses with different options (IPv6), so we don't compare those bits
 * either.
 */
static long rxrpc_local_cmp_key(const struct rxrpc_local *local,
				const struct sockaddr_rxrpc *srx)
{
	long diff;

	diff = ((local->srx.transport_type - srx->transport_type) ?:
		(local->srx.transport_len - srx->transport_len) ?:
		(local->srx.transport.family - srx->transport.family));
	if (diff != 0)
		return diff;

	switch (srx->transport.family) {
	case AF_INET:
		/* If the choice of UDP port is left up to the transport, then
		 * the endpoint record doesn't match.
		 */
		return ((u16 __force)local->srx.transport.sin.sin_port -
			(u16 __force)srx->transport.sin.sin_port) ?:
			memcmp(&local->srx.transport.sin.sin_addr,
			       &srx->transport.sin.sin_addr,
			       sizeof(struct in_addr));
	default:
		BUG();
	}
}

/*
 * Allocate a new local endpoint.
 */
static struct rxrpc_local *rxrpc_alloc_local(const struct sockaddr_rxrpc *srx)
{
	struct rxrpc_local *local;

	local = kzalloc(sizeof(struct rxrpc_local), GFP_KERNEL);
	if (local) {
		atomic_set(&local->usage, 1);
		INIT_LIST_HEAD(&local->link);
		INIT_WORK(&local->processor, rxrpc_local_processor);
		INIT_HLIST_HEAD(&local->services);
		init_rwsem(&local->defrag_sem);
		skb_queue_head_init(&local->reject_queue);
		skb_queue_head_init(&local->event_queue);
		local->client_conns = RB_ROOT;
		spin_lock_init(&local->client_conns_lock);
		spin_lock_init(&local->lock);
		rwlock_init(&local->services_lock);
		local->debug_id = atomic_inc_return(&rxrpc_debug_id);
		memcpy(&local->srx, srx, sizeof(*srx));
	}

	_leave(" = %p", local);
	return local;
}

/*
 * create the local socket
 * - must be called with rxrpc_local_mutex locked
 */
static int rxrpc_open_socket(struct rxrpc_local *local)
{
	struct sock *sock;
	int ret, opt;

	_enter("%p{%d}", local, local->srx.transport_type);

	/* create a socket to represent the local endpoint */
	ret = sock_create_kern(&init_net, PF_INET, local->srx.transport_type,
			       IPPROTO_UDP, &local->socket);
	if (ret < 0) {
		_leave(" = %d [socket]", ret);
		return ret;
	}

	/* if a local address was supplied then bind it */
	if (local->srx.transport_len > sizeof(sa_family_t)) {
		_debug("bind");
		ret = kernel_bind(local->socket,
				  (struct sockaddr *)&local->srx.transport,
				  local->srx.transport_len);
		if (ret < 0) {
			_debug("bind failed %d", ret);
			goto error;
		}
	}

	/* we want to receive ICMP errors */
	opt = 1;
	ret = kernel_setsockopt(local->socket, SOL_IP, IP_RECVERR,
				(char *) &opt, sizeof(opt));
	if (ret < 0) {
		_debug("setsockopt failed");
		goto error;
	}

	/* we want to set the don't fragment bit */
	opt = IP_PMTUDISC_DO;
	ret = kernel_setsockopt(local->socket, SOL_IP, IP_MTU_DISCOVER,
				(char *) &opt, sizeof(opt));
	if (ret < 0) {
		_debug("setsockopt failed");
		goto error;
	}

	/* set the socket up */
	sock = local->socket->sk;
	sock->sk_user_data	= local;
	sock->sk_data_ready	= rxrpc_data_ready;
	sock->sk_error_report	= rxrpc_error_report;
	_leave(" = 0");
	return 0;

error:
	kernel_sock_shutdown(local->socket, SHUT_RDWR);
	local->socket->sk->sk_user_data = NULL;
	sock_release(local->socket);
	local->socket = NULL;

	_leave(" = %d", ret);
	return ret;
}

/*
 * Look up or create a new local endpoint using the specified local address.
 */
struct rxrpc_local *rxrpc_lookup_local(const struct sockaddr_rxrpc *srx)
{
	struct rxrpc_local *local;
	struct list_head *cursor;
	const char *age;
	long diff;
	int ret;

	if (srx->transport.family == AF_INET) {
		_enter("{%d,%u,%pI4+%hu}",
		       srx->transport_type,
		       srx->transport.family,
		       &srx->transport.sin.sin_addr,
		       ntohs(srx->transport.sin.sin_port));
	} else {
		_enter("{%d,%u}",
		       srx->transport_type,
		       srx->transport.family);
		return ERR_PTR(-EAFNOSUPPORT);
	}

	mutex_lock(&rxrpc_local_mutex);

	for (cursor = rxrpc_local_endpoints.next;
	     cursor != &rxrpc_local_endpoints;
	     cursor = cursor->next) {
		local = list_entry(cursor, struct rxrpc_local, link);

		diff = rxrpc_local_cmp_key(local, srx);
		if (diff < 0)
			continue;
		if (diff > 0)
			break;

		/* Services aren't allowed to share transport sockets, so
		 * reject that here.  It is possible that the object is dying -
		 * but it may also still have the local transport address that
		 * we want bound.
		 */
		if (srx->srx_service) {
			local = NULL;
			goto addr_in_use;
		}

		/* Found a match.  We replace a dying object.  Attempting to
		 * bind the transport socket may still fail if we're attempting
		 * to use a local address that the dying object is still using.
		 */
		if (!rxrpc_get_local_maybe(local)) {
			cursor = cursor->next;
			list_del_init(&local->link);
			break;
		}

		age = "old";
		goto found;
	}

	local = rxrpc_alloc_local(srx);
	if (!local)
		goto nomem;

	ret = rxrpc_open_socket(local);
	if (ret < 0)
		goto sock_error;

	list_add_tail(&local->link, cursor);
	age = "new";

found:
	mutex_unlock(&rxrpc_local_mutex);

	_net("LOCAL %s %d {%d,%u,%pI4+%hu}",
	     age,
	     local->debug_id,
	     local->srx.transport_type,
	     local->srx.transport.family,
	     &local->srx.transport.sin.sin_addr,
	     ntohs(local->srx.transport.sin.sin_port));

	_leave(" = %p", local);
	return local;

nomem:
	ret = -ENOMEM;
sock_error:
	mutex_unlock(&rxrpc_local_mutex);
	kfree(local);
	_leave(" = %d", ret);
	return ERR_PTR(ret);

addr_in_use:
	mutex_unlock(&rxrpc_local_mutex);
	_leave(" = -EADDRINUSE");
	return ERR_PTR(-EADDRINUSE);
}

/*
 * A local endpoint reached its end of life.
 */
void __rxrpc_put_local(struct rxrpc_local *local)
{
	_enter("%d", local->debug_id);
	rxrpc_queue_work(&local->processor);
}

/*
 * Destroy a local endpoint's socket and then hand the record to RCU to dispose
 * of.
 *
 * Closing the socket cannot be done from bottom half context or RCU callback
 * context because it might sleep.
 */
static void rxrpc_local_destroyer(struct rxrpc_local *local)
{
	struct socket *socket = local->socket;

	_enter("%d", local->debug_id);

	/* We can get a race between an incoming call packet queueing the
	 * processor again and the work processor starting the destruction
	 * process which will shut down the UDP socket.
	 */
	if (local->dead) {
		_leave(" [already dead]");
		return;
	}
	local->dead = true;

	mutex_lock(&rxrpc_local_mutex);
	list_del_init(&local->link);
	mutex_unlock(&rxrpc_local_mutex);

	ASSERT(RB_EMPTY_ROOT(&local->client_conns));
	ASSERT(hlist_empty(&local->services));

	if (socket) {
		local->socket = NULL;
		kernel_sock_shutdown(socket, SHUT_RDWR);
		socket->sk->sk_user_data = NULL;
		sock_release(socket);
	}

	/* At this point, there should be no more packets coming in to the
	 * local endpoint.
	 */
	rxrpc_purge_queue(&local->reject_queue);
	rxrpc_purge_queue(&local->event_queue);

	_debug("rcu local %d", local->debug_id);
	call_rcu(&local->rcu, rxrpc_local_rcu);
}

/*
 * Process events on an endpoint
 */
static void rxrpc_local_processor(struct work_struct *work)
{
	struct rxrpc_local *local =
		container_of(work, struct rxrpc_local, processor);
	bool again;

	_enter("%d", local->debug_id);

	do {
		again = false;
		if (atomic_read(&local->usage) == 0)
			return rxrpc_local_destroyer(local);

		if (!skb_queue_empty(&local->reject_queue)) {
			rxrpc_reject_packets(local);
			again = true;
		}

		if (!skb_queue_empty(&local->event_queue)) {
			rxrpc_process_local_events(local);
			again = true;
		}
	} while (again);
}

/*
 * Destroy a local endpoint after the RCU grace period expires.
 */
static void rxrpc_local_rcu(struct rcu_head *rcu)
{
	struct rxrpc_local *local = container_of(rcu, struct rxrpc_local, rcu);

	_enter("%d", local->debug_id);

	ASSERT(!work_pending(&local->processor));

	_net("DESTROY LOCAL %d", local->debug_id);
	kfree(local);
	_leave("");
}

/*
 * Verify the local endpoint list is empty by this point.
 */
void __exit rxrpc_destroy_all_locals(void)
{
	struct rxrpc_local *local;

	_enter("");

	flush_workqueue(rxrpc_workqueue);

	if (!list_empty(&rxrpc_local_endpoints)) {
		mutex_lock(&rxrpc_local_mutex);
		list_for_each_entry(local, &rxrpc_local_endpoints, link) {
			pr_err("AF_RXRPC: Leaked local %p {%d}\n",
			       local, atomic_read(&local->usage));
		}
		mutex_unlock(&rxrpc_local_mutex);
		BUG();
	}

	rcu_barrier();
}
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	*/
17926a79 DH	11
9b6d5398 JP	12	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9b6d5398 JP	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>
44ba0698 DH	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 *);
4f95dd78 DH	26	static void rxrpc_local_rcu(struct rcu_head *);
17926a79	27
4f95dd78 DH	28	static DEFINE_MUTEX(rxrpc_local_mutex);
4f95dd78 DH	29	static LIST_HEAD(rxrpc_local_endpoints);
17926a79 DH	30
17926a79 DH	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	77	INIT_WORK(&local->processor, rxrpc_local_processor);
de8d6c74	78	INIT_HLIST_HEAD(&local->services);
17926a79	79	init_rwsem(&local->defrag_sem);
17926a79	80	skb_queue_head_init(&local->reject_queue);
44ba0698	81	skb_queue_head_init(&local->event_queue);
999b69f8 DH	82	local->client_conns = RB_ROOT;
999b69f8 DH	83	spin_lock_init(&local->client_conns_lock);
17926a79 DH	84	spin_lock_init(&local->lock);
17926a79 DH	85	rwlock_init(&local->services_lock);
17926a79 DH	86	local->debug_id = atomic_inc_return(&rxrpc_debug_id);
	87	memcpy(&local->srx, srx, sizeof(*srx));
	88	}
	89
	90	_leave(" = %p", local);
	91	return local;
	92	}
	93
	94	/*
	95	* create the local socket
4f95dd78	96	* - must be called with rxrpc_local_mutex locked
17926a79	97	*/
4f95dd78	98	static int rxrpc_open_socket(struct rxrpc_local *local)
17926a79 DH	99	{
	100	struct sock *sock;
	101	int ret, opt;
	102
	103	_enter("%p{%d}", local, local->srx.transport_type);
	104
	105	/* create a socket to represent the local endpoint */
eeb1bd5c EB	106	ret = sock_create_kern(&init_net, PF_INET, local->srx.transport_type,
eeb1bd5c EB	107	IPPROTO_UDP, &local->socket);
17926a79 DH	108	if (ret < 0) {
	109	_leave(" = %d [socket]", ret);
	110	return ret;
	111	}
	112
	113	/* if a local address was supplied then bind it */
	114	if (local->srx.transport_len > sizeof(sa_family_t)) {
	115	_debug("bind");
	116	ret = kernel_bind(local->socket,
4f95dd78	117	(struct sockaddr *)&local->srx.transport,
17926a79 DH	118	local->srx.transport_len);
17926a79 DH	119	if (ret < 0) {
4f95dd78	120	_debug("bind failed %d", ret);
17926a79 DH	121	goto error;
	122	}
	123	}
	124
	125	/* we want to receive ICMP errors */
	126	opt = 1;
	127	ret = kernel_setsockopt(local->socket, SOL_IP, IP_RECVERR,
	128	(char *) &opt, sizeof(opt));
	129	if (ret < 0) {
	130	_debug("setsockopt failed");
	131	goto error;
	132	}
	133
	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));
	138	if (ret < 0) {
	139	_debug("setsockopt failed");
	140	goto error;
	141	}
	142
17926a79 DH	143	/* set the socket up */
	144	sock = local->socket->sk;
	145	sock->sk_user_data = local;
	146	sock->sk_data_ready = rxrpc_data_ready;
abe89ef0	147	sock->sk_error_report = rxrpc_error_report;
17926a79 DH	148	_leave(" = 0");
	149	return 0;
	150
	151	error:
91cf45f0	152	kernel_sock_shutdown(local->socket, SHUT_RDWR);
17926a79 DH	153	local->socket->sk->sk_user_data = NULL;
	154	sock_release(local->socket);
	155	local->socket = NULL;
	156
	157	_leave(" = %d", ret);
	158	return ret;
	159	}
	160
	161	/*
4f95dd78	162	* Look up or create a new local endpoint using the specified local address.
17926a79	163	*/
4f95dd78	164	struct rxrpc_local rxrpc_lookup_local(const struct sockaddr_rxrpc srx)
17926a79 DH	165	{
17926a79 DH	166	struct rxrpc_local *local;
4f95dd78 DH	167	struct list_head *cursor;
	168	const char *age;
	169	long diff;
17926a79 DH	170	int ret;
17926a79 DH	171
4f95dd78 DH	172	if (srx->transport.family == AF_INET) {
	173	_enter("{%d,%u,%pI4+%hu}",
	174	srx->transport_type,
	175	srx->transport.family,
	176	&srx->transport.sin.sin_addr,
	177	ntohs(srx->transport.sin.sin_port));
	178	} else {
	179	_enter("{%d,%u}",
	180	srx->transport_type,
	181	srx->transport.family);
	182	return ERR_PTR(-EAFNOSUPPORT);
	183	}
17926a79	184
4f95dd78	185	mutex_lock(&rxrpc_local_mutex);
17926a79	186
4f95dd78 DH	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);
17926a79	191
4f95dd78 DH	192	diff = rxrpc_local_cmp_key(local, srx);
4f95dd78 DH	193	if (diff < 0)
17926a79	194	continue;
4f95dd78 DH	195	if (diff > 0)
	196	break;
	197
	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
	201	* we want bound.
	202	*/
	203	if (srx->srx_service) {
	204	local = NULL;
	205	goto addr_in_use;
	206	}
17926a79	207
4f95dd78 DH	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.
	211	*/
5627cc8b	212	if (!rxrpc_get_local_maybe(local)) {
4f95dd78 DH	213	cursor = cursor->next;
	214	list_del_init(&local->link);
	215	break;
17926a79	216	}
17926a79	217
4f95dd78 DH	218	age = "old";
	219	goto found;
	220	}
17926a79	221
17926a79	222	local = rxrpc_alloc_local(srx);
4f95dd78 DH	223	if (!local)
4f95dd78 DH	224	goto nomem;
17926a79	225
4f95dd78 DH	226	ret = rxrpc_open_socket(local);
	227	if (ret < 0)
	228	goto sock_error;
	229
	230	list_add_tail(&local->link, cursor);
	231	age = "new";
17926a79	232
4f95dd78 DH	233	found:
4f95dd78 DH	234	mutex_unlock(&rxrpc_local_mutex);
17926a79	235
4f95dd78 DH	236	_net("LOCAL %s %d {%d,%u,%pI4+%hu}",
4f95dd78 DH	237	age,
17926a79 DH	238	local->debug_id,
	239	local->srx.transport_type,
	240	local->srx.transport.family,
21454aaa	241	&local->srx.transport.sin.sin_addr,
17926a79 DH	242	ntohs(local->srx.transport.sin.sin_port));
17926a79 DH	243
4f95dd78	244	_leave(" = %p", local);
17926a79 DH	245	return local;
17926a79 DH	246
4f95dd78 DH	247	nomem:
	248	ret = -ENOMEM;
	249	sock_error:
	250	mutex_unlock(&rxrpc_local_mutex);
	251	kfree(local);
	252	_leave(" = %d", ret);
	253	return ERR_PTR(ret);
17926a79	254
4f95dd78 DH	255	addr_in_use:
	256	mutex_unlock(&rxrpc_local_mutex);
	257	_leave(" = -EADDRINUSE");
	258	return ERR_PTR(-EADDRINUSE);
	259	}
17926a79	260
4f95dd78 DH	261	/*
	262	* A local endpoint reached its end of life.
	263	*/
	264	void __rxrpc_put_local(struct rxrpc_local *local)
	265	{
	266	_enter("%d", local->debug_id);
	267	rxrpc_queue_work(&local->processor);
17926a79 DH	268	}
	269
	270	/*
4f95dd78 DH	271	* Destroy a local endpoint's socket and then hand the record to RCU to dispose
	272	* of.
	273	*
	274	* Closing the socket cannot be done from bottom half context or RCU callback
	275	* context because it might sleep.
17926a79	276	*/
4f95dd78	277	static void rxrpc_local_destroyer(struct rxrpc_local *local)
17926a79	278	{
4f95dd78	279	struct socket *socket = local->socket;
17926a79	280
4f95dd78	281	_enter("%d", local->debug_id);
17926a79	282
4f95dd78 DH	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.
	286	*/
	287	if (local->dead) {
	288	_leave(" [already dead]");
	289	return;
17926a79	290	}
4f95dd78 DH	291	local->dead = true;
	292
	293	mutex_lock(&rxrpc_local_mutex);
	294	list_del_init(&local->link);
	295	mutex_unlock(&rxrpc_local_mutex);
	296
999b69f8	297	ASSERT(RB_EMPTY_ROOT(&local->client_conns));
de8d6c74	298	ASSERT(hlist_empty(&local->services));
4f95dd78 DH	299
	300	if (socket) {
	301	local->socket = NULL;
	302	kernel_sock_shutdown(socket, SHUT_RDWR);
	303	socket->sk->sk_user_data = NULL;
	304	sock_release(socket);
	305	}
	306
	307	/* At this point, there should be no more packets coming in to the
	308	* local endpoint.
	309	*/
4f95dd78 DH	310	rxrpc_purge_queue(&local->reject_queue);
	311	rxrpc_purge_queue(&local->event_queue);
	312
	313	_debug("rcu local %d", local->debug_id);
	314	call_rcu(&local->rcu, rxrpc_local_rcu);
17926a79 DH	315	}
	316
	317	/*
4f95dd78	318	* Process events on an endpoint
17926a79	319	*/
4f95dd78	320	static void rxrpc_local_processor(struct work_struct *work)
17926a79 DH	321	{
17926a79 DH	322	struct rxrpc_local *local =
4f95dd78 DH	323	container_of(work, struct rxrpc_local, processor);
4f95dd78 DH	324	bool again;
17926a79	325
4f95dd78	326	_enter("%d", local->debug_id);
17926a79	327
4f95dd78 DH	328	do {
	329	again = false;
	330	if (atomic_read(&local->usage) == 0)
	331	return rxrpc_local_destroyer(local);
17926a79	332
4f95dd78 DH	333	if (!skb_queue_empty(&local->reject_queue)) {
	334	rxrpc_reject_packets(local);
	335	again = true;
	336	}
17926a79	337
4f95dd78 DH	338	if (!skb_queue_empty(&local->event_queue)) {
	339	rxrpc_process_local_events(local);
	340	again = true;
	341	}
	342	} while (again);
	343	}
17926a79	344
4f95dd78 DH	345	/*
	346	* Destroy a local endpoint after the RCU grace period expires.
	347	*/
	348	static void rxrpc_local_rcu(struct rcu_head *rcu)
	349	{
	350	struct rxrpc_local *local = container_of(rcu, struct rxrpc_local, rcu);
17926a79	351
4f95dd78	352	_enter("%d", local->debug_id);
17926a79	353
4f95dd78	354	ASSERT(!work_pending(&local->processor));
17926a79 DH	355
	356	_net("DESTROY LOCAL %d", local->debug_id);
	357	kfree(local);
17926a79 DH	358	_leave("");
	359	}
	360
	361	/*
4f95dd78	362	* Verify the local endpoint list is empty by this point.
17926a79 DH	363	*/
	364	void __exit rxrpc_destroy_all_locals(void)
	365	{
4f95dd78	366	struct rxrpc_local *local;
17926a79 DH	367
	368	_enter("");
	369
dee46364	370	flush_workqueue(rxrpc_workqueue);
17926a79	371
dee46364 DH	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));
	377	}
	378	mutex_unlock(&rxrpc_local_mutex);
	379	BUG();
17926a79	380	}
dee46364 DH	381
dee46364 DH	382	rcu_barrier();
17926a79	383	}