LU-10467 ptlrpc: convert final users of LWI_TIMEOUT_INTERVAL

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

diff --git a/lustre/ptlrpc/import.c b/lustre/ptlrpc/import.c
index d070e75..4b4bcab 100644 (file)
--- a/lustre/ptlrpc/import.c
+++ b/lustre/ptlrpc/import.c
@@ -301,7 +301,6 @@ void ptlrpc_invalidate_import(struct obd_import *imp)
 {
        struct list_head *tmp, *n;
        struct ptlrpc_request *req;
-       struct l_wait_info lwi;
        time64_t timeout;
        int rc;
 
@@ -348,18 +347,16 @@ void ptlrpc_invalidate_import(struct obd_import *imp)
                 * have been locally cancelled by ptlrpc_abort_inflight.
                 */
                timeout_jiffies = max_t(long, cfs_time_seconds(timeout), 1);
-               lwi = LWI_TIMEOUT_INTERVAL(timeout_jiffies,
-                                          (timeout > 1) ? cfs_time_seconds(1) :
-                                          cfs_time_seconds(1) / 2,
-                                          NULL, NULL);
-               rc = l_wait_event(imp->imp_recovery_waitq,
-                                 (atomic_read(&imp->imp_inflight) == 0),
-                                 &lwi);
-               if (rc) {
+               rc = wait_event_idle_timeout(
+                                   imp->imp_recovery_waitq,
+                                   (atomic_read(&imp->imp_inflight) == 0),
+                                   timeout_jiffies);
+
+               if (rc == 0) {
                        const char *cli_tgt = obd2cli_tgt(imp->imp_obd);
 
-                       CERROR("%s: rc = %d waiting for callback (%d != 0)\n",
-                              cli_tgt, rc, atomic_read(&imp->imp_inflight));
+                       CERROR("%s: timeout waiting for callback (%d != 0)\n",
+                              cli_tgt, atomic_read(&imp->imp_inflight));
 
                        spin_lock(&imp->imp_lock);
                        if (atomic_read(&imp->imp_inflight) == 0) {
@@ -377,7 +374,7 @@ void ptlrpc_invalidate_import(struct obd_import *imp)
                                /* Let's save one loop as soon as inflight have
                                 * dropped to zero. No new inflights possible at
                                 * this point. */
-                               rc = 0;
+                               rc = 1;
                        } else {
                                list_for_each_safe(tmp, n,
                                                   &imp->imp_sending_list) {
@@ -403,7 +400,7 @@ void ptlrpc_invalidate_import(struct obd_import *imp)
                        }
                        spin_unlock(&imp->imp_lock);
                }
-       } while (rc != 0);
+       } while (rc == 0);
 
        /*
         * Let's additionally check that no new rpcs added to import in
@@ -414,7 +411,7 @@ void ptlrpc_invalidate_import(struct obd_import *imp)
        sptlrpc_import_flush_all_ctx(imp);
 
        atomic_dec(&imp->imp_inval_count);
-       wake_up_all(&imp->imp_recovery_waitq);
+       wake_up(&imp->imp_recovery_waitq);
 }
 EXPORT_SYMBOL(ptlrpc_invalidate_import);
 
@@ -471,7 +468,6 @@ int ptlrpc_reconnect_import(struct obd_import *imp)
 {
 #ifdef ENABLE_PINGER
        long timeout_jiffies = cfs_time_seconds(obd_timeout);
-       struct l_wait_info lwi;
        int rc;
 
        ptlrpc_pinger_force(imp);
@@ -479,9 +475,13 @@ int ptlrpc_reconnect_import(struct obd_import *imp)
        CDEBUG(D_HA, "%s: recovery started, waiting %u seconds\n",
               obd2cli_tgt(imp->imp_obd), obd_timeout);
 
-       lwi = LWI_TIMEOUT(timeout_jiffies, NULL, NULL);
-       rc = l_wait_event(imp->imp_recovery_waitq,
-                         !ptlrpc_import_in_recovery(imp), &lwi);
+       rc = wait_event_idle_timeout(imp->imp_recovery_waitq,
+                                    !ptlrpc_import_in_recovery(imp),
+                                    timeout_jiffies);
+       if (rc == 0)
+               rc = -ETIMEDOUT;
+       else
+               rc = 0;
        CDEBUG(D_HA, "%s: recovery finished s:%s\n", obd2cli_tgt(imp->imp_obd),
               ptlrpc_import_state_name(imp->imp_state));
        return rc;
@@ -493,12 +493,11 @@ int ptlrpc_reconnect_import(struct obd_import *imp)
        ptlrpc_disconnect_import(imp, 1);
        /* Wait for all invalidate calls to finish */
        if (atomic_read(&imp->imp_inval_count) > 0) {
-               struct l_wait_info lwi = LWI_INTR(LWI_ON_SIGNAL_NOOP, NULL);
                int rc;
 
-               rc = l_wait_event(imp->imp_recovery_waitq,
-                                 (atomic_read(&imp->imp_inval_count) == 0),
-                                 &lwi);
+               rc = l_wait_event_abortable(
+                       imp->imp_recovery_waitq,
+                       (atomic_read(&imp->imp_inval_count) == 0));
                if (rc)
                        CERROR("Interrupted, inval=%d\n",
                               atomic_read(&imp->imp_inval_count));
@@ -1000,8 +999,8 @@ static void ptlrpc_prepare_replay(struct obd_import *imp)
  * full state for normal operations of disconnect it due to an error.
  */
 static int ptlrpc_connect_interpret(const struct lu_env *env,
-                                    struct ptlrpc_request *request,
-                                    void *data, int rc)
+                                   struct ptlrpc_request *request,
+                                   void *data, int rc)
 {
        struct ptlrpc_connect_async_args *aa = data;
        struct obd_import *imp = request->rq_import;
@@ -1403,7 +1402,7 @@ out:
                spin_unlock(&imp->imp_lock);
        }
 
-       wake_up_all(&imp->imp_recovery_waitq);
+       wake_up(&imp->imp_recovery_waitq);
        RETURN(rc);
 }
 
@@ -1607,14 +1606,19 @@ int ptlrpc_import_recovery_state_machine(struct obd_import *imp)
                        GOTO(out, rc);
                ptlrpc_activate_import(imp, true);
 
-               LCONSOLE_INFO("%s: Connection restored to %s (at %s)\n",
-                             imp->imp_obd->obd_name,
-                             obd_uuid2str(&conn->c_remote_uuid),
-                             obd_import_nid2str(imp));
+               CDEBUG_LIMIT(imp->imp_was_idle ?
+                               imp->imp_idle_debug : D_CONSOLE,
+                            "%s: Connection restored to %s (at %s)\n",
+                            imp->imp_obd->obd_name,
+                            obd_uuid2str(&conn->c_remote_uuid),
+                            obd_import_nid2str(imp));
+               spin_lock(&imp->imp_lock);
+               imp->imp_was_idle = 0;
+               spin_unlock(&imp->imp_lock);
        }
 
        if (imp->imp_state == LUSTRE_IMP_FULL) {
-               wake_up_all(&imp->imp_recovery_waitq);
+               wake_up(&imp->imp_recovery_waitq);
                ptlrpc_wake_delayed(imp);
        }
 
@@ -1685,7 +1689,6 @@ int ptlrpc_disconnect_import(struct obd_import *imp, int noclose)
        spin_unlock(&imp->imp_lock);
 
        if (ptlrpc_import_in_recovery(imp)) {
-               struct l_wait_info lwi;
                long timeout_jiffies;
                time64_t timeout;
 
@@ -1701,15 +1704,16 @@ int ptlrpc_disconnect_import(struct obd_import *imp, int noclose)
                        req_portal = imp->imp_client->cli_request_portal;
                        idx = import_at_get_index(imp, req_portal);
                        timeout = at_get(&imp->imp_at.iat_service_estimate[idx]);
-                }
+               }
 
                timeout_jiffies = cfs_time_seconds(timeout);
-               lwi = LWI_TIMEOUT_INTR(max_t(long, timeout_jiffies, 1),
-                                       back_to_sleep, LWI_ON_SIGNAL_NOOP, NULL);
-                rc = l_wait_event(imp->imp_recovery_waitq,
-                                  !ptlrpc_import_in_recovery(imp), &lwi);
-
-        }
+               if (wait_event_idle_timeout(imp->imp_recovery_waitq,
+                                           !ptlrpc_import_in_recovery(imp),
+                                           timeout_jiffies) == 0 &&
+                   l_wait_event_abortable(imp->imp_recovery_waitq,
+                                          !ptlrpc_import_in_recovery(imp)) < 0)
+                       rc = -EINTR;
+       }
 
        spin_lock(&imp->imp_lock);
        if (imp->imp_state != LUSTRE_IMP_FULL)
@@ -1748,7 +1752,8 @@ static void ptlrpc_reset_reqs_generation(struct obd_import *imp)
                        rq_list) {
                spin_lock(&old->rq_lock);
                if (old->rq_import_generation == imp->imp_generation - 1 &&
-                   !old->rq_no_resend)
+                   ((imp->imp_initiated_at == imp->imp_generation) ||
+                    !old->rq_no_resend))
                        old->rq_import_generation = imp->imp_generation;
                spin_unlock(&old->rq_lock);
        }
@@ -1821,6 +1826,12 @@ int ptlrpc_disconnect_and_idle_import(struct obd_import *imp)
        CDEBUG_LIMIT(imp->imp_idle_debug, "%s: disconnect after %llus idle\n",
                     imp->imp_obd->obd_name,
                     ktime_get_real_seconds() - imp->imp_last_reply_time);
+
+       /* don't make noise at reconnection */
+       spin_lock(&imp->imp_lock);
+       imp->imp_was_idle = 1;
+       spin_unlock(&imp->imp_lock);
+
        req->rq_interpret_reply = ptlrpc_disconnect_idle_interpret;
        ptlrpcd_add_req(req);