2016-04-04 07:00:37 -06:00
|
|
|
/* 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.
|
|
|
|
*/
|
2016-04-04 07:00:40 -06:00
|
|
|
static int rxrpc_get_client_connection_id(struct rxrpc_connection *conn,
|
|
|
|
gfp_t gfp)
|
2016-04-04 07:00:37 -06:00
|
|
|
{
|
|
|
|
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.
|
|
|
|
*/
|
2016-06-30 03:45:22 -06:00
|
|
|
static void rxrpc_put_client_connection_id(struct rxrpc_connection *conn)
|
2016-04-04 07:00:37 -06:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
2016-06-27 03:32:02 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
2016-04-04 07:00:40 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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->out_clientflag = RXRPC_CLIENT_INITIATED;
|
|
|
|
conn->state = RXRPC_CONN_CLIENT;
|
|
|
|
|
|
|
|
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);
|
2016-08-24 00:30:52 -06:00
|
|
|
list_add_tail(&conn->proc_link, &rxrpc_connection_proc_list);
|
2016-04-04 07:00:40 -06:00
|
|
|
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");
|
2016-06-30 03:45:22 -06:00
|
|
|
set_bit(RXRPC_CONN_IN_CLIENT_CONNS, &candidate->flags);
|
|
|
|
rb_link_node(&candidate->client_node, parent, pp);
|
|
|
|
rb_insert_color(&candidate->client_node, &local->client_conns);
|
|
|
|
attached:
|
2016-04-04 07:00:40 -06:00
|
|
|
conn = candidate;
|
|
|
|
candidate = NULL;
|
|
|
|
|
|
|
|
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;
|
2016-08-24 07:31:43 -06:00
|
|
|
call->peer = rxrpc_get_peer(conn->params.peer);
|
2016-04-04 07:00:40 -06:00
|
|
|
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;
|
|
|
|
|
2016-06-30 03:45:22 -06:00
|
|
|
/* We found a potentially suitable connection already in existence. If
|
|
|
|
* we can reuse it (ie. its usage count hasn't been reduced to 0 by the
|
|
|
|
* reaper), discard any candidate we may have allocated, and try to get
|
|
|
|
* a channel on this one, otherwise we have to replace it.
|
2016-04-04 07:00:40 -06:00
|
|
|
*/
|
|
|
|
found_extant_conn:
|
|
|
|
_debug("found conn");
|
2016-06-30 03:45:22 -06:00
|
|
|
if (!rxrpc_get_connection_maybe(conn)) {
|
|
|
|
set_bit(RXRPC_CONN_IN_CLIENT_CONNS, &candidate->flags);
|
|
|
|
rb_replace_node(&conn->client_node,
|
|
|
|
&candidate->client_node,
|
|
|
|
&local->client_conns);
|
|
|
|
clear_bit(RXRPC_CONN_IN_CLIENT_CONNS, &conn->flags);
|
|
|
|
goto attached;
|
|
|
|
}
|
|
|
|
|
2016-04-04 07:00:40 -06:00
|
|
|
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;
|
|
|
|
}
|
2016-06-30 03:45:22 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove a client connection from the local endpoint's tree, thereby removing
|
|
|
|
* it as a target for reuse for new client calls.
|
|
|
|
*/
|
|
|
|
void rxrpc_unpublish_client_conn(struct rxrpc_connection *conn)
|
|
|
|
{
|
|
|
|
struct rxrpc_local *local = conn->params.local;
|
|
|
|
|
|
|
|
spin_lock(&local->client_conns_lock);
|
|
|
|
if (test_and_clear_bit(RXRPC_CONN_IN_CLIENT_CONNS, &conn->flags))
|
|
|
|
rb_erase(&conn->client_node, &local->client_conns);
|
|
|
|
spin_unlock(&local->client_conns_lock);
|
|
|
|
|
|
|
|
rxrpc_put_client_connection_id(conn);
|
|
|
|
}
|