[deliverable/linux.git] / net / rxrpc / ar-peer.c

/* RxRPC remote transport endpoint management
 *
 * Copyright (C) 2007 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 License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

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

static LIST_HEAD(rxrpc_peers);
static DEFINE_RWLOCK(rxrpc_peer_lock);
static DECLARE_WAIT_QUEUE_HEAD(rxrpc_peer_wq);

static void rxrpc_destroy_peer(struct work_struct *work);

/*
 * assess the MTU size for the network interface through which this peer is
 * reached
 */
static void rxrpc_assess_MTU_size(struct rxrpc_peer *peer)
{
	struct rtable *rt;
	struct flowi4 fl4;

	peer->if_mtu = 1500;

	rt = ip_route_output_ports(&init_net, &fl4, NULL,
				   peer->srx.transport.sin.sin_addr.s_addr, 0,
				   htons(7000), htons(7001),
				   IPPROTO_UDP, 0, 0);
	if (IS_ERR(rt)) {
		_leave(" [route err %ld]", PTR_ERR(rt));
		return;
	}

	peer->if_mtu = dst_mtu(&rt->dst);
	dst_release(&rt->dst);

	_leave(" [if_mtu %u]", peer->if_mtu);
}

/*
 * allocate a new peer
 */
static struct rxrpc_peer *rxrpc_alloc_peer(struct sockaddr_rxrpc *srx,
					   gfp_t gfp)
{
	struct rxrpc_peer *peer;

	_enter("");

	peer = kzalloc(sizeof(struct rxrpc_peer), gfp);
	if (peer) {
		INIT_WORK(&peer->destroyer, &rxrpc_destroy_peer);
		INIT_LIST_HEAD(&peer->link);
		INIT_LIST_HEAD(&peer->error_targets);
		spin_lock_init(&peer->lock);
		atomic_set(&peer->usage, 1);
		peer->debug_id = atomic_inc_return(&rxrpc_debug_id);
		memcpy(&peer->srx, srx, sizeof(*srx));

		rxrpc_assess_MTU_size(peer);
		peer->mtu = peer->if_mtu;

		if (srx->transport.family == AF_INET) {
			peer->hdrsize = sizeof(struct iphdr);
			switch (srx->transport_type) {
			case SOCK_DGRAM:
				peer->hdrsize += sizeof(struct udphdr);
				break;
			default:
				BUG();
				break;
			}
		} else {
			BUG();
		}

		peer->hdrsize += sizeof(struct rxrpc_header);
		peer->maxdata = peer->mtu - peer->hdrsize;
	}

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

/*
 * obtain a remote transport endpoint for the specified address
 */
struct rxrpc_peer *rxrpc_get_peer(struct sockaddr_rxrpc *srx, gfp_t gfp)
{
	struct rxrpc_peer *peer, *candidate;
	const char *new = "old";
	int usage;

	_enter("{%d,%d,%pI4+%hu}",
	       srx->transport_type,
	       srx->transport_len,
	       &srx->transport.sin.sin_addr,
	       ntohs(srx->transport.sin.sin_port));

	/* search the peer list first */
	read_lock_bh(&rxrpc_peer_lock);
	list_for_each_entry(peer, &rxrpc_peers, link) {
		_debug("check PEER %d { u=%d t=%d l=%d }",
		       peer->debug_id,
		       atomic_read(&peer->usage),
		       peer->srx.transport_type,
		       peer->srx.transport_len);

		if (atomic_read(&peer->usage) > 0 &&
		    peer->srx.transport_type == srx->transport_type &&
		    peer->srx.transport_len == srx->transport_len &&
		    memcmp(&peer->srx.transport,
			   &srx->transport,
			   srx->transport_len) == 0)
			goto found_extant_peer;
	}
	read_unlock_bh(&rxrpc_peer_lock);

	/* not yet present - create a candidate for a new record and then
	 * redo the search */
	candidate = rxrpc_alloc_peer(srx, gfp);
	if (!candidate) {
		_leave(" = -ENOMEM");
		return ERR_PTR(-ENOMEM);
	}

	write_lock_bh(&rxrpc_peer_lock);

	list_for_each_entry(peer, &rxrpc_peers, link) {
		if (atomic_read(&peer->usage) > 0 &&
		    peer->srx.transport_type == srx->transport_type &&
		    peer->srx.transport_len == srx->transport_len &&
		    memcmp(&peer->srx.transport,
			   &srx->transport,
			   srx->transport_len) == 0)
			goto found_extant_second;
	}

	/* we can now add the new candidate to the list */
	peer = candidate;
	candidate = NULL;
	usage = atomic_read(&peer->usage);

	list_add_tail(&peer->link, &rxrpc_peers);
	write_unlock_bh(&rxrpc_peer_lock);
	new = "new";

success:
	_net("PEER %s %d {%d,%u,%pI4+%hu}",
	     new,
	     peer->debug_id,
	     peer->srx.transport_type,
	     peer->srx.transport.family,
	     &peer->srx.transport.sin.sin_addr,
	     ntohs(peer->srx.transport.sin.sin_port));

	_leave(" = %p {u=%d}", peer, usage);
	return peer;

	/* we found the peer in the list immediately */
found_extant_peer:
	usage = atomic_inc_return(&peer->usage);
	read_unlock_bh(&rxrpc_peer_lock);
	goto success;

	/* we found the peer on the second time through the list */
found_extant_second:
	usage = atomic_inc_return(&peer->usage);
	write_unlock_bh(&rxrpc_peer_lock);
	kfree(candidate);
	goto success;
}

/*
 * find the peer associated with a packet
 */
struct rxrpc_peer *rxrpc_find_peer(struct rxrpc_local *local,
				   __be32 addr, __be16 port)
{
	struct rxrpc_peer *peer;

	_enter("");

	/* search the peer list */
	read_lock_bh(&rxrpc_peer_lock);

	if (local->srx.transport.family == AF_INET &&
	    local->srx.transport_type == SOCK_DGRAM
	    ) {
		list_for_each_entry(peer, &rxrpc_peers, link) {
			if (atomic_read(&peer->usage) > 0 &&
			    peer->srx.transport_type == SOCK_DGRAM &&
			    peer->srx.transport.family == AF_INET &&
			    peer->srx.transport.sin.sin_port == port &&
			    peer->srx.transport.sin.sin_addr.s_addr == addr)
				goto found_UDP_peer;
		}

		goto new_UDP_peer;
	}

	read_unlock_bh(&rxrpc_peer_lock);
	_leave(" = -EAFNOSUPPORT");
	return ERR_PTR(-EAFNOSUPPORT);

found_UDP_peer:
	_net("Rx UDP DGRAM from peer %d", peer->debug_id);
	atomic_inc(&peer->usage);
	read_unlock_bh(&rxrpc_peer_lock);
	_leave(" = %p", peer);
	return peer;

new_UDP_peer:
	_net("Rx UDP DGRAM from NEW peer");
	read_unlock_bh(&rxrpc_peer_lock);
	_leave(" = -EBUSY [new]");
	return ERR_PTR(-EBUSY);
}

/*
 * release a remote transport endpoint
 */
void rxrpc_put_peer(struct rxrpc_peer *peer)
{
	_enter("%p{u=%d}", peer, atomic_read(&peer->usage));

	ASSERTCMP(atomic_read(&peer->usage), >, 0);

	if (likely(!atomic_dec_and_test(&peer->usage))) {
		_leave(" [in use]");
		return;
	}

	rxrpc_queue_work(&peer->destroyer);
	_leave("");
}

/*
 * destroy a remote transport endpoint
 */
static void rxrpc_destroy_peer(struct work_struct *work)
{
	struct rxrpc_peer *peer =
		container_of(work, struct rxrpc_peer, destroyer);

	_enter("%p{%d}", peer, atomic_read(&peer->usage));

	write_lock_bh(&rxrpc_peer_lock);
	list_del(&peer->link);
	write_unlock_bh(&rxrpc_peer_lock);

	_net("DESTROY PEER %d", peer->debug_id);
	kfree(peer);

	if (list_empty(&rxrpc_peers))
		wake_up_all(&rxrpc_peer_wq);
	_leave("");
}

/*
 * preemptively destroy all the peer records from a transport endpoint rather
 * than waiting for them to time out
 */
void __exit rxrpc_destroy_all_peers(void)
{
	DECLARE_WAITQUEUE(myself,current);

	_enter("");

	/* we simply have to wait for them to go away */
	if (!list_empty(&rxrpc_peers)) {
		set_current_state(TASK_UNINTERRUPTIBLE);
		add_wait_queue(&rxrpc_peer_wq, &myself);

		while (!list_empty(&rxrpc_peers)) {
			schedule();
			set_current_state(TASK_UNINTERRUPTIBLE);
		}

		remove_wait_queue(&rxrpc_peer_wq, &myself);
		set_current_state(TASK_RUNNING);
	}

	_leave("");
}
Commit	Line	Data
17926a79 DH	1	/* RxRPC remote transport endpoint management
	2	*
	3	* Copyright (C) 2007 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 License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/net.h>
	14	#include <linux/skbuff.h>
	15	#include <linux/udp.h>
	16	#include <linux/in.h>
	17	#include <linux/in6.h>
	18	#include <linux/icmp.h>
5a0e3ad6	19	#include <linux/slab.h>
17926a79 DH	20	#include <net/sock.h>
	21	#include <net/af_rxrpc.h>
	22	#include <net/ip.h>
224711df	23	#include <net/route.h>
17926a79 DH	24	#include "ar-internal.h"
	25
	26	static LIST_HEAD(rxrpc_peers);
	27	static DEFINE_RWLOCK(rxrpc_peer_lock);
	28	static DECLARE_WAIT_QUEUE_HEAD(rxrpc_peer_wq);
	29
	30	static void rxrpc_destroy_peer(struct work_struct *work);
	31
224711df DH	32	/*
	33	* assess the MTU size for the network interface through which this peer is
	34	* reached
	35	*/
	36	static void rxrpc_assess_MTU_size(struct rxrpc_peer *peer)
	37	{
	38	struct rtable *rt;
31e4543d	39	struct flowi4 fl4;
224711df DH	40
	41	peer->if_mtu = 1500;
	42
31e4543d	43	rt = ip_route_output_ports(&init_net, &fl4, NULL,
78fbfd8a DM	44	peer->srx.transport.sin.sin_addr.s_addr, 0,
	45	htons(7000), htons(7001),
	46	IPPROTO_UDP, 0, 0);
b23dd4fe DM	47	if (IS_ERR(rt)) {
b23dd4fe DM	48	_leave(" [route err %ld]", PTR_ERR(rt));
224711df DH	49	return;
	50	}
	51
d8d1f30b CG	52	peer->if_mtu = dst_mtu(&rt->dst);
d8d1f30b CG	53	dst_release(&rt->dst);
224711df	54
a6a62b69	55	_leave(" [if_mtu %u]", peer->if_mtu);
224711df DH	56	}
224711df DH	57
17926a79 DH	58	/*
	59	* allocate a new peer
	60	*/
	61	static struct rxrpc_peer rxrpc_alloc_peer(struct sockaddr_rxrpc srx,
	62	gfp_t gfp)
	63	{
	64	struct rxrpc_peer *peer;
	65
	66	_enter("");
	67
	68	peer = kzalloc(sizeof(struct rxrpc_peer), gfp);
	69	if (peer) {
	70	INIT_WORK(&peer->destroyer, &rxrpc_destroy_peer);
	71	INIT_LIST_HEAD(&peer->link);
	72	INIT_LIST_HEAD(&peer->error_targets);
	73	spin_lock_init(&peer->lock);
	74	atomic_set(&peer->usage, 1);
	75	peer->debug_id = atomic_inc_return(&rxrpc_debug_id);
	76	memcpy(&peer->srx, srx, sizeof(*srx));
	77
224711df DH	78	rxrpc_assess_MTU_size(peer);
224711df DH	79	peer->mtu = peer->if_mtu;
17926a79 DH	80
	81	if (srx->transport.family == AF_INET) {
	82	peer->hdrsize = sizeof(struct iphdr);
	83	switch (srx->transport_type) {
	84	case SOCK_DGRAM:
	85	peer->hdrsize += sizeof(struct udphdr);
	86	break;
	87	default:
	88	BUG();
	89	break;
	90	}
	91	} else {
	92	BUG();
	93	}
	94
	95	peer->hdrsize += sizeof(struct rxrpc_header);
	96	peer->maxdata = peer->mtu - peer->hdrsize;
	97	}
	98
	99	_leave(" = %p", peer);
	100	return peer;
	101	}
	102
	103	/*
	104	* obtain a remote transport endpoint for the specified address
	105	*/
	106	struct rxrpc_peer rxrpc_get_peer(struct sockaddr_rxrpc srx, gfp_t gfp)
	107	{
	108	struct rxrpc_peer peer, candidate;
	109	const char *new = "old";
	110	int usage;
	111
21454aaa	112	_enter("{%d,%d,%pI4+%hu}",
17926a79 DH	113	srx->transport_type,
17926a79 DH	114	srx->transport_len,
21454aaa	115	&srx->transport.sin.sin_addr,
17926a79 DH	116	ntohs(srx->transport.sin.sin_port));
	117
	118	/* search the peer list first */
	119	read_lock_bh(&rxrpc_peer_lock);
	120	list_for_each_entry(peer, &rxrpc_peers, link) {
	121	_debug("check PEER %d { u=%d t=%d l=%d }",
	122	peer->debug_id,
	123	atomic_read(&peer->usage),
	124	peer->srx.transport_type,
	125	peer->srx.transport_len);
	126
	127	if (atomic_read(&peer->usage) > 0 &&
	128	peer->srx.transport_type == srx->transport_type &&
	129	peer->srx.transport_len == srx->transport_len &&
	130	memcmp(&peer->srx.transport,
	131	&srx->transport,
	132	srx->transport_len) == 0)
	133	goto found_extant_peer;
	134	}
	135	read_unlock_bh(&rxrpc_peer_lock);
	136
	137	/* not yet present - create a candidate for a new record and then
	138	* redo the search */
	139	candidate = rxrpc_alloc_peer(srx, gfp);
	140	if (!candidate) {
	141	_leave(" = -ENOMEM");
	142	return ERR_PTR(-ENOMEM);
	143	}
	144
	145	write_lock_bh(&rxrpc_peer_lock);
	146
	147	list_for_each_entry(peer, &rxrpc_peers, link) {
	148	if (atomic_read(&peer->usage) > 0 &&
	149	peer->srx.transport_type == srx->transport_type &&
	150	peer->srx.transport_len == srx->transport_len &&
	151	memcmp(&peer->srx.transport,
	152	&srx->transport,
	153	srx->transport_len) == 0)
	154	goto found_extant_second;
	155	}
	156
	157	/* we can now add the new candidate to the list */
	158	peer = candidate;
	159	candidate = NULL;
2a642550	160	usage = atomic_read(&peer->usage);
17926a79 DH	161
	162	list_add_tail(&peer->link, &rxrpc_peers);
	163	write_unlock_bh(&rxrpc_peer_lock);
	164	new = "new";
	165
	166	success:
21454aaa	167	_net("PEER %s %d {%d,%u,%pI4+%hu}",
17926a79 DH	168	new,
	169	peer->debug_id,
	170	peer->srx.transport_type,
	171	peer->srx.transport.family,
21454aaa	172	&peer->srx.transport.sin.sin_addr,
17926a79 DH	173	ntohs(peer->srx.transport.sin.sin_port));
17926a79 DH	174
2a642550	175	_leave(" = %p {u=%d}", peer, usage);
17926a79 DH	176	return peer;
	177
	178	/* we found the peer in the list immediately */
	179	found_extant_peer:
	180	usage = atomic_inc_return(&peer->usage);
	181	read_unlock_bh(&rxrpc_peer_lock);
	182	goto success;
	183
	184	/* we found the peer on the second time through the list */
	185	found_extant_second:
	186	usage = atomic_inc_return(&peer->usage);
	187	write_unlock_bh(&rxrpc_peer_lock);
	188	kfree(candidate);
	189	goto success;
	190	}
	191
	192	/*
	193	* find the peer associated with a packet
	194	*/
	195	struct rxrpc_peer rxrpc_find_peer(struct rxrpc_local local,
	196	__be32 addr, __be16 port)
	197	{
	198	struct rxrpc_peer *peer;
	199
	200	_enter("");
	201
	202	/* search the peer list */
	203	read_lock_bh(&rxrpc_peer_lock);
	204
	205	if (local->srx.transport.family == AF_INET &&
	206	local->srx.transport_type == SOCK_DGRAM
	207	) {
	208	list_for_each_entry(peer, &rxrpc_peers, link) {
	209	if (atomic_read(&peer->usage) > 0 &&
	210	peer->srx.transport_type == SOCK_DGRAM &&
	211	peer->srx.transport.family == AF_INET &&
	212	peer->srx.transport.sin.sin_port == port &&
	213	peer->srx.transport.sin.sin_addr.s_addr == addr)
	214	goto found_UDP_peer;
	215	}
	216
	217	goto new_UDP_peer;
	218	}
	219
	220	read_unlock_bh(&rxrpc_peer_lock);
	221	_leave(" = -EAFNOSUPPORT");
	222	return ERR_PTR(-EAFNOSUPPORT);
	223
	224	found_UDP_peer:
	225	_net("Rx UDP DGRAM from peer %d", peer->debug_id);
	226	atomic_inc(&peer->usage);
	227	read_unlock_bh(&rxrpc_peer_lock);
	228	_leave(" = %p", peer);
	229	return peer;
	230
	231	new_UDP_peer:
cae296c4	232	_net("Rx UDP DGRAM from NEW peer");
17926a79 DH	233	read_unlock_bh(&rxrpc_peer_lock);
	234	_leave(" = -EBUSY [new]");
	235	return ERR_PTR(-EBUSY);
	236	}
	237
	238	/*
	239	* release a remote transport endpoint
	240	*/
	241	void rxrpc_put_peer(struct rxrpc_peer *peer)
	242	{
	243	_enter("%p{u=%d}", peer, atomic_read(&peer->usage));
	244
	245	ASSERTCMP(atomic_read(&peer->usage), >, 0);
	246
	247	if (likely(!atomic_dec_and_test(&peer->usage))) {
	248	_leave(" [in use]");
	249	return;
	250	}
	251
651350d1	252	rxrpc_queue_work(&peer->destroyer);
17926a79 DH	253	_leave("");
	254	}
	255
	256	/*
	257	* destroy a remote transport endpoint
	258	*/
	259	static void rxrpc_destroy_peer(struct work_struct *work)
	260	{
	261	struct rxrpc_peer *peer =
	262	container_of(work, struct rxrpc_peer, destroyer);
	263
	264	_enter("%p{%d}", peer, atomic_read(&peer->usage));
	265
	266	write_lock_bh(&rxrpc_peer_lock);
	267	list_del(&peer->link);
	268	write_unlock_bh(&rxrpc_peer_lock);
	269
	270	_net("DESTROY PEER %d", peer->debug_id);
	271	kfree(peer);
	272
	273	if (list_empty(&rxrpc_peers))
	274	wake_up_all(&rxrpc_peer_wq);
	275	_leave("");
	276	}
	277
	278	/*
	279	* preemptively destroy all the peer records from a transport endpoint rather
	280	* than waiting for them to time out
	281	*/
	282	void __exit rxrpc_destroy_all_peers(void)
	283	{
	284	DECLARE_WAITQUEUE(myself,current);
	285
	286	_enter("");
	287
	288	/* we simply have to wait for them to go away */
	289	if (!list_empty(&rxrpc_peers)) {
	290	set_current_state(TASK_UNINTERRUPTIBLE);
	291	add_wait_queue(&rxrpc_peer_wq, &myself);
	292
	293	while (!list_empty(&rxrpc_peers)) {
	294	schedule();
	295	set_current_state(TASK_UNINTERRUPTIBLE);
	296	}
	297
	298	remove_wait_queue(&rxrpc_peer_wq, &myself);
	299	set_current_state(TASK_RUNNING);
	300	}
	301
	302	_leave("");
	303	}