LU-570: Add function to find connect uuid by nid

In this patch, two functions are added:
- class_find_uuid(), find conn uuid by peer nid
- client_import_find_conn(), find a conn uuid in import connection list

Also, a code cleanup is performed.

Change-Id: I50e8e9392a39ef78719504cf083c0c22f5d39dcb
Signed-off-by: Jinshan Xiong <jay@whamcloud.com>
Reviewed-on: http://review.whamcloud.com/1189
Tested-by: Hudson
Tested-by: Maloo <whamcloud.maloo@gmail.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/lustre/include/lustre/lustre_user.h b/lustre/include/lustre/lustre_user.h
index d6f7e88..d6d304f 100644 (file)
--- a/lustre/include/lustre/lustre_user.h
+++ b/lustre/include/lustre/lustre_user.h
@@ -248,8 +248,9 @@ struct ll_fid {
                            * OST for saving into EA. */
 };
 
+#define UUID_MAX        40
 struct obd_uuid {
-        char uuid[40];
+        char uuid[UUID_MAX];
 };
 
 static inline int obd_uuid_equals(const struct obd_uuid *u1,

diff --git a/lustre/include/lustre_net.h b/lustre/include/lustre_net.h
index d9d52d0..3bd7caf 100644 (file)
--- a/lustre/include/lustre_net.h
+++ b/lustre/include/lustre_net.h
@@ -1788,6 +1788,8 @@ int client_disconnect_export(struct obd_export *exp);
 int client_import_add_conn(struct obd_import *imp, struct obd_uuid *uuid,
                            int priority);
 int client_import_del_conn(struct obd_import *imp, struct obd_uuid *uuid);
+int client_import_find_conn(struct obd_import *imp, lnet_nid_t peer,
+                            struct obd_uuid *uuid);
 int import_set_conn_priority(struct obd_import *imp, struct obd_uuid *uuid);
 void client_destroy_import(struct obd_import *imp);
 /** @} */

diff --git a/lustre/include/obd_class.h b/lustre/include/obd_class.h
index df7cd84..257ab2b 100644 (file)
--- a/lustre/include/obd_class.h
+++ b/lustre/include/obd_class.h
@@ -2280,6 +2280,7 @@ void class_uuid_unparse(class_uuid_t in, struct obd_uuid *out);
 int lustre_uuid_to_peer(const char *uuid, lnet_nid_t *peer_nid, int index);
 int class_add_uuid(const char *uuid, __u64 nid);
 int class_del_uuid (const char *uuid);
+int class_check_uuid(struct obd_uuid *uuid, __u64 nid);
 void class_init_uuidlist(void);
 void class_exit_uuidlist(void);
 

diff --git a/lustre/ldlm/ldlm_lib.c b/lustre/ldlm/ldlm_lib.c
index db02383..a8af509 100644 (file)
--- a/lustre/ldlm/ldlm_lib.c
+++ b/lustre/ldlm/ldlm_lib.c
@@ -193,6 +193,31 @@ out:
         RETURN(rc);
 }
 
+/**
+ * Find conn uuid by peer nid. @peer is a server nid. This function is used
+ * to find a conn uuid of @imp which can reach @peer.
+ */
+int client_import_find_conn(struct obd_import *imp, lnet_nid_t peer,
+                            struct obd_uuid *uuid)
+{
+        struct obd_import_conn *conn;
+        int rc = -ENOENT;
+        ENTRY;
+
+        cfs_spin_lock(&imp->imp_lock);
+        cfs_list_for_each_entry(conn, &imp->imp_conn_list, oic_item) {
+                /* check if conn uuid does have this peer nid */
+                if (class_check_uuid(&conn->oic_uuid, peer)) {
+                        *uuid = conn->oic_uuid;
+                        rc = 0;
+                        break;
+                }
+        }
+        cfs_spin_unlock(&imp->imp_lock);
+        RETURN(rc);
+}
+EXPORT_SYMBOL(client_import_find_conn);
+
 void client_destroy_import(struct obd_import *imp)
 {
         /* drop security policy instance after all rpc finished/aborted

diff --git a/lustre/obdclass/lustre_peer.c b/lustre/obdclass/lustre_peer.c
index b7a4b02..27c8d96 100644 (file)
--- a/lustre/obdclass/lustre_peer.c
+++ b/lustre/obdclass/lustre_peer.c
@@ -47,11 +47,13 @@
 #include <lustre_net.h>
 #include <lprocfs_status.h>
 
+#define NIDS_MAX        32
+
 struct uuid_nid_data {
         cfs_list_t       un_list;
-        lnet_nid_t       un_nid;
-        char            *un_uuid;
-        int              un_count;  /* nid/uuid pair refcount */
+        struct obd_uuid  un_uuid;
+        int              un_nid_count;
+        lnet_nid_t       un_nids[NIDS_MAX];
 };
 
 /* FIXME: This should probably become more elegant than a global linked list */
@@ -72,25 +74,24 @@ void class_exit_uuidlist(void)
 
 int lustre_uuid_to_peer(const char *uuid, lnet_nid_t *peer_nid, int index)
 {
-        cfs_list_t *tmp;
-
-        cfs_spin_lock (&g_uuid_lock);
-
-        cfs_list_for_each(tmp, &g_uuid_list) {
-                struct uuid_nid_data *data =
-                        cfs_list_entry(tmp, struct uuid_nid_data, un_list);
-
-                if (!strcmp(data->un_uuid, uuid) &&
-                    index-- == 0) {
-                        *peer_nid = data->un_nid;
-
-                        cfs_spin_unlock (&g_uuid_lock);
-                        return 0;
+        struct uuid_nid_data *data;
+        struct obd_uuid tmp;
+        int rc = -ENOENT;
+
+        obd_str2uuid(&tmp, uuid);
+        cfs_spin_lock(&g_uuid_lock);
+        cfs_list_for_each_entry(data, &g_uuid_list, un_list) {
+                if (obd_uuid_equals(&data->un_uuid, &tmp)) {
+                        if (index >= data->un_nid_count)
+                                break;
+
+                        rc = 0;
+                        *peer_nid = data->un_nids[index];
+                        break;
                 }
         }
-
-        cfs_spin_unlock (&g_uuid_lock);
-        return -ENOENT;
+        cfs_spin_unlock(&g_uuid_lock);
+        return rc;
 }
 
 /* Add a nid to a niduuid.  Multiple nids can be added to a single uuid;
@@ -98,46 +99,45 @@ int lustre_uuid_to_peer(const char *uuid, lnet_nid_t *peer_nid, int index)
 int class_add_uuid(const char *uuid, __u64 nid)
 {
         struct uuid_nid_data *data, *entry;
-        int nob = strnlen (uuid, CFS_PAGE_SIZE) + 1;
         int found = 0;
 
         LASSERT(nid != 0);  /* valid newconfig NID is never zero */
 
-        if (nob > CFS_PAGE_SIZE)
-                return -EINVAL;
+        if (strlen(uuid) > UUID_MAX - 1)
+                return -EOVERFLOW;
 
-        OBD_ALLOC(data, sizeof(*data));
+        OBD_ALLOC_PTR(data);
         if (data == NULL)
                 return -ENOMEM;
 
-        OBD_ALLOC(data->un_uuid, nob);
-        if (data == NULL) {
-                OBD_FREE(data, sizeof(*data));
-                return -ENOMEM;
-        }
-
-        memcpy(data->un_uuid, uuid, nob);
-        data->un_nid = nid;
-        data->un_count = 1;
-
-        cfs_spin_lock (&g_uuid_lock);
+        obd_str2uuid(&data->un_uuid, uuid);
+        data->un_nids[0] = nid;
+        data->un_nid_count = 1;
 
+        cfs_spin_lock(&g_uuid_lock);
         cfs_list_for_each_entry(entry, &g_uuid_list, un_list) {
-                if (entry->un_nid == nid && 
-                    (strcmp(entry->un_uuid, uuid) == 0)) {
-                        found++;
-                        entry->un_count++;
-                        break;
+                if (obd_uuid_equals(&entry->un_uuid, &data->un_uuid)) {
+                        int i;
+
+                        found = 1;
+                        for (i = 0; i < data->un_nid_count; i++)
+                                if (nid == entry->un_nids[i])
+                                        break;
+
+                        if (i == data->un_nid_count) {
+                                LASSERT(data->un_nid_count < NIDS_MAX);
+                                data->un_nids[++data->un_nid_count] = nid;
+                                break;
+                        }
                 }
         }
-        if (!found) 
+        if (!found)
                 cfs_list_add(&data->un_list, &g_uuid_list);
-        cfs_spin_unlock (&g_uuid_lock);
+        cfs_spin_unlock(&g_uuid_lock);
 
         if (found) {
-                CDEBUG(D_INFO, "found uuid %s %s cnt=%d\n", uuid, 
-                       libcfs_nid2str(nid), entry->un_count);
-                OBD_FREE(data->un_uuid, nob);
+                CDEBUG(D_INFO, "found uuid %s %s cnt=%d\n", uuid,
+                       libcfs_nid2str(nid), entry->un_nid_count);
                 OBD_FREE(data, sizeof(*data));
         } else {
                 CDEBUG(D_INFO, "add uuid %s %s\n", uuid, libcfs_nid2str(nid));
@@ -150,29 +150,24 @@ int class_del_uuid(const char *uuid)
 {
         CFS_LIST_HEAD(deathrow);
         struct uuid_nid_data *data;
-        int found = 0;
 
-        cfs_spin_lock (&g_uuid_lock);
-        if (uuid == NULL) {
-                cfs_list_splice_init(&g_uuid_list, &deathrow);
-                found = 1;
-        } else {
+        cfs_spin_lock(&g_uuid_lock);
+        if (uuid != NULL) {
+                struct obd_uuid tmp;
+
+                obd_str2uuid(&tmp, uuid);
                 cfs_list_for_each_entry(data, &g_uuid_list, un_list) {
-                        if (strcmp(data->un_uuid, uuid))
-                                continue;
-                        --data->un_count;
-                        LASSERT(data->un_count >= 0);
-                        if (data->un_count == 0)
+                        if (obd_uuid_equals(&data->un_uuid, &tmp)) {
                                 cfs_list_move(&data->un_list, &deathrow);
-                        found = 1;
-                        break;
+                                break;
+                        }
                 }
-        }
-        cfs_spin_unlock (&g_uuid_lock);
+        } else
+                cfs_list_splice_init(&g_uuid_list, &deathrow);
+        cfs_spin_unlock(&g_uuid_lock);
 
-        if (!found) {
-                if (uuid)
-                        CERROR("Try to delete a non-existent uuid %s\n", uuid);
+        if (uuid != NULL && cfs_list_empty(&deathrow)) {
+                CDEBUG(D_INFO, "Try to delete a non-existent uuid %s\n", uuid);
                 return -EINVAL;
         }
 
@@ -181,12 +176,43 @@ int class_del_uuid(const char *uuid)
                                       un_list);
                 cfs_list_del(&data->un_list);
 
-                CDEBUG(D_INFO, "del uuid %s %s\n", data->un_uuid,
-                       libcfs_nid2str(data->un_nid));
+                CDEBUG(D_INFO, "del uuid %s %s/%d\n",
+                       obd_uuid2str(&data->un_uuid),
+                       libcfs_nid2str(data->un_nids[0]),
+                       data->un_nid_count);
 
-                OBD_FREE(data->un_uuid, strlen(data->un_uuid) + 1);
                 OBD_FREE(data, sizeof(*data));
         }
 
         return 0;
 }
+
+/* check if @nid exists in nid list of @uuid */
+int class_check_uuid(struct obd_uuid *uuid, __u64 nid)
+{
+        struct uuid_nid_data *entry;
+        int found = 0;
+        ENTRY;
+
+        CDEBUG(D_INFO, "check if uuid %s has %s.\n",
+               obd_uuid2str(uuid), libcfs_nid2str(nid));
+
+        cfs_spin_lock(&g_uuid_lock);
+        cfs_list_for_each_entry(entry, &g_uuid_list, un_list) {
+                int i;
+
+                if (!obd_uuid_equals(&entry->un_uuid, uuid))
+                        continue;
+
+                /* found the uuid, check if it has @nid */
+                for (i = 0; i < entry->un_nid_count; i++) {
+                        if (entry->un_nids[i] == nid) {
+                                found = 1;
+                                break;
+                        }
+                }
+        }
+        cfs_spin_unlock (&g_uuid_lock);
+        RETURN(found);
+}
+EXPORT_SYMBOL(class_check_uuid);