mirror of
https://github.com/torvalds/linux
synced 2024-09-20 02:57:25 +00:00
001c112249
Overhaul the usage count accounting for the rxrpc_connection struct to make
it easier to implement RCU access from the data_ready handler.
The problem is that currently we're using a lock to prevent the garbage
collector from trying to clean up a connection that we're contemplating
unidling. We could just stick incoming packets on the connection we find,
but we've then got a problem that we may race when dispatching a work item
to process it as we need to give that a ref to prevent the rxrpc_connection
struct from disappearing in the meantime.
Further, incoming packets may get discarded if attached to an
rxrpc_connection struct that is going away. Whilst this is not a total
disaster - the client will presumably resend - it would delay processing of
the call. This would affect the AFS client filesystem's service manager
operation.
To this end:
(1) We now maintain an extra count on the connection usage count whilst it
is on the connection list. This mean it is not in use when its
refcount is 1.
(2) When trying to reuse an old connection, we only increment the refcount
if it is greater than 0. If it is 0, we replace it in the tree with a
new candidate connection.
(3) Two connection flags are added to indicate whether or not a connection
is in the local's client connection tree (used by sendmsg) or the
peer's service connection tree (used by data_ready). This makes sure
that we don't try and remove a connection if it got replaced.
The flags are tested under lock with the removal operation to prevent
the reaper from killing the rxrpc_connection struct whilst someone
else is trying to effect a replacement.
This could probably be alleviated by using memory barriers between the
flag set/test and the rb_tree ops. The rb_tree op would still need to
be under the lock, however.
(4) When trying to reap an old connection, we try to flip the usage count
from 1 to 0. If it's not 1 at that point, then it must've come back
to life temporarily and we ignore it.
Signed-off-by: David Howells <dhowells@redhat.com>
181 lines
4.8 KiB
C
181 lines
4.8 KiB
C
/* Service connection 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.
|
|
*/
|
|
|
|
#include <linux/slab.h>
|
|
#include "ar-internal.h"
|
|
|
|
/*
|
|
* get a record of an incoming connection
|
|
*/
|
|
struct rxrpc_connection *rxrpc_incoming_connection(struct rxrpc_local *local,
|
|
struct sockaddr_rxrpc *srx,
|
|
struct sk_buff *skb)
|
|
{
|
|
struct rxrpc_connection *conn, *candidate = NULL;
|
|
struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
|
|
struct rxrpc_peer *peer;
|
|
struct rb_node *p, **pp;
|
|
const char *new = "old";
|
|
u32 epoch, cid;
|
|
|
|
_enter("");
|
|
|
|
peer = rxrpc_lookup_peer(local, srx, GFP_NOIO);
|
|
if (!peer) {
|
|
_debug("no peer");
|
|
return ERR_PTR(-EBUSY);
|
|
}
|
|
|
|
ASSERT(sp->hdr.flags & RXRPC_CLIENT_INITIATED);
|
|
|
|
epoch = sp->hdr.epoch;
|
|
cid = sp->hdr.cid & RXRPC_CIDMASK;
|
|
|
|
/* search the connection list first */
|
|
read_lock_bh(&peer->conn_lock);
|
|
|
|
p = peer->service_conns.rb_node;
|
|
while (p) {
|
|
conn = rb_entry(p, struct rxrpc_connection, service_node);
|
|
|
|
_debug("maybe %x", conn->proto.cid);
|
|
|
|
if (epoch < conn->proto.epoch)
|
|
p = p->rb_left;
|
|
else if (epoch > conn->proto.epoch)
|
|
p = p->rb_right;
|
|
else if (cid < conn->proto.cid)
|
|
p = p->rb_left;
|
|
else if (cid > conn->proto.cid)
|
|
p = p->rb_right;
|
|
else
|
|
goto found_extant_connection;
|
|
}
|
|
read_unlock_bh(&peer->conn_lock);
|
|
|
|
/* not yet present - create a candidate for a new record and then
|
|
* redo the search */
|
|
candidate = rxrpc_alloc_connection(GFP_NOIO);
|
|
if (!candidate) {
|
|
rxrpc_put_peer(peer);
|
|
_leave(" = -ENOMEM");
|
|
return ERR_PTR(-ENOMEM);
|
|
}
|
|
|
|
candidate->proto.local = local;
|
|
candidate->proto.epoch = sp->hdr.epoch;
|
|
candidate->proto.cid = sp->hdr.cid & RXRPC_CIDMASK;
|
|
candidate->proto.in_clientflag = RXRPC_CLIENT_INITIATED;
|
|
candidate->params.local = local;
|
|
candidate->params.peer = peer;
|
|
candidate->params.service_id = sp->hdr.serviceId;
|
|
candidate->security_ix = sp->hdr.securityIndex;
|
|
candidate->out_clientflag = 0;
|
|
candidate->state = RXRPC_CONN_SERVICE;
|
|
if (candidate->params.service_id)
|
|
candidate->state = RXRPC_CONN_SERVICE_UNSECURED;
|
|
|
|
write_lock_bh(&peer->conn_lock);
|
|
|
|
pp = &peer->service_conns.rb_node;
|
|
p = NULL;
|
|
while (*pp) {
|
|
p = *pp;
|
|
conn = rb_entry(p, struct rxrpc_connection, service_node);
|
|
|
|
if (epoch < conn->proto.epoch)
|
|
pp = &(*pp)->rb_left;
|
|
else if (epoch > conn->proto.epoch)
|
|
pp = &(*pp)->rb_right;
|
|
else if (cid < conn->proto.cid)
|
|
pp = &(*pp)->rb_left;
|
|
else if (cid > conn->proto.cid)
|
|
pp = &(*pp)->rb_right;
|
|
else
|
|
goto found_extant_second;
|
|
}
|
|
|
|
/* we can now add the new candidate to the list */
|
|
set_bit(RXRPC_CONN_IN_SERVICE_CONNS, &candidate->flags);
|
|
rb_link_node(&candidate->service_node, p, pp);
|
|
rb_insert_color(&candidate->service_node, &peer->service_conns);
|
|
attached:
|
|
conn = candidate;
|
|
candidate = NULL;
|
|
rxrpc_get_peer(peer);
|
|
rxrpc_get_local(local);
|
|
|
|
write_unlock_bh(&peer->conn_lock);
|
|
|
|
write_lock(&rxrpc_connection_lock);
|
|
list_add_tail(&conn->link, &rxrpc_connections);
|
|
write_unlock(&rxrpc_connection_lock);
|
|
|
|
new = "new";
|
|
|
|
success:
|
|
_net("CONNECTION %s %d {%x}", new, conn->debug_id, conn->proto.cid);
|
|
|
|
rxrpc_put_peer(peer);
|
|
_leave(" = %p {u=%d}", conn, atomic_read(&conn->usage));
|
|
return conn;
|
|
|
|
/* we found the connection in the list immediately */
|
|
found_extant_connection:
|
|
if (!rxrpc_get_connection_maybe(conn)) {
|
|
set_bit(RXRPC_CONN_IN_SERVICE_CONNS, &candidate->flags);
|
|
rb_replace_node(&conn->service_node,
|
|
&candidate->service_node,
|
|
&peer->service_conns);
|
|
clear_bit(RXRPC_CONN_IN_SERVICE_CONNS, &conn->flags);
|
|
goto attached;
|
|
}
|
|
|
|
if (sp->hdr.securityIndex != conn->security_ix) {
|
|
read_unlock_bh(&peer->conn_lock);
|
|
goto security_mismatch_put;
|
|
}
|
|
read_unlock_bh(&peer->conn_lock);
|
|
goto success;
|
|
|
|
/* we found the connection on the second time through the list */
|
|
found_extant_second:
|
|
if (sp->hdr.securityIndex != conn->security_ix) {
|
|
write_unlock_bh(&peer->conn_lock);
|
|
goto security_mismatch;
|
|
}
|
|
rxrpc_get_connection(conn);
|
|
write_unlock_bh(&peer->conn_lock);
|
|
kfree(candidate);
|
|
goto success;
|
|
|
|
security_mismatch_put:
|
|
rxrpc_put_connection(conn);
|
|
security_mismatch:
|
|
kfree(candidate);
|
|
_leave(" = -EKEYREJECTED");
|
|
return ERR_PTR(-EKEYREJECTED);
|
|
}
|
|
|
|
/*
|
|
* Remove the service connection from the peer's tree, thereby removing it as a
|
|
* target for incoming packets.
|
|
*/
|
|
void rxrpc_unpublish_service_conn(struct rxrpc_connection *conn)
|
|
{
|
|
struct rxrpc_peer *peer = conn->params.peer;
|
|
|
|
write_lock_bh(&peer->conn_lock);
|
|
if (test_and_clear_bit(RXRPC_CONN_IN_SERVICE_CONNS, &conn->flags))
|
|
rb_erase(&conn->service_node, &peer->service_conns);
|
|
write_unlock_bh(&peer->conn_lock);
|
|
}
|