LU-8645 ptlrpc: update imp_known_replied_xid on resend-replay

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

diff --git a/lustre/ptlrpc/recover.c b/lustre/ptlrpc/recover.c
index c7b09e8..02f79d0 100644 (file)
--- a/lustre/ptlrpc/recover.c
+++ b/lustre/ptlrpc/recover.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -27,7 +23,7 @@
  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, 2014, Intel Corporation.
+ * Copyright (c) 2011, 2015, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -39,6 +35,7 @@
  */
 
 #define DEBUG_SUBSYSTEM S_RPC
+#include <linux/list.h>
 #include <libcfs/libcfs.h>
 #include <obd_support.h>
 #include <lustre_ha.h>
@@ -47,7 +44,6 @@
 #include <lustre_export.h>
 #include <obd.h>
 #include <obd_class.h>
-#include <libcfs/list.h>
 
 #include "ptlrpc_internal.h"
 
@@ -88,7 +84,7 @@ int ptlrpc_replay_next(struct obd_import *imp, int *inflight)
        last_transno = imp->imp_last_replay_transno;
        spin_unlock(&imp->imp_lock);
 
-        CDEBUG(D_HA, "import %p from %s committed "LPU64" last "LPU64"\n",
+       CDEBUG(D_HA, "import %p from %s committed %llu last %llu\n",
                imp, obd2cli_tgt(imp->imp_obd),
                imp->imp_peer_committed_transno, last_transno);
 
@@ -119,7 +115,10 @@ int ptlrpc_replay_next(struct obd_import *imp, int *inflight)
                        /* Since the imp_committed_list is immutable before
                         * all of it's requests being replayed, it's safe to
                         * use a cursor to accelerate the search */
-                       imp->imp_replay_cursor = imp->imp_replay_cursor->next;
+                       if (!imp->imp_resend_replay ||
+                           imp->imp_replay_cursor == &imp->imp_committed_list)
+                               imp->imp_replay_cursor =
+                                       imp->imp_replay_cursor->next;
 
                        while (imp->imp_replay_cursor !=
                               &imp->imp_committed_list) {
@@ -155,25 +154,37 @@ int ptlrpc_replay_next(struct obd_import *imp, int *inflight)
 
        /* If need to resend the last sent transno (because a reconnect
         * has occurred), then stop on the matching req and send it again.
-        * If, however, the last sent transno has been committed then we 
+        * If, however, the last sent transno has been committed then we
         * continue replay from the next request. */
        if (req != NULL && imp->imp_resend_replay)
                lustre_msg_add_flags(req->rq_reqmsg, MSG_RESENT);
 
        spin_lock(&imp->imp_lock);
+       /* The resend replay request may have been removed from the
+        * unreplied list. */
+       if (req != NULL && imp->imp_resend_replay &&
+           list_empty(&req->rq_unreplied_list)) {
+               ptlrpc_add_unreplied(req);
+               imp->imp_known_replied_xid = ptlrpc_known_replied_xid(imp);
+       }
+
        imp->imp_resend_replay = 0;
        spin_unlock(&imp->imp_lock);
 
-        if (req != NULL) {
-                rc = ptlrpc_replay_req(req);
-                if (rc) {
-                        CERROR("recovery replay error %d for req "
-                               LPU64"\n", rc, req->rq_xid);
-                        RETURN(rc);
-                }
-                *inflight = 1;
-        }
-        RETURN(rc);
+       if (req != NULL) {
+               /* The request should have been added back in unreplied list
+                * by ptlrpc_prepare_replay(). */
+               LASSERT(!list_empty(&req->rq_unreplied_list));
+
+               rc = ptlrpc_replay_req(req);
+               if (rc) {
+                       CERROR("recovery replay error %d for req "
+                              "%llu\n", rc, req->rq_xid);
+                       RETURN(rc);
+               }
+               *inflight = 1;
+       }
+       RETURN(rc);
 }
 
 /**
@@ -198,19 +209,21 @@ int ptlrpc_resend(struct obd_import *imp)
                 RETURN(-1);
         }
 
-       list_for_each_entry_safe(req, next, &imp->imp_sending_list,
-                                     rq_list) {
-               LASSERTF((long)req > PAGE_CACHE_SIZE && req != LP_POISON,
-                         "req %p bad\n", req);
-                LASSERTF(req->rq_type != LI_POISON, "req %p freed\n", req);
-                if (!ptlrpc_no_resend(req))
-                        ptlrpc_resend_req(req);
-        }
+       list_for_each_entry_safe(req, next, &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);
+
+               /* If the request is allowed to be sent during replay and it
+                * is not timeout yet, then it does not need to be resent. */
+               if (!ptlrpc_no_resend(req) &&
+                   (req->rq_timedout || !req->rq_allow_replay))
+                       ptlrpc_resend_req(req);
+       }
        spin_unlock(&imp->imp_lock);
 
        RETURN(0);
 }
-EXPORT_SYMBOL(ptlrpc_resend);
 
 /**
  * Go through all requests in delayed list and wake their threads
@@ -230,7 +243,6 @@ void ptlrpc_wake_delayed(struct obd_import *imp)
        }
        spin_unlock(&imp->imp_lock);
 }
-EXPORT_SYMBOL(ptlrpc_wake_delayed);
 
 void ptlrpc_request_handle_notconn(struct ptlrpc_request *failed_req)
 {