X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fptlrpc%2Fconnection.c;h=62db6aabd369e0d01f6f39d8e98c55c142e0c045;hp=a41b2021d6ea3ed7eb6172503f8c100d0df828b7;hb=37b29a8f709aa4bd2e22cbb3549257b28cd85610;hpb=6e3ec5812ebd1b5ecf7cae584f429b013ffe7431

diff --git a/lustre/ptlrpc/connection.c b/lustre/ptlrpc/connection.c
index a41b202..62db6aa 100644
--- a/lustre/ptlrpc/connection.c
+++ b/lustre/ptlrpc/connection.c
@@ -1,6 +1,4 @@
-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
+/*
  * GPL HEADER START
  *
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
@@ -17,17 +15,15 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
 /*
- * Copyright  2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
+ *
+ * Copyright (c) 2011, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -35,204 +31,178 @@
  */
 
 #define DEBUG_SUBSYSTEM S_RPC
-#ifdef __KERNEL__
+
+#include <linux/delay.h>
+#include <libcfs/linux/linux-hash.h>
 #include <obd_support.h>
 #include <obd_class.h>
 #include <lustre_net.h>
-#else
-#include <liblustre.h>
-#endif
 
 #include "ptlrpc_internal.h"
 
-static cfs_hash_t *conn_hash = NULL;
-static cfs_hash_ops_t conn_hash_ops;
+static struct rhashtable conn_hash;
 
-struct ptlrpc_connection *
-ptlrpc_connection_get(lnet_process_id_t peer, lnet_nid_t self,
-                      struct obd_uuid *uuid)
-{
-        struct ptlrpc_connection *conn, *conn2;
-        ENTRY;
-
-        conn = cfs_hash_lookup(conn_hash, &peer);
-        if (conn)
-                GOTO(out, conn);
-
-        OBD_ALLOC_PTR(conn);
-        if (!conn)
-                RETURN(NULL);
-
-        conn->c_peer = peer;
-        conn->c_self = self;
-        CFS_INIT_HLIST_NODE(&conn->c_hash);
-        cfs_atomic_set(&conn->c_refcount, 1);
-        if (uuid)
-                obd_str2uuid(&conn->c_remote_uuid, uuid->uuid);
-
-        /*
-         * Add the newly created conn to the hash, on key collision we
-         * lost a racing addition and must destroy our newly allocated
-         * connection.  The object which exists in the has will be
-         * returned and may be compared against out object.
-         */
-        conn2 = cfs_hash_findadd_unique(conn_hash, &peer, &conn->c_hash);
-        if (conn != conn2) {
-                OBD_FREE_PTR(conn);
-                conn = conn2;
-        }
-        EXIT;
-out:
-        CDEBUG(D_INFO, "conn=%p refcount %d to %s\n",
-               conn, cfs_atomic_read(&conn->c_refcount),
-               libcfs_nid2str(conn->c_peer.nid));
-        return conn;
-}
-
-int ptlrpc_connection_put(struct ptlrpc_connection *conn)
-{
-        int rc = 0;
-        ENTRY;
-
-        if (!conn)
-                RETURN(rc);
-
-        LASSERT(!cfs_hlist_unhashed(&conn->c_hash));
-
-        /*
-         * We do not remove connection from hashtable and
-         * do not free it even if last caller released ref,
-         * as we want to have it cached for the case it is
-         * needed again.
-         *
-         * Deallocating it and later creating new connection
-         * again would be wastful. This way we also avoid
-         * expensive locking to protect things from get/put
-         * race when found cached connection is freed by
-         * ptlrpc_connection_put().
-         *
-         * It will be freed later in module unload time,
-         * when ptlrpc_connection_fini()->lh_exit->conn_exit()
-         * path is called.
-         */
-        if (cfs_atomic_dec_return(&conn->c_refcount) == 1)
-                rc = 1;
-
-        CDEBUG(D_INFO, "PUT conn=%p refcount %d to %s\n",
-               conn, cfs_atomic_read(&conn->c_refcount),
-               libcfs_nid2str(conn->c_peer.nid));
-
-        RETURN(rc);
-}
+/*
+ * struct lnet_process_id may contain unassigned bytes which might not
+ * be zero, so we cannot just hash and compare bytes.
+ */
 
-struct ptlrpc_connection *
-ptlrpc_connection_addref(struct ptlrpc_connection *conn)
+static u32 lnet_process_id_hash(const void *data, u32 len, u32 seed)
 {
-        ENTRY;
-
-        cfs_atomic_inc(&conn->c_refcount);
-        CDEBUG(D_INFO, "conn=%p refcount %d to %s\n",
-               conn, cfs_atomic_read(&conn->c_refcount),
-               libcfs_nid2str(conn->c_peer.nid));
+	const struct lnet_process_id *lpi = data;
 
-        RETURN(conn);
+	seed = cfs_hash_32(seed ^ lpi->pid, 32);
+	seed ^= cfs_hash_64(lpi->nid, 32);
+	return seed;
 }
 
-int ptlrpc_connection_init(void)
+static int lnet_process_id_cmp(struct rhashtable_compare_arg *arg,
+			       const void *obj)
 {
-        ENTRY;
-
-        conn_hash = cfs_hash_create("CONN_HASH",
-                                    HASH_CONN_CUR_BITS,
-                                    HASH_CONN_MAX_BITS,
-                                    &conn_hash_ops, CFS_HASH_REHASH);
-        if (!conn_hash)
-                RETURN(-ENOMEM);
-
-        RETURN(0);
-}
+	const struct lnet_process_id *lpi = arg->key;
+	const struct ptlrpc_connection *con = obj;
 
-void ptlrpc_connection_fini(void) {
-        ENTRY;
-        cfs_hash_destroy(conn_hash);
-        EXIT;
+	if (lpi->nid == con->c_peer.nid &&
+	    lpi->pid == con->c_peer.pid)
+		return 0;
+	return -ESRCH;
 }
 
-/*
- * Hash operations for net_peer<->connection
- */
-static unsigned
-conn_hashfn(cfs_hash_t *hs,  void *key, unsigned mask)
-{
-        return cfs_hash_djb2_hash(key, sizeof(lnet_process_id_t), mask);
-}
+static const struct rhashtable_params conn_hash_params = {
+	.key_len	= 1,	/* actually variable-length */
+	.key_offset	= offsetof(struct ptlrpc_connection, c_peer),
+	.head_offset	= offsetof(struct ptlrpc_connection, c_hash),
+	.hashfn		= lnet_process_id_hash,
+	.obj_cmpfn	= lnet_process_id_cmp,
+};
 
-static int
-conn_compare(void *key, cfs_hlist_node_t *hnode)
+struct ptlrpc_connection *
+ptlrpc_connection_get(struct lnet_process_id peer, lnet_nid_t self,
+		      struct obd_uuid *uuid)
 {
-        struct ptlrpc_connection *conn;
-        lnet_process_id_t *conn_key;
-
-        LASSERT(key != NULL);
-        conn_key = (lnet_process_id_t*)key;
-        conn = cfs_hlist_entry(hnode, struct ptlrpc_connection, c_hash);
-
-        return conn_key->nid == conn->c_peer.nid &&
-               conn_key->pid == conn->c_peer.pid;
+	struct ptlrpc_connection *conn, *conn2;
+	ENTRY;
+
+	peer.nid = LNetPrimaryNID(peer.nid);
+	conn = rhashtable_lookup_fast(&conn_hash, &peer, conn_hash_params);
+	if (conn) {
+		ptlrpc_connection_addref(conn);
+		GOTO(out, conn);
+	}
+
+	OBD_ALLOC_PTR(conn);
+	if (!conn)
+		RETURN(NULL);
+
+	conn->c_peer = peer;
+	conn->c_self = self;
+	atomic_set(&conn->c_refcount, 1);
+	if (uuid)
+		obd_str2uuid(&conn->c_remote_uuid, uuid->uuid);
+
+	/*
+	 * Add the newly created conn to the hash, on key collision we
+	 * lost a racing addition and must destroy our newly allocated
+	 * connection.	The object which exists in the hash will be
+	 * returned,otherwise NULL is returned on success.
+	 */
+try_again:
+	conn2 = rhashtable_lookup_get_insert_fast(&conn_hash, &conn->c_hash,
+						  conn_hash_params);
+	if (conn2) {
+		/* insertion failed */
+		OBD_FREE_PTR(conn);
+		if (IS_ERR(conn2)) {
+			/* hash table could be resizing. */
+			if (PTR_ERR(conn2) == -ENOMEM ||
+			    PTR_ERR(conn2) == -EBUSY) {
+				msleep(5);
+				goto try_again;
+			}
+			return NULL;
+		}
+		conn = conn2;
+		ptlrpc_connection_addref(conn);
+	}
+	EXIT;
+out:
+	CDEBUG(D_INFO, "conn=%p refcount %d to %s\n",
+	       conn, atomic_read(&conn->c_refcount),
+	       libcfs_nid2str(conn->c_peer.nid));
+	return conn;
 }
 
-static void *
-conn_key(cfs_hlist_node_t *hnode)
+int ptlrpc_connection_put(struct ptlrpc_connection *conn)
 {
-        struct ptlrpc_connection *conn;
-        conn = cfs_hlist_entry(hnode, struct ptlrpc_connection, c_hash);
-        return &conn->c_peer;
+	int rc = 0;
+	ENTRY;
+
+	if (!conn)
+		RETURN(rc);
+
+	LASSERT(atomic_read(&conn->c_refcount) > 0);
+
+	/*
+	 * We do not remove connection from hashtable and
+	 * do not free it even if last caller released ref,
+	 * as we want to have it cached for the case it is
+	 * needed again.
+	 *
+	 * Deallocating it and later creating new connection
+	 * again would be wastful. This way we also avoid
+	 * expensive locking to protect things from get/put
+	 * race when found cached connection is freed by
+	 * ptlrpc_connection_put().
+	 *
+	 * It will be freed later in module unload time,
+	 * when ptlrpc_connection_fini()->lh_exit->conn_exit()
+	 * path is called.
+	 */
+	if (atomic_dec_return(&conn->c_refcount) == 0)
+		rc = 1;
+
+	CDEBUG(D_INFO, "PUT conn=%p refcount %d to %s\n",
+	       conn, atomic_read(&conn->c_refcount),
+	       libcfs_nid2str(conn->c_peer.nid));
+
+	RETURN(rc);
 }
 
-static void *
-conn_get(cfs_hlist_node_t *hnode)
+struct ptlrpc_connection *
+ptlrpc_connection_addref(struct ptlrpc_connection *conn)
 {
-        struct ptlrpc_connection *conn;
+	ENTRY;
 
-        conn = cfs_hlist_entry(hnode, struct ptlrpc_connection, c_hash);
-        cfs_atomic_inc(&conn->c_refcount);
+	atomic_inc(&conn->c_refcount);
+	CDEBUG(D_INFO, "conn=%p refcount %d to %s\n",
+	       conn, atomic_read(&conn->c_refcount),
+	       libcfs_nid2str(conn->c_peer.nid));
 
-        return conn;
+	RETURN(conn);
 }
 
-static void *
-conn_put(cfs_hlist_node_t *hnode)
+static void
+conn_exit(void *vconn, void *data)
 {
-        struct ptlrpc_connection *conn;
-
-        conn = cfs_hlist_entry(hnode, struct ptlrpc_connection, c_hash);
-        cfs_atomic_dec(&conn->c_refcount);
-
-        return conn;
+	struct ptlrpc_connection *conn = vconn;
+
+	/*
+	 * Nothing should be left. Connection user put it and
+	 * connection also was deleted from table by this time
+	 * so we should have 0 refs.
+	 */
+	LASSERTF(atomic_read(&conn->c_refcount) == 0,
+		 "Busy connection with %d refs\n",
+		 atomic_read(&conn->c_refcount));
+	OBD_FREE_PTR(conn);
 }
 
-static void
-conn_exit(cfs_hlist_node_t *hnode)
+int ptlrpc_connection_init(void)
 {
-        struct ptlrpc_connection *conn;
-
-        conn = cfs_hlist_entry(hnode, struct ptlrpc_connection, c_hash);
-        /*
-         * Nothing should be left. Connection user put it and
-         * connection also was deleted from table by this time
-         * so we should have 0 refs.
-         */
-        LASSERTF(cfs_atomic_read(&conn->c_refcount) == 0,
-                 "Busy connection with %d refs\n",
-                 cfs_atomic_read(&conn->c_refcount));
-        OBD_FREE_PTR(conn);
+	return rhashtable_init(&conn_hash, &conn_hash_params);
 }
 
-static cfs_hash_ops_t conn_hash_ops = {
-        .hs_hash    = conn_hashfn,
-        .hs_compare = conn_compare,
-        .hs_key     = conn_key,
-        .hs_get     = conn_get,
-        .hs_put     = conn_put,
-        .hs_exit    = conn_exit,
-};
+void ptlrpc_connection_fini(void)
+{
+	rhashtable_free_and_destroy(&conn_hash, conn_exit, NULL);
+}