LU-6142 lustre: ptlrpc: don't use list_for_each_entry_safe unnecessarily.

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

diff --git a/lustre/ptlrpc/recover.c b/lustre/ptlrpc/recover.c
index c923ab9..3cbc423 100644 (file)
--- a/lustre/ptlrpc/recover.c
+++ b/lustre/ptlrpc/recover.c
@@ -67,17 +67,16 @@ void ptlrpc_initiate_recovery(struct obd_import *imp)
  */
 int ptlrpc_replay_next(struct obd_import *imp, int *inflight)
 {
-        int rc = 0;
-       struct list_head *tmp, *pos;
-        struct ptlrpc_request *req = NULL;
-        __u64 last_transno;
-        ENTRY;
+       int rc = 0;
+       struct ptlrpc_request *req = NULL;
+       __u64 last_transno;
+       ENTRY;
 
-        *inflight = 0;
+       *inflight = 0;
 
-        /* It might have committed some after we last spoke, so make sure we
-         * get rid of them now.
-         */
+       /* It might have committed some after we last spoke, so make sure we
+        * get rid of them now.
+        */
        spin_lock(&imp->imp_lock);
        imp->imp_last_transno_checked = 0;
        ptlrpc_free_committed(imp);
@@ -89,9 +88,8 @@ int ptlrpc_replay_next(struct obd_import *imp, int *inflight)
 
        /* Replay all the committed open requests on committed_list first */
        if (!list_empty(&imp->imp_committed_list)) {
-               tmp = imp->imp_committed_list.prev;
-               req = list_entry(tmp, struct ptlrpc_request,
-                                    rq_replay_list);
+               req = list_last_entry(&imp->imp_committed_list,
+                                     struct ptlrpc_request, rq_replay_list);
 
                /* The last request on committed_list hasn't been replayed */
                if (req->rq_transno > last_transno) {
@@ -103,8 +101,8 @@ int ptlrpc_replay_next(struct obd_import *imp, int *inflight)
                        while (imp->imp_replay_cursor !=
                               &imp->imp_committed_list) {
                                req = list_entry(imp->imp_replay_cursor,
-                                                    struct ptlrpc_request,
-                                                    rq_replay_list);
+                                                struct ptlrpc_request,
+                                                rq_replay_list);
                                if (req->rq_transno > last_transno)
                                        break;
 
@@ -123,13 +121,14 @@ int ptlrpc_replay_next(struct obd_import *imp, int *inflight)
        /* All the requests in committed list have been replayed, let's replay
         * the imp_replay_list */
        if (req == NULL) {
-               list_for_each_safe(tmp, pos, &imp->imp_replay_list) {
-                       req = list_entry(tmp, struct ptlrpc_request,
-                                            rq_replay_list);
+               struct ptlrpc_request *tmp;
 
-                       if (req->rq_transno > last_transno)
+               list_for_each_entry(tmp, &imp->imp_replay_list,
+                                   rq_replay_list) {
+                       if (tmp->rq_transno > last_transno) {
+                               req = tmp;
                                break;
-                       req = NULL;
+                       }
                }
        }
 
@@ -145,7 +144,7 @@ int ptlrpc_replay_next(struct obd_import *imp, int *inflight)
         * exception is that resend replay could have been removed from the
         * unreplied list. */
        if (req != NULL && list_empty(&req->rq_unreplied_list)) {
-               DEBUG_REQ(D_HA, req, "resend_replay: %d, last_transno: %llu\n",
+               DEBUG_REQ(D_HA, req, "resend_replay=%d, last_transno=%llu",
                          imp->imp_resend_replay, last_transno);
                ptlrpc_add_unreplied(req);
                imp->imp_known_replied_xid = ptlrpc_known_replied_xid(imp);
@@ -159,8 +158,8 @@ int ptlrpc_replay_next(struct obd_import *imp, int *inflight)
 
                rc = ptlrpc_replay_req(req);
                if (rc) {
-                       CERROR("recovery replay error %d for req "
-                              "%llu\n", rc, req->rq_xid);
+                       CERROR("recovery replay error %d for req %llu\n",
+                              rc, req->rq_xid);
                        RETURN(rc);
                }
                *inflight = 1;
@@ -174,7 +173,7 @@ int ptlrpc_replay_next(struct obd_import *imp, int *inflight)
  */
 int ptlrpc_resend(struct obd_import *imp)
 {
-        struct ptlrpc_request *req, *next;
+       struct ptlrpc_request *req;
 
         ENTRY;
 
@@ -190,7 +189,7 @@ int ptlrpc_resend(struct obd_import *imp)
                 RETURN(-1);
         }
 
-       list_for_each_entry_safe(req, next, &imp->imp_sending_list, rq_list) {
+       list_for_each_entry(req, &imp->imp_sending_list, rq_list) {
                LASSERTF((long)req > PAGE_SIZE && req != LP_POISON,
                         "req %p bad\n", req);
                LASSERTF(req->rq_type != LI_POISON, "req %p freed\n", req);
@@ -213,13 +212,10 @@ int ptlrpc_resend(struct obd_import *imp)
  */
 void ptlrpc_wake_delayed(struct obd_import *imp)
 {
-       struct list_head *tmp, *pos;
        struct ptlrpc_request *req;
 
        spin_lock(&imp->imp_lock);
-       list_for_each_safe(tmp, pos, &imp->imp_delayed_list) {
-               req = list_entry(tmp, struct ptlrpc_request, rq_list);
-
+       list_for_each_entry(req, &imp->imp_delayed_list, rq_list) {
                DEBUG_REQ(D_HA, req, "waking (set %p):", req->rq_set);
                ptlrpc_client_wake_req(req);
        }
@@ -328,39 +324,42 @@ int ptlrpc_recover_import(struct obd_import *imp, char *new_uuid, int async)
                        GOTO(out, rc);
        }
 
-        /* Check if reconnect is already in progress */
+       /* Check if reconnect is already in progress */
        spin_lock(&imp->imp_lock);
        if (imp->imp_state != LUSTRE_IMP_DISCON) {
                imp->imp_force_verify = 1;
                rc = -EALREADY;
        }
        spin_unlock(&imp->imp_lock);
-        if (rc)
-                GOTO(out, rc);
+       if (rc)
+               GOTO(out, rc);
 
        OBD_RACE(OBD_FAIL_PTLRPC_CONNECT_RACE);
 
-        rc = ptlrpc_connect_import(imp);
-        if (rc)
-                GOTO(out, rc);
-
-        if (!async) {
-                struct l_wait_info lwi;
-               long secs = cfs_time_seconds(obd_timeout);
-
-               CDEBUG(D_HA, "%s: recovery started, waiting %lu seconds\n",
-                       obd2cli_tgt(imp->imp_obd), secs);
+       rc = ptlrpc_connect_import(imp);
+       if (rc)
+               GOTO(out, rc);
 
-                lwi = LWI_TIMEOUT(secs, NULL, NULL);
-                rc = l_wait_event(imp->imp_recovery_waitq,
-                                  !ptlrpc_import_in_recovery(imp), &lwi);
-                CDEBUG(D_HA, "%s: recovery finished\n",
-                       obd2cli_tgt(imp->imp_obd));
-        }
-        EXIT;
+       if (!async) {
+               long timeout = cfs_time_seconds(obd_timeout);
+
+               CDEBUG(D_HA, "%s: recovery started, waiting %u jiffies\n",
+                      obd2cli_tgt(imp->imp_obd), obd_timeout);
+
+               rc = wait_event_idle_timeout(imp->imp_recovery_waitq,
+                                            !ptlrpc_import_in_recovery(imp),
+                                            timeout);
+               if (rc == 0)
+                       rc = -ETIMEDOUT;
+               else
+                       rc = 0;
+               CDEBUG(D_HA, "%s: recovery finished\n",
+                      obd2cli_tgt(imp->imp_obd));
+       }
+       EXIT;
 
 out:
-        return rc;
+       return rc;
 }
 EXPORT_SYMBOL(ptlrpc_recover_import);