rxrpc: Kill off the call hash table
authorDavid Howells <dhowells@redhat.com>
Tue, 5 Jul 2016 09:57:10 +0000 (10:57 +0100)
committerDavid Howells <dhowells@redhat.com>
Wed, 6 Jul 2016 10:23:54 +0000 (11:23 +0100)
The call hash table is now no longer used as calls are looked up directly
by channel slot on the connection, so kill it off.

Signed-off-by: David Howells <dhowells@redhat.com>
net/rxrpc/ar-internal.h
net/rxrpc/call_object.c

index e292276c8539f66a99041dc5d3f988df2e7c6303..1bb9e7ac9e14280a8a83dbf002f0bded91a3c5d6 100644 (file)
@@ -461,19 +461,12 @@ struct rxrpc_call {
 #define RXRPC_ACKR_WINDOW_ASZ DIV_ROUND_UP(RXRPC_MAXACKS, BITS_PER_LONG)
        unsigned long           ackr_window[RXRPC_ACKR_WINDOW_ASZ + 1];
 
-       struct hlist_node       hash_node;
-       unsigned long           hash_key;       /* Full hash key */
-       u8                      in_clientflag;  /* Copy of conn->in_clientflag for hashing */
-       struct rxrpc_local      *local;         /* Local endpoint. Used for hashing. */
-       sa_family_t             family;         /* Frame protocol */
+       u8                      in_clientflag;  /* Copy of conn->in_clientflag */
+       struct rxrpc_local      *local;         /* Local endpoint. */
        u32                     call_id;        /* call ID on connection  */
        u32                     cid;            /* connection ID plus channel index */
        u32                     epoch;          /* epoch of this connection */
        u16                     service_id;     /* service ID */
-       union {                                 /* Peer IP address for hashing */
-               __be32  ipv4_addr;
-               __u8    ipv6_addr[16];          /* Anticipates eventual IPv6 support */
-       } peer_ip;
 };
 
 /*
@@ -521,8 +514,6 @@ extern struct kmem_cache *rxrpc_call_jar;
 extern struct list_head rxrpc_calls;
 extern rwlock_t rxrpc_call_lock;
 
-struct rxrpc_call *rxrpc_find_call_hash(struct rxrpc_host_header *,
-                                       void *, sa_family_t, const void *);
 struct rxrpc_call *rxrpc_find_call_by_user_ID(struct rxrpc_sock *, unsigned long);
 struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *,
                                         struct rxrpc_conn_parameters *,
index ebbd7dd5292fb173359cd8928ae5488c8892c2db..91287c9d01bb460c56eda06d3d4e7ceea074f14e 100644 (file)
@@ -14,7 +14,6 @@
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/circ_buf.h>
-#include <linux/hashtable.h>
 #include <linux/spinlock_types.h>
 #include <net/sock.h>
 #include <net/af_rxrpc.h>
@@ -61,142 +60,6 @@ static void rxrpc_dead_call_expired(unsigned long _call);
 static void rxrpc_ack_time_expired(unsigned long _call);
 static void rxrpc_resend_time_expired(unsigned long _call);
 
-static DEFINE_SPINLOCK(rxrpc_call_hash_lock);
-static DEFINE_HASHTABLE(rxrpc_call_hash, 10);
-
-/*
- * Hash function for rxrpc_call_hash
- */
-static unsigned long rxrpc_call_hashfunc(
-       u8              in_clientflag,
-       u32             cid,
-       u32             call_id,
-       u32             epoch,
-       u16             service_id,
-       sa_family_t     family,
-       void            *localptr,
-       unsigned int    addr_size,
-       const u8        *peer_addr)
-{
-       const u16 *p;
-       unsigned int i;
-       unsigned long key;
-
-       _enter("");
-
-       key = (unsigned long)localptr;
-       /* We just want to add up the __be32 values, so forcing the
-        * cast should be okay.
-        */
-       key += epoch;
-       key += service_id;
-       key += call_id;
-       key += (cid & RXRPC_CIDMASK) >> RXRPC_CIDSHIFT;
-       key += cid & RXRPC_CHANNELMASK;
-       key += in_clientflag;
-       key += family;
-       /* Step through the peer address in 16-bit portions for speed */
-       for (i = 0, p = (const u16 *)peer_addr; i < addr_size >> 1; i++, p++)
-               key += *p;
-       _leave(" key = 0x%lx", key);
-       return key;
-}
-
-/*
- * Add a call to the hashtable
- */
-static void rxrpc_call_hash_add(struct rxrpc_call *call)
-{
-       unsigned long key;
-       unsigned int addr_size = 0;
-
-       _enter("");
-       switch (call->family) {
-       case AF_INET:
-               addr_size = sizeof(call->peer_ip.ipv4_addr);
-               break;
-       case AF_INET6:
-               addr_size = sizeof(call->peer_ip.ipv6_addr);
-               break;
-       default:
-               break;
-       }
-       key = rxrpc_call_hashfunc(call->in_clientflag, call->cid,
-                                 call->call_id, call->epoch,
-                                 call->service_id, call->family,
-                                 call->conn->params.local, addr_size,
-                                 call->peer_ip.ipv6_addr);
-       /* Store the full key in the call */
-       call->hash_key = key;
-       spin_lock(&rxrpc_call_hash_lock);
-       hash_add_rcu(rxrpc_call_hash, &call->hash_node, key);
-       spin_unlock(&rxrpc_call_hash_lock);
-       _leave("");
-}
-
-/*
- * Remove a call from the hashtable
- */
-static void rxrpc_call_hash_del(struct rxrpc_call *call)
-{
-       _enter("");
-       spin_lock(&rxrpc_call_hash_lock);
-       hash_del_rcu(&call->hash_node);
-       spin_unlock(&rxrpc_call_hash_lock);
-       _leave("");
-}
-
-/*
- * Find a call in the hashtable and return it, or NULL if it
- * isn't there.
- */
-struct rxrpc_call *rxrpc_find_call_hash(
-       struct rxrpc_host_header *hdr,
-       void            *localptr,
-       sa_family_t     family,
-       const void      *peer_addr)
-{
-       unsigned long key;
-       unsigned int addr_size = 0;
-       struct rxrpc_call *call = NULL;
-       struct rxrpc_call *ret = NULL;
-       u8 in_clientflag = hdr->flags & RXRPC_CLIENT_INITIATED;
-
-       _enter("");
-       switch (family) {
-       case AF_INET:
-               addr_size = sizeof(call->peer_ip.ipv4_addr);
-               break;
-       case AF_INET6:
-               addr_size = sizeof(call->peer_ip.ipv6_addr);
-               break;
-       default:
-               break;
-       }
-
-       key = rxrpc_call_hashfunc(in_clientflag, hdr->cid, hdr->callNumber,
-                                 hdr->epoch, hdr->serviceId,
-                                 family, localptr, addr_size,
-                                 peer_addr);
-       hash_for_each_possible_rcu(rxrpc_call_hash, call, hash_node, key) {
-               if (call->hash_key == key &&
-                   call->call_id == hdr->callNumber &&
-                   call->cid == hdr->cid &&
-                   call->in_clientflag == in_clientflag &&
-                   call->service_id == hdr->serviceId &&
-                   call->family == family &&
-                   call->local == localptr &&
-                   memcmp(call->peer_ip.ipv6_addr, peer_addr,
-                          addr_size) == 0 &&
-                   call->epoch == hdr->epoch) {
-                       ret = call;
-                       break;
-               }
-       }
-       _leave(" = %p", ret);
-       return ret;
-}
-
 /*
  * find an extant server call
  * - called in process context with IRQs enabled
@@ -305,20 +168,7 @@ static struct rxrpc_call *rxrpc_alloc_client_call(struct rxrpc_sock *rx,
        call->socket = rx;
        call->rx_data_post = 1;
 
-       /* Record copies of information for hashtable lookup */
-       call->family = rx->family;
        call->local = rx->local;
-       switch (call->family) {
-       case AF_INET:
-               call->peer_ip.ipv4_addr = srx->transport.sin.sin_addr.s_addr;
-               break;
-       case AF_INET6:
-               memcpy(call->peer_ip.ipv6_addr,
-                      srx->transport.sin6.sin6_addr.in6_u.u6_addr8,
-                      sizeof(call->peer_ip.ipv6_addr));
-               break;
-       }
-
        call->service_id = srx->srx_service;
        call->in_clientflag = 0;
 
@@ -345,9 +195,6 @@ static int rxrpc_begin_client_call(struct rxrpc_call *call,
 
        call->state = RXRPC_CALL_CLIENT_SEND_REQUEST;
 
-       /* Add the new call to the hashtable */
-       rxrpc_call_hash_add(call);
-
        spin_lock(&call->conn->params.peer->lock);
        hlist_add_head(&call->error_link, &call->conn->params.peer->error_targets);
        spin_unlock(&call->conn->params.peer->lock);
@@ -548,27 +395,10 @@ struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *rx,
        list_add_tail(&call->link, &rxrpc_calls);
        write_unlock_bh(&rxrpc_call_lock);
 
-       /* Record copies of information for hashtable lookup */
-       call->family = rx->family;
        call->local = conn->params.local;
-       switch (call->family) {
-       case AF_INET:
-               call->peer_ip.ipv4_addr =
-                       conn->params.peer->srx.transport.sin.sin_addr.s_addr;
-               break;
-       case AF_INET6:
-               memcpy(call->peer_ip.ipv6_addr,
-                      conn->params.peer->srx.transport.sin6.sin6_addr.in6_u.u6_addr8,
-                      sizeof(call->peer_ip.ipv6_addr));
-               break;
-       default:
-               break;
-       }
        call->epoch = conn->proto.epoch;
        call->service_id = conn->params.service_id;
        call->in_clientflag = RXRPC_CLIENT_INITIATED;
-       /* Add the new call to the hashtable */
-       rxrpc_call_hash_add(call);
 
        _net("CALL incoming %d on CONN %d", call->debug_id, call->conn->debug_id);
 
@@ -818,9 +648,6 @@ static void rxrpc_cleanup_call(struct rxrpc_call *call)
 
        ASSERTCMP(call->conn, ==, NULL);
 
-       /* Remove the call from the hash */
-       rxrpc_call_hash_del(call);
-
        if (call->acks_window) {
                _debug("kill Tx window %d",
                       CIRC_CNT(call->acks_head, call->acks_tail,