LU-12559 ptlrpc: Hold imp lock for idle reconnect

Idle reconnect sets import state to IMP_NEW, then releases
the import lock before calling ptlrpc_connect_import.  This
creates a gap where an import in IMP_NEW state is exposed,
which can cause new requests to fail with EIO.

Hold the lock across the call so as not to expose imports
in this state.

Signed-off-by: Patrick Farrell <pfarrell@whamcloud.com>
Change-Id: I9f8509d11c4d5a8917a313349534d98b964cd588
Reviewed-on: https://review.whamcloud.com/35530
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Alex Zhuravlev <bzzz@whamcloud.com>
Reviewed-by: Wang Shilong <wshilong@ddn.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/lustre/include/lustre_net.h b/lustre/include/lustre_net.h
index 52e3ddf..fd1589a 100644 (file)
--- a/lustre/include/lustre_net.h
+++ b/lustre/include/lustre_net.h
@@ -2279,6 +2279,7 @@ void ptlrpc_hr_fini(void);
  * @{
  */
 int ptlrpc_connect_import(struct obd_import *imp);
+int ptlrpc_connect_import_locked(struct obd_import *imp);
 int ptlrpc_init_import(struct obd_import *imp);
 int ptlrpc_disconnect_import(struct obd_import *imp, int noclose);
 int ptlrpc_disconnect_and_idle_import(struct obd_import *imp);

diff --git a/lustre/ptlrpc/client.c b/lustre/ptlrpc/client.c
index 300ec30..48ade0f 100644 (file)
--- a/lustre/ptlrpc/client.c
+++ b/lustre/ptlrpc/client.c
@@ -894,7 +894,6 @@ ptlrpc_request_alloc_internal(struct obd_import *imp,
                              const struct req_format *format)
 {
        struct ptlrpc_request *request;
-       int connect = 0;
 
        request = __ptlrpc_request_alloc(imp, pool);
        if (!request)
@@ -915,17 +914,17 @@ ptlrpc_request_alloc_internal(struct obd_import *imp,
                if (imp->imp_state == LUSTRE_IMP_IDLE) {
                        imp->imp_generation++;
                        imp->imp_initiated_at = imp->imp_generation;
-                       imp->imp_state =  LUSTRE_IMP_NEW;
-                       connect = 1;
-               }
-               spin_unlock(&imp->imp_lock);
-               if (connect) {
-                       rc = ptlrpc_connect_import(imp);
+                       imp->imp_state = LUSTRE_IMP_NEW;
+
+                       /* connect_import_locked releases imp_lock */
+                       rc = ptlrpc_connect_import_locked(imp);
                        if (rc < 0) {
                                ptlrpc_request_free(request);
                                return NULL;
                        }
                        ptlrpc_pinger_add_import(imp);
+               } else {
+                       spin_unlock(&imp->imp_lock);
                }
        }
 

diff --git a/lustre/ptlrpc/import.c b/lustre/ptlrpc/import.c
index cc963df..b7ce038 100644 (file)
--- a/lustre/ptlrpc/import.c
+++ b/lustre/ptlrpc/import.c
@@ -658,13 +658,22 @@ static int ptlrpc_first_transno(struct obd_import *imp, __u64 *transno)
        return 0;
 }
 
+int ptlrpc_connect_import(struct obd_import *imp)
+{
+       spin_lock(&imp->imp_lock);
+       return ptlrpc_connect_import_locked(imp);
+}
+
 /**
  * Attempt to (re)connect import \a imp. This includes all preparations,
  * initializing CONNECT RPC request and passing it to ptlrpcd for
  * actual sending.
+ *
+ * Assumes imp->imp_lock is held, and releases it.
+ *
  * Returns 0 on success or error code.
  */
-int ptlrpc_connect_import(struct obd_import *imp)
+int ptlrpc_connect_import_locked(struct obd_import *imp)
 {
        struct obd_device *obd = imp->imp_obd;
        int initial_connect = 0;
@@ -682,7 +691,8 @@ int ptlrpc_connect_import(struct obd_import *imp)
        int rc;
        ENTRY;
 
-       spin_lock(&imp->imp_lock);
+       assert_spin_locked(&imp->imp_lock);
+
        if (imp->imp_state == LUSTRE_IMP_CLOSED) {
                spin_unlock(&imp->imp_lock);
                CERROR("can't connect to a closed import\n");
@@ -1770,12 +1780,13 @@ static int ptlrpc_disconnect_idle_interpret(const struct lu_env *env,
                        connect = 1;
                }
        }
-       spin_unlock(&imp->imp_lock);
 
        if (connect) {
-               rc = ptlrpc_connect_import(imp);
+               rc = ptlrpc_connect_import_locked(imp);
                if (rc >= 0)
                        ptlrpc_pinger_add_import(imp);
+       } else {
+               spin_unlock(&imp->imp_lock);
        }
 
        return 0;