Whamcloud - gitweb
git://git.whamcloud.com / fs / lustre-release.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Revert "LU-7434 ptlrpc: lost bulk leads to a hang"
[fs/lustre-release.git] / lustre / include / lustre_net.h
diff --git a/lustre/include/lustre_net.h b/lustre/include/lustre_net.h
index 5f02e97..8858384 100644 (file)
--- a/lustre/include/lustre_net.h
+++ b/lustre/include/lustre_net.h
@@ -714,14 +714,13 @@ struct ptlrpc_thread;
 
 /** RPC stages */
 enum rq_phase {
-       RQ_PHASE_NEW            = 0xebc0de00,
-       RQ_PHASE_RPC            = 0xebc0de01,
-       RQ_PHASE_BULK           = 0xebc0de02,
-       RQ_PHASE_INTERPRET      = 0xebc0de03,
-       RQ_PHASE_COMPLETE       = 0xebc0de04,
-       RQ_PHASE_UNREG_RPC      = 0xebc0de05,
-       RQ_PHASE_UNREG_BULK     = 0xebc0de06,
-       RQ_PHASE_UNDEFINED      = 0xebc0de07
+        RQ_PHASE_NEW            = 0xebc0de00,
+        RQ_PHASE_RPC            = 0xebc0de01,
+        RQ_PHASE_BULK           = 0xebc0de02,
+        RQ_PHASE_INTERPRET      = 0xebc0de03,
+        RQ_PHASE_COMPLETE       = 0xebc0de04,
+        RQ_PHASE_UNREGISTERING  = 0xebc0de05,
+        RQ_PHASE_UNDEFINED      = 0xebc0de06
 };
 
 /** Type of request interpreter call-back */
@@ -796,8 +795,6 @@ struct ptlrpc_cli_req {
        time_t                           cr_reply_deadline;
        /** when req bulk unlink must finish. */
        time_t                           cr_bulk_deadline;
-       /** when req unlink must finish. */
-       time_t                           cr_req_deadline;
        /** Portal to which this request would be sent */
        short                            cr_req_ptl;
        /** Portal where to wait for reply and where reply would be sent */
@@ -856,7 +853,6 @@ struct ptlrpc_cli_req {
 #define rq_real_sent           rq_cli.cr_sent_out
 #define rq_reply_deadline      rq_cli.cr_reply_deadline
 #define rq_bulk_deadline       rq_cli.cr_bulk_deadline
-#define rq_req_deadline                rq_cli.cr_req_deadline
 #define rq_nr_resend           rq_cli.cr_resend_nr
 #define rq_request_portal      rq_cli.cr_req_ptl
 #define rq_reply_portal                rq_cli.cr_rep_ptl
@@ -1232,24 +1228,22 @@ static inline void lustre_set_rep_swabbed(struct ptlrpc_request *req,
 static inline const char *
 ptlrpc_phase2str(enum rq_phase phase)
 {
-       switch (phase) {
-       case RQ_PHASE_NEW:
-               return "New";
-       case RQ_PHASE_RPC:
-               return "Rpc";
-       case RQ_PHASE_BULK:
-               return "Bulk";
-       case RQ_PHASE_INTERPRET:
-               return "Interpret";
-       case RQ_PHASE_COMPLETE:
-               return "Complete";
-       case RQ_PHASE_UNREG_RPC:
-               return "UnregRPC";
-       case RQ_PHASE_UNREG_BULK:
-               return "UnregBULK";
-       default:
-               return "?Phase?";
-       }
+        switch (phase) {
+        case RQ_PHASE_NEW:
+                return "New";
+        case RQ_PHASE_RPC:
+                return "Rpc";
+        case RQ_PHASE_BULK:
+                return "Bulk";
+        case RQ_PHASE_INTERPRET:
+                return "Interpret";
+        case RQ_PHASE_COMPLETE:
+                return "Complete";
+        case RQ_PHASE_UNREGISTERING:
+                return "Unregistering";
+        default:
+                return "?Phase?";
+        }
 }
 
 /**
@@ -1270,18 +1264,18 @@ ptlrpc_rqphase2str(struct ptlrpc_request *req)
 #define FLAG(field, str) (field ? str : "")
 
 /** Convert bit flags into a string */
-#define DEBUG_REQ_FLAGS(req)                                                   \
-       ptlrpc_rqphase2str(req),                                               \
-       FLAG(req->rq_intr, "I"), FLAG(req->rq_replied, "R"),                   \
-       FLAG(req->rq_err, "E"), FLAG(req->rq_net_err, "e"),                    \
-       FLAG(req->rq_timedout, "X") /* eXpired */, FLAG(req->rq_resend, "S"),  \
-       FLAG(req->rq_restart, "T"), FLAG(req->rq_replay, "P"),                 \
-       FLAG(req->rq_no_resend, "N"),                                          \
-       FLAG(req->rq_waiting, "W"),                                            \
-       FLAG(req->rq_wait_ctx, "C"), FLAG(req->rq_hp, "H"),                    \
-       FLAG(req->rq_committed, "M")
-
-#define REQ_FLAGS_FMT "%s:%s%s%s%s%s%s%s%s%s%s%s%s%s"
+#define DEBUG_REQ_FLAGS(req)                                                    \
+        ptlrpc_rqphase2str(req),                                                \
+        FLAG(req->rq_intr, "I"), FLAG(req->rq_replied, "R"),                    \
+        FLAG(req->rq_err, "E"),                                                 \
+        FLAG(req->rq_timedout, "X") /* eXpired */, FLAG(req->rq_resend, "S"),   \
+        FLAG(req->rq_restart, "T"), FLAG(req->rq_replay, "P"),                  \
+        FLAG(req->rq_no_resend, "N"),                                           \
+        FLAG(req->rq_waiting, "W"),                                             \
+        FLAG(req->rq_wait_ctx, "C"), FLAG(req->rq_hp, "H"),                     \
+        FLAG(req->rq_committed, "M")
+
+#define REQ_FLAGS_FMT "%s:%s%s%s%s%s%s%s%s%s%s%s%s"
 
 void _debug_req(struct ptlrpc_request *req,
                 struct libcfs_debug_msg_data *data, const char *fmt, ...)
@@ -2052,14 +2046,15 @@ static inline int ptlrpc_client_bulk_active(struct ptlrpc_request *req)
        struct ptlrpc_bulk_desc *desc;
         int                      rc;
 
-       LASSERT(req != NULL);
+        LASSERT(req != NULL);
        desc = req->rq_bulk;
 
-       if (req->rq_bulk_deadline > cfs_time_current_sec())
-               return 1;
+        if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_BULK_UNLINK) &&
+            req->rq_bulk_deadline > cfs_time_current_sec())
+                return 1;
 
-       if (!desc)
-               return 0;
+        if (!desc)
+                return 0;
 
        spin_lock(&desc->bd_lock);
        rc = desc->bd_md_count;
@@ -2435,20 +2430,13 @@ ptlrpc_rqphase_move(struct ptlrpc_request *req, enum rq_phase new_phase)
        if (req->rq_phase == new_phase)
                return;
 
-       if (new_phase == RQ_PHASE_UNREG_RPC ||
-           new_phase == RQ_PHASE_UNREG_BULK) {
-               /* No embedded unregistering phases */
-               if (req->rq_phase == RQ_PHASE_UNREG_RPC ||
-                   req->rq_phase == RQ_PHASE_UNREG_BULK)
-                       return;
-
+       if (new_phase == RQ_PHASE_UNREGISTERING) {
                req->rq_next_phase = req->rq_phase;
                if (req->rq_import)
                        atomic_inc(&req->rq_import->imp_unregistering);
        }
 
-       if (req->rq_phase == RQ_PHASE_UNREG_RPC ||
-           req->rq_phase == RQ_PHASE_UNREG_BULK) {
+       if (req->rq_phase == RQ_PHASE_UNREGISTERING) {
                if (req->rq_import)
                        atomic_dec(&req->rq_import->imp_unregistering);
        }
@@ -2465,6 +2453,9 @@ ptlrpc_rqphase_move(struct ptlrpc_request *req, enum rq_phase new_phase)
 static inline int
 ptlrpc_client_early(struct ptlrpc_request *req)
 {
+        if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_REPL_UNLINK) &&
+            req->rq_reply_deadline > cfs_time_current_sec())
+                return 0;
         return req->rq_early;
 }
 
@@ -2474,18 +2465,20 @@ ptlrpc_client_early(struct ptlrpc_request *req)
 static inline int
 ptlrpc_client_replied(struct ptlrpc_request *req)
 {
-       if (req->rq_reply_deadline > cfs_time_current_sec())
-               return 0;
-       return req->rq_replied;
+        if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_REPL_UNLINK) &&
+            req->rq_reply_deadline > cfs_time_current_sec())
+                return 0;
+        return req->rq_replied;
 }
 
 /** Returns true if request \a req is in process of receiving server reply */
 static inline int
 ptlrpc_client_recv(struct ptlrpc_request *req)
 {
-       if (req->rq_reply_deadline > cfs_time_current_sec())
-               return 1;
-       return req->rq_receiving_reply;
+        if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_REPL_UNLINK) &&
+            req->rq_reply_deadline > cfs_time_current_sec())
+                return 1;
+        return req->rq_receiving_reply;
 }
 
 static inline int
@@ -2494,15 +2487,11 @@ ptlrpc_client_recv_or_unlink(struct ptlrpc_request *req)
        int rc;
 
        spin_lock(&req->rq_lock);
-       if (req->rq_reply_deadline > cfs_time_current_sec()) {
-               spin_unlock(&req->rq_lock);
-               return 1;
-       }
-       if (req->rq_req_deadline > cfs_time_current_sec()) {
+       if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_REPL_UNLINK) &&
+           req->rq_reply_deadline > cfs_time_current_sec()) {
                spin_unlock(&req->rq_lock);
                return 1;
        }
-
        rc = !req->rq_req_unlinked || !req->rq_reply_unlinked ||
             req->rq_receiving_reply;
        spin_unlock(&req->rq_lock);
Lustre primary development and releases