- hash-based export handling

[fs/lustre-release.git] / lustre / ptlrpc / connection.c

diff --git a/lustre/ptlrpc/connection.c b/lustre/ptlrpc/connection.c
index 1d2e228..b2e0d85 100644 (file)
--- a/lustre/ptlrpc/connection.c
+++ b/lustre/ptlrpc/connection.c
@@ -33,10 +33,15 @@
 #endif
 
 #include "ptlrpc_internal.h"
+#include <class_hash.h>
 
 static spinlock_t conn_lock;
 static struct list_head conn_list;
 static struct list_head conn_unused_list;
+static struct lustre_class_hash_body *conn_hash_body;
+static struct lustre_class_hash_body *conn_unused_hash_body;
+
+extern struct lustre_hash_operations conn_hash_operations;
 
 void ptlrpc_dump_connections(void)
 {
@@ -58,26 +63,14 @@ struct ptlrpc_connection*
 ptlrpc_lookup_conn_locked (lnet_process_id_t peer)
 {
         struct ptlrpc_connection *c;
-        struct list_head         *tmp;
-
-        list_for_each(tmp, &conn_list) {
-                c = list_entry(tmp, struct ptlrpc_connection, c_link);
-
-                if (peer.nid == c->c_peer.nid &&
-                    peer.pid == c->c_peer.pid)
-                        return ptlrpc_connection_addref(c);
-        }
 
-        list_for_each(tmp, &conn_unused_list) {
-                c = list_entry(tmp, struct ptlrpc_connection, c_link);
+        c = lustre_hash_get_object_by_key(conn_hash_body, &peer);
+        if (c != NULL)
+                return c;
 
-                if (peer.nid == c->c_peer.nid &&
-                    peer.pid == c->c_peer.pid) {
-                        list_del(&c->c_link);
-                        list_add(&c->c_link, &conn_list);
-                        return ptlrpc_connection_addref(c);
-                }
-        }
+        c = lustre_hash_get_object_by_key(conn_unused_hash_body, &peer);
+        if (c != NULL)
+                return c;
 
         return NULL;
 }
@@ -88,6 +81,7 @@ struct ptlrpc_connection *ptlrpc_get_connection(lnet_process_id_t peer,
 {
         struct ptlrpc_connection *c;
         struct ptlrpc_connection *c2;
+        int rc = 0;
         ENTRY;
 
         CDEBUG(D_INFO, "self %s peer %s\n", 
@@ -115,15 +109,26 @@ struct ptlrpc_connection *ptlrpc_get_connection(lnet_process_id_t peer,
         spin_lock(&conn_lock);
 
         c2 = ptlrpc_lookup_conn_locked(peer);
-        if (c2 == NULL)
+        if (c2 == NULL) {
                 list_add(&c->c_link, &conn_list);
-        
+                rc = lustre_hash_additem_unique(conn_hash_body, &peer, 
+                                                &c->c_hash);
+                if (rc != 0) {
+                        list_del(&c->c_link);
+                        CERROR("Cannot add connection to conn_hash_body\n");
+                        goto out_conn;
+                }
+        }
+
+out_conn:
+
         spin_unlock(&conn_lock);
 
-        if (c2 == NULL)
+        if (c2 == NULL && rc == 0)
                 RETURN (c);
-        
-        OBD_FREE(c, sizeof(*c));
+
+        if (c != NULL) 
+                OBD_FREE(c, sizeof(*c));
         RETURN (c2);
 }
 
@@ -141,16 +146,35 @@ int ptlrpc_put_connection(struct ptlrpc_connection *c)
                 c, atomic_read(&c->c_refcount) - 1, 
                 libcfs_nid2str(c->c_peer.nid));
 
-        if (atomic_dec_and_test(&c->c_refcount)) {
+        spin_lock(&conn_lock);
+        LASSERT(!hlist_unhashed(&c->c_hash));
+        spin_unlock(&conn_lock);
+
+        if (atomic_dec_return(&c->c_refcount) == 1) {
+
                 spin_lock(&conn_lock);
+
+                lustre_hash_delitem(conn_hash_body, &c->c_peer, &c->c_hash);
                 list_del(&c->c_link);
+
                 list_add(&c->c_link, &conn_unused_list);
+                rc = lustre_hash_additem_unique(conn_unused_hash_body, &c->c_peer, 
+                                                &c->c_hash);
+                if (rc != 0) {
+                        spin_unlock(&conn_lock);
+                        CERROR("Cannot hash connection to conn_hash_body\n");
+                        GOTO(ret, rc);
+                }
+
                 spin_unlock(&conn_lock);
                 rc = 1;
-        }
+ 
+        } 
+
         if (atomic_read(&c->c_refcount) < 0)
                 CERROR("connection %p refcount %d!\n",
                        c, atomic_read(&c->c_refcount));
+ret :
 
         RETURN(rc);
 }
@@ -165,11 +189,28 @@ struct ptlrpc_connection *ptlrpc_connection_addref(struct ptlrpc_connection *c)
         RETURN(c);
 }
 
-void ptlrpc_init_connection(void)
+int ptlrpc_init_connection(void)
 {
+        int rc = 0;
         CFS_INIT_LIST_HEAD(&conn_list);
+        rc = lustre_hash_init(&conn_hash_body, "CONN_HASH", 
+                              128, &conn_hash_operations);
+        if (rc)
+                GOTO(ret, rc);
+
         CFS_INIT_LIST_HEAD(&conn_unused_list);
+        rc = lustre_hash_init(&conn_unused_hash_body, "CONN_UNUSED_HASH", 
+                              128, &conn_hash_operations);
+        if (rc)
+                GOTO(ret, rc);
+
         spin_lock_init(&conn_lock);
+ret:
+        if (rc) {
+                lustre_hash_exit(&conn_hash_body);
+                lustre_hash_exit(&conn_unused_hash_body);
+        }
+        RETURN(rc);
 }
 
 void ptlrpc_cleanup_connection(void)
@@ -178,11 +219,15 @@ void ptlrpc_cleanup_connection(void)
         struct ptlrpc_connection *c;
 
         spin_lock(&conn_lock);
+
+        lustre_hash_exit(&conn_unused_hash_body);
         list_for_each_safe(tmp, pos, &conn_unused_list) {
                 c = list_entry(tmp, struct ptlrpc_connection, c_link);
                 list_del(&c->c_link);
                 OBD_FREE(c, sizeof(*c));
         }
+
+        lustre_hash_exit(&conn_hash_body);
         list_for_each_safe(tmp, pos, &conn_list) {
                 c = list_entry(tmp, struct ptlrpc_connection, c_link);
                 CERROR("Connection %p/%s has refcount %d (nid=%s)\n",