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

/* Client connection-specific management code.
 *
 * 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/slab.h>
#include <linux/idr.h>
#include <linux/timer.h>
#include "ar-internal.h"

/*
 * We use machine-unique IDs for our client connections.
 */
DEFINE_IDR(rxrpc_client_conn_ids);
static DEFINE_SPINLOCK(rxrpc_conn_id_lock);

/*
 * Get a connection ID and epoch for a client connection from the global pool.
 * The connection struct pointer is then recorded in the idr radix tree.  The
 * epoch is changed if this wraps.
 *
 * TODO: The IDR tree gets very expensive on memory if the connection IDs are
 * widely scattered throughout the number space, so we shall need to retire
 * connections that have, say, an ID more than four times the maximum number of
 * client conns away from the current allocation point to try and keep the IDs
 * concentrated.  We will also need to retire connections from an old epoch.
 */
static int rxrpc_get_client_connection_id(struct rxrpc_connection *conn,
					  gfp_t gfp)
{
	u32 epoch;
	int id;

	_enter("");

	idr_preload(gfp);
	spin_lock(&rxrpc_conn_id_lock);

	epoch = rxrpc_epoch;

	/* We could use idr_alloc_cyclic() here, but we really need to know
	 * when the thing wraps so that we can advance the epoch.
	 */
	if (rxrpc_client_conn_ids.cur == 0)
		rxrpc_client_conn_ids.cur = 1;
	id = idr_alloc(&rxrpc_client_conn_ids, conn,
		       rxrpc_client_conn_ids.cur, 0x40000000, GFP_NOWAIT);
	if (id < 0) {
		if (id != -ENOSPC)
			goto error;
		id = idr_alloc(&rxrpc_client_conn_ids, conn,
			       1, 0x40000000, GFP_NOWAIT);
		if (id < 0)
			goto error;
		epoch++;
		rxrpc_epoch = epoch;
	}
	rxrpc_client_conn_ids.cur = id + 1;

	spin_unlock(&rxrpc_conn_id_lock);
	idr_preload_end();

	conn->proto.epoch = epoch;
	conn->proto.cid = id << RXRPC_CIDSHIFT;
	set_bit(RXRPC_CONN_HAS_IDR, &conn->flags);
	_leave(" [CID %x:%x]", epoch, conn->proto.cid);
	return 0;

error:
	spin_unlock(&rxrpc_conn_id_lock);
	idr_preload_end();
	_leave(" = %d", id);
	return id;
}

/*
 * Release a connection ID for a client connection from the global pool.
 */
void rxrpc_put_client_connection_id(struct rxrpc_connection *conn)
{
	if (test_bit(RXRPC_CONN_HAS_IDR, &conn->flags)) {
		spin_lock(&rxrpc_conn_id_lock);
		idr_remove(&rxrpc_client_conn_ids,
			   conn->proto.cid >> RXRPC_CIDSHIFT);
		spin_unlock(&rxrpc_conn_id_lock);
	}
}

/*
 * Destroy the client connection ID tree.
 */
void rxrpc_destroy_client_conn_ids(void)
{
	struct rxrpc_connection *conn;
	int id;

	if (!idr_is_empty(&rxrpc_client_conn_ids)) {
		idr_for_each_entry(&rxrpc_client_conn_ids, conn, id) {
			pr_err("AF_RXRPC: Leaked client conn %p {%d}\n",
			       conn, atomic_read(&conn->usage));
		}
		BUG();
	}

	idr_destroy(&rxrpc_client_conn_ids);
}

/*
 * Allocate a client connection.  The caller must take care to clear any
 * padding bytes in *cp.
 */
static struct rxrpc_connection *
rxrpc_alloc_client_connection(struct rxrpc_conn_parameters *cp, gfp_t gfp)
{
	struct rxrpc_connection *conn;
	int ret;

	_enter("");

	conn = rxrpc_alloc_connection(gfp);
	if (!conn) {
		_leave(" = -ENOMEM");
		return ERR_PTR(-ENOMEM);
	}

	conn->params		= *cp;
	conn->proto.local	= cp->local;
	conn->proto.epoch	= rxrpc_epoch;
	conn->proto.cid		= 0;
	conn->proto.in_clientflag = 0;
	conn->proto.family	= cp->peer->srx.transport.family;
	conn->out_clientflag	= RXRPC_CLIENT_INITIATED;
	conn->state		= RXRPC_CONN_CLIENT;

	switch (conn->proto.family) {
	case AF_INET:
		conn->proto.addr_size = sizeof(conn->proto.ipv4_addr);
		conn->proto.ipv4_addr = cp->peer->srx.transport.sin.sin_addr;
		conn->proto.port = cp->peer->srx.transport.sin.sin_port;
		break;
	}

	ret = rxrpc_get_client_connection_id(conn, gfp);
	if (ret < 0)
		goto error_0;

	ret = rxrpc_init_client_conn_security(conn);
	if (ret < 0)
		goto error_1;

	ret = conn->security->prime_packet_security(conn);
	if (ret < 0)
		goto error_2;

	write_lock(&rxrpc_connection_lock);
	list_add_tail(&conn->link, &rxrpc_connections);
	write_unlock(&rxrpc_connection_lock);

	/* We steal the caller's peer ref. */
	cp->peer = NULL;
	rxrpc_get_local(conn->params.local);
	key_get(conn->params.key);

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

error_2:
	conn->security->clear(conn);
error_1:
	rxrpc_put_client_connection_id(conn);
error_0:
	kfree(conn);
	_leave(" = %d", ret);
	return ERR_PTR(ret);
}

/*
 * find a connection for a call
 * - called in process context with IRQs enabled
 */
int rxrpc_connect_call(struct rxrpc_call *call,
		       struct rxrpc_conn_parameters *cp,
		       struct sockaddr_rxrpc *srx,
		       gfp_t gfp)
{
	struct rxrpc_connection *conn, *candidate = NULL;
	struct rxrpc_local *local = cp->local;
	struct rb_node *p, **pp, *parent;
	long diff;
	int chan;

	DECLARE_WAITQUEUE(myself, current);

	_enter("{%d,%lx},", call->debug_id, call->user_call_ID);

	cp->peer = rxrpc_lookup_peer(cp->local, srx, gfp);
	if (!cp->peer)
		return -ENOMEM;

	if (!cp->exclusive) {
		/* Search for a existing client connection unless this is going
		 * to be a connection that's used exclusively for a single call.
		 */
		_debug("search 1");
		spin_lock(&local->client_conns_lock);
		p = local->client_conns.rb_node;
		while (p) {
			conn = rb_entry(p, struct rxrpc_connection, client_node);

#define cmp(X) ((long)conn->params.X - (long)cp->X)
			diff = (cmp(peer) ?:
				cmp(key) ?:
				cmp(security_level));
			if (diff < 0)
				p = p->rb_left;
			else if (diff > 0)
				p = p->rb_right;
			else
				goto found_extant_conn;
		}
		spin_unlock(&local->client_conns_lock);
	}

	/* We didn't find a connection or we want an exclusive one. */
	_debug("get new conn");
	candidate = rxrpc_alloc_client_connection(cp, gfp);
	if (!candidate) {
		_leave(" = -ENOMEM");
		return -ENOMEM;
	}

	if (cp->exclusive) {
		/* Assign the call on an exclusive connection to channel 0 and
		 * don't add the connection to the endpoint's shareable conn
		 * lookup tree.
		 */
		_debug("exclusive chan 0");
		conn = candidate;
		atomic_set(&conn->avail_chans, RXRPC_MAXCALLS - 1);
		spin_lock(&conn->channel_lock);
		chan = 0;
		goto found_channel;
	}

	/* We need to redo the search before attempting to add a new connection
	 * lest we race with someone else adding a conflicting instance.
	 */
	_debug("search 2");
	spin_lock(&local->client_conns_lock);

	pp = &local->client_conns.rb_node;
	parent = NULL;
	while (*pp) {
		parent = *pp;
		conn = rb_entry(parent, struct rxrpc_connection, client_node);

		diff = (cmp(peer) ?:
			cmp(key) ?:
			cmp(security_level));
		if (diff < 0)
			pp = &(*pp)->rb_left;
		else if (diff > 0)
			pp = &(*pp)->rb_right;
		else
			goto found_extant_conn;
	}

	/* The second search also failed; simply add the new connection with
	 * the new call in channel 0.  Note that we need to take the channel
	 * lock before dropping the client conn lock.
	 */
	_debug("new conn");
	conn = candidate;
	candidate = NULL;

	rb_link_node(&conn->client_node, parent, pp);
	rb_insert_color(&conn->client_node, &local->client_conns);

	atomic_set(&conn->avail_chans, RXRPC_MAXCALLS - 1);
	spin_lock(&conn->channel_lock);
	spin_unlock(&local->client_conns_lock);
	chan = 0;

found_channel:
	_debug("found chan");
	call->conn	= conn;
	call->channel	= chan;
	call->epoch	= conn->proto.epoch;
	call->cid	= conn->proto.cid | chan;
	call->call_id	= ++conn->channels[chan].call_counter;
	conn->channels[chan].call_id = call->call_id;
	rcu_assign_pointer(conn->channels[chan].call, call);

	_net("CONNECT call %d on conn %d", call->debug_id, conn->debug_id);

	spin_unlock(&conn->channel_lock);
	rxrpc_put_peer(cp->peer);
	cp->peer = NULL;
	_leave(" = %p {u=%d}", conn, atomic_read(&conn->usage));
	return 0;

	/* We found a suitable connection already in existence.  Discard any
	 * candidate we may have allocated, and try to get a channel on this
	 * one.
	 */
found_extant_conn:
	_debug("found conn");
	rxrpc_get_connection(conn);
	spin_unlock(&local->client_conns_lock);

	rxrpc_put_connection(candidate);

	if (!atomic_add_unless(&conn->avail_chans, -1, 0)) {
		if (!gfpflags_allow_blocking(gfp)) {
			rxrpc_put_connection(conn);
			_leave(" = -EAGAIN");
			return -EAGAIN;
		}

		add_wait_queue(&conn->channel_wq, &myself);
		for (;;) {
			set_current_state(TASK_INTERRUPTIBLE);
			if (atomic_add_unless(&conn->avail_chans, -1, 0))
				break;
			if (signal_pending(current))
				goto interrupted;
			schedule();
		}
		remove_wait_queue(&conn->channel_wq, &myself);
		__set_current_state(TASK_RUNNING);
	}

	/* The connection allegedly now has a free channel and we can now
	 * attach the call to it.
	 */
	spin_lock(&conn->channel_lock);

	for (chan = 0; chan < RXRPC_MAXCALLS; chan++)
		if (!conn->channels[chan].call)
			goto found_channel;
	BUG();

interrupted:
	remove_wait_queue(&conn->channel_wq, &myself);
	__set_current_state(TASK_RUNNING);
	rxrpc_put_connection(conn);
	rxrpc_put_peer(cp->peer);
	cp->peer = NULL;
	_leave(" = -ERESTARTSYS");
	return -ERESTARTSYS;
}
Commit	Line	Data
4a3388c8 DH	1	/* Client connection-specific management code.
	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/slab.h>
	15	#include <linux/idr.h>
	16	#include <linux/timer.h>
	17	#include "ar-internal.h"
	18
	19	/*
	20	* We use machine-unique IDs for our client connections.
	21	*/
	22	DEFINE_IDR(rxrpc_client_conn_ids);
	23	static DEFINE_SPINLOCK(rxrpc_conn_id_lock);
	24
	25	/*
	26	* Get a connection ID and epoch for a client connection from the global pool.
	27	* The connection struct pointer is then recorded in the idr radix tree. The
	28	* epoch is changed if this wraps.
	29	*
	30	* TODO: The IDR tree gets very expensive on memory if the connection IDs are
	31	* widely scattered throughout the number space, so we shall need to retire
	32	* connections that have, say, an ID more than four times the maximum number of
	33	* client conns away from the current allocation point to try and keep the IDs
	34	* concentrated. We will also need to retire connections from an old epoch.
	35	*/
c6d2b8d7 DH	36	static int rxrpc_get_client_connection_id(struct rxrpc_connection *conn,
c6d2b8d7 DH	37	gfp_t gfp)
4a3388c8 DH	38	{
	39	u32 epoch;
	40	int id;
	41
	42	_enter("");
	43
	44	idr_preload(gfp);
4a3388c8 DH	45	spin_lock(&rxrpc_conn_id_lock);
	46
	47	epoch = rxrpc_epoch;
	48
	49	/* We could use idr_alloc_cyclic() here, but we really need to know
	50	* when the thing wraps so that we can advance the epoch.
	51	*/
	52	if (rxrpc_client_conn_ids.cur == 0)
	53	rxrpc_client_conn_ids.cur = 1;
	54	id = idr_alloc(&rxrpc_client_conn_ids, conn,
	55	rxrpc_client_conn_ids.cur, 0x40000000, GFP_NOWAIT);
	56	if (id < 0) {
	57	if (id != -ENOSPC)
	58	goto error;
	59	id = idr_alloc(&rxrpc_client_conn_ids, conn,
	60	1, 0x40000000, GFP_NOWAIT);
	61	if (id < 0)
	62	goto error;
	63	epoch++;
	64	rxrpc_epoch = epoch;
	65	}
	66	rxrpc_client_conn_ids.cur = id + 1;
	67
	68	spin_unlock(&rxrpc_conn_id_lock);
4a3388c8 DH	69	idr_preload_end();
	70
	71	conn->proto.epoch = epoch;
	72	conn->proto.cid = id << RXRPC_CIDSHIFT;
	73	set_bit(RXRPC_CONN_HAS_IDR, &conn->flags);
	74	_leave(" [CID %x:%x]", epoch, conn->proto.cid);
	75	return 0;
	76
	77	error:
	78	spin_unlock(&rxrpc_conn_id_lock);
4a3388c8 DH	79	idr_preload_end();
	80	_leave(" = %d", id);
	81	return id;
	82	}
	83
	84	/*
	85	* Release a connection ID for a client connection from the global pool.
	86	*/
	87	void rxrpc_put_client_connection_id(struct rxrpc_connection *conn)
	88	{
	89	if (test_bit(RXRPC_CONN_HAS_IDR, &conn->flags)) {
	90	spin_lock(&rxrpc_conn_id_lock);
	91	idr_remove(&rxrpc_client_conn_ids,
	92	conn->proto.cid >> RXRPC_CIDSHIFT);
	93	spin_unlock(&rxrpc_conn_id_lock);
	94	}
	95	}
eb9b9d22 DH	96
	97	/*
	98	* Destroy the client connection ID tree.
	99	*/
	100	void rxrpc_destroy_client_conn_ids(void)
	101	{
	102	struct rxrpc_connection *conn;
	103	int id;
	104
	105	if (!idr_is_empty(&rxrpc_client_conn_ids)) {
	106	idr_for_each_entry(&rxrpc_client_conn_ids, conn, id) {
	107	pr_err("AF_RXRPC: Leaked client conn %p {%d}\n",
	108	conn, atomic_read(&conn->usage));
	109	}
	110	BUG();
	111	}
	112
	113	idr_destroy(&rxrpc_client_conn_ids);
	114	}
c6d2b8d7 DH	115
	116	/*
	117	* Allocate a client connection. The caller must take care to clear any
	118	* padding bytes in *cp.
	119	*/
	120	static struct rxrpc_connection *
	121	rxrpc_alloc_client_connection(struct rxrpc_conn_parameters *cp, gfp_t gfp)
	122	{
	123	struct rxrpc_connection *conn;
	124	int ret;
	125
	126	_enter("");
	127
	128	conn = rxrpc_alloc_connection(gfp);
	129	if (!conn) {
	130	_leave(" = -ENOMEM");
	131	return ERR_PTR(-ENOMEM);
	132	}
	133
	134	conn->params = *cp;
	135	conn->proto.local = cp->local;
	136	conn->proto.epoch = rxrpc_epoch;
	137	conn->proto.cid = 0;
	138	conn->proto.in_clientflag = 0;
	139	conn->proto.family = cp->peer->srx.transport.family;
	140	conn->out_clientflag = RXRPC_CLIENT_INITIATED;
	141	conn->state = RXRPC_CONN_CLIENT;
	142
	143	switch (conn->proto.family) {
	144	case AF_INET:
	145	conn->proto.addr_size = sizeof(conn->proto.ipv4_addr);
	146	conn->proto.ipv4_addr = cp->peer->srx.transport.sin.sin_addr;
	147	conn->proto.port = cp->peer->srx.transport.sin.sin_port;
	148	break;
	149	}
	150
	151	ret = rxrpc_get_client_connection_id(conn, gfp);
	152	if (ret < 0)
	153	goto error_0;
	154
	155	ret = rxrpc_init_client_conn_security(conn);
	156	if (ret < 0)
	157	goto error_1;
	158
	159	ret = conn->security->prime_packet_security(conn);
	160	if (ret < 0)
	161	goto error_2;
	162
	163	write_lock(&rxrpc_connection_lock);
	164	list_add_tail(&conn->link, &rxrpc_connections);
	165	write_unlock(&rxrpc_connection_lock);
	166
	167	/* We steal the caller's peer ref. */
	168	cp->peer = NULL;
	169	rxrpc_get_local(conn->params.local);
	170	key_get(conn->params.key);
	171
	172	_leave(" = %p", conn);
	173	return conn;
	174
	175	error_2:
	176	conn->security->clear(conn);
	177	error_1:
	178	rxrpc_put_client_connection_id(conn);
179	error_0:
180	kfree(conn);
181	_leave(" = %d", ret);
182	return ERR_PTR(ret);
183	}
184
185	/*
186	* find a connection for a call
187	* - called in process context with IRQs enabled
188	*/
189	int rxrpc_connect_call(struct rxrpc_call *call,
190	struct rxrpc_conn_parameters *cp,
191	struct sockaddr_rxrpc *srx,
192	gfp_t gfp)
193	{
194	struct rxrpc_connection conn, candidate = NULL;
195	struct rxrpc_local *local = cp->local;
196	struct rb_node p, pp, parent;
197	long diff;
198	int chan;
199
200	DECLARE_WAITQUEUE(myself, current);
201
202	_enter("{%d,%lx},", call->debug_id, call->user_call_ID);
203
204	cp->peer = rxrpc_lookup_peer(cp->local, srx, gfp);
205	if (!cp->peer)
206	return -ENOMEM;
207
208	if (!cp->exclusive) {
209	/* Search for a existing client connection unless this is going
210	* to be a connection that's used exclusively for a single call.
211	*/
212	_debug("search 1");
213	spin_lock(&local->client_conns_lock);
214	p = local->client_conns.rb_node;
215	while (p) {
216	conn = rb_entry(p, struct rxrpc_connection, client_node);
217
218	#define cmp(X) ((long)conn->params.X - (long)cp->X)
219	diff = (cmp(peer) ?:
220	cmp(key) ?:
221	cmp(security_level));
222	if (diff < 0)
223	p = p->rb_left;
224	else if (diff > 0)
225	p = p->rb_right;
226	else
227	goto found_extant_conn;
228	}
229	spin_unlock(&local->client_conns_lock);
230	}
231
232	/* We didn't find a connection or we want an exclusive one. */
233	_debug("get new conn");
234	candidate = rxrpc_alloc_client_connection(cp, gfp);
235	if (!candidate) {
236	_leave(" = -ENOMEM");
237	return -ENOMEM;
238	}
239
240	if (cp->exclusive) {
241	/* Assign the call on an exclusive connection to channel 0 and
242	* don't add the connection to the endpoint's shareable conn
243	* lookup tree.
244	*/
245	_debug("exclusive chan 0");
246	conn = candidate;
247	atomic_set(&conn->avail_chans, RXRPC_MAXCALLS - 1);
248	spin_lock(&conn->channel_lock);
249	chan = 0;
250	goto found_channel;
251	}
252
253	/* We need to redo the search before attempting to add a new connection
254	* lest we race with someone else adding a conflicting instance.
255	*/
256	_debug("search 2");
257	spin_lock(&local->client_conns_lock);
258
259	pp = &local->client_conns.rb_node;
260	parent = NULL;
261	while (*pp) {
262	parent = *pp;
263	conn = rb_entry(parent, struct rxrpc_connection, client_node);
264
265	diff = (cmp(peer) ?:
266	cmp(key) ?:
267	cmp(security_level));
268	if (diff < 0)
269	pp = &(*pp)->rb_left;
270	else if (diff > 0)
271	pp = &(*pp)->rb_right;
272	else
273	goto found_extant_conn;
274	}
275
276	/* The second search also failed; simply add the new connection with
277	* the new call in channel 0. Note that we need to take the channel
278	* lock before dropping the client conn lock.
279	*/
280	_debug("new conn");
281	conn = candidate;
282	candidate = NULL;
283
284	rb_link_node(&conn->client_node, parent, pp);
285	rb_insert_color(&conn->client_node, &local->client_conns);
286
287	atomic_set(&conn->avail_chans, RXRPC_MAXCALLS - 1);
288	spin_lock(&conn->channel_lock);
289	spin_unlock(&local->client_conns_lock);
290	chan = 0;
291
292	found_channel:
293	_debug("found chan");
294	call->conn = conn;
295	call->channel = chan;
296	call->epoch = conn->proto.epoch;
297	call->cid = conn->proto.cid \| chan;
298	call->call_id = ++conn->channels[chan].call_counter;
299	conn->channels[chan].call_id = call->call_id;
300	rcu_assign_pointer(conn->channels[chan].call, call);
301
302	_net("CONNECT call %d on conn %d", call->debug_id, conn->debug_id);
303
304	spin_unlock(&conn->channel_lock);
305	rxrpc_put_peer(cp->peer);
306	cp->peer = NULL;
307	_leave(" = %p {u=%d}", conn, atomic_read(&conn->usage));
308	return 0;
309
310	/* We found a suitable connection already in existence. Discard any
311	* candidate we may have allocated, and try to get a channel on this
312	* one.
313	*/
314	found_extant_conn:
315	_debug("found conn");
316	rxrpc_get_connection(conn);
317	spin_unlock(&local->client_conns_lock);
318
319	rxrpc_put_connection(candidate);
320
321	if (!atomic_add_unless(&conn->avail_chans, -1, 0)) {
322	if (!gfpflags_allow_blocking(gfp)) {
323	rxrpc_put_connection(conn);
324	_leave(" = -EAGAIN");
325	return -EAGAIN;
326	}
327
328	add_wait_queue(&conn->channel_wq, &myself);
329	for (;;) {
330	set_current_state(TASK_INTERRUPTIBLE);
331	if (atomic_add_unless(&conn->avail_chans, -1, 0))
332	break;
333	if (signal_pending(current))
334	goto interrupted;
335	schedule();
336	}
337	remove_wait_queue(&conn->channel_wq, &myself);
338	__set_current_state(TASK_RUNNING);
339	}
340
341	/* The connection allegedly now has a free channel and we can now
342	* attach the call to it.
343	*/
344	spin_lock(&conn->channel_lock);
345
346	for (chan = 0; chan < RXRPC_MAXCALLS; chan++)
347	if (!conn->channels[chan].call)
348	goto found_channel;
349	BUG();
350
351	interrupted:
352	remove_wait_queue(&conn->channel_wq, &myself);
353	__set_current_state(TASK_RUNNING);
354	rxrpc_put_connection(conn);
355	rxrpc_put_peer(cp->peer);
356	cp->peer = NULL;
357	_leave(" = -ERESTARTSYS");
358	return -ERESTARTSYS;
359	}