diff --git a/lustre/include/lustre_net.h b/lustre/include/lustre_net.h
index e82c7e3..4a9a194 100644
--- a/lustre/include/lustre_net.h
+++ b/lustre/include/lustre_net.h
@@ -261,13 +261,14 @@ struct ptlrpc_reply_state {
 struct ptlrpc_thread;
 
 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_UNREGISTERING  = 0xebc0de05,
-        RQ_PHASE_UNDEFINED      = 0xebc0de06
+        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_BULK_UNREGISTERING = 0xebc0de06,
+        RQ_PHASE_UNDEFINED          = 0xebc0de07
 };
 
 struct ptlrpc_request_pool {
@@ -473,6 +474,8 @@ ptlrpc_phase2str(enum rq_phase phase)
                 return "Complete";
         case RQ_PHASE_UNREGISTERING:
                 return "Unregistering";
+        case RQ_PHASE_BULK_UNREGISTERING:
+                return "BulkUnregistering";
         default:
                 return "?Phase?";
         }
@@ -1006,13 +1009,15 @@ ptlrpc_rqphase_move(struct ptlrpc_request *req, enum rq_phase new_phase)
         if (req->rq_phase == new_phase)
                 return;
 
-        if (new_phase == RQ_PHASE_UNREGISTERING) {
+        if (new_phase == RQ_PHASE_UNREGISTERING ||
+            new_phase == RQ_PHASE_BULK_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_UNREGISTERING) {
+        if (req->rq_phase == RQ_PHASE_UNREGISTERING ||
+            req->rq_phase == RQ_PHASE_BULK_UNREGISTERING) {
                 if (req->rq_import)
                         atomic_dec(&req->rq_import->imp_unregistering);
         }
diff --git a/lustre/ptlrpc/client.c b/lustre/ptlrpc/client.c
index 8ad465a..2c46d4d 100644
--- a/lustre/ptlrpc/client.c
+++ b/lustre/ptlrpc/client.c
@@ -1215,6 +1215,7 @@ int ptlrpc_check_set(struct ptlrpc_request_set *set)
                       req->rq_phase == RQ_PHASE_BULK ||
                       req->rq_phase == RQ_PHASE_INTERPRET ||
                       req->rq_phase == RQ_PHASE_UNREGISTERING ||
+                      req->rq_phase == RQ_PHASE_BULK_UNREGISTERING ||
                       req->rq_phase == RQ_PHASE_COMPLETE)) {
                         DEBUG_REQ(D_ERROR, req, "bad phase %x", req->rq_phase);
                         LBUG();
@@ -1229,8 +1230,7 @@ int ptlrpc_check_set(struct ptlrpc_request_set *set)
                          * call interpret before that. We need to make
                          * sure that all rdma transfers finished and will
                          * not corrupt any data. */
-                        if (ptlrpc_client_recv_or_unlink(req) ||
-                            ptlrpc_client_bulk_active(req))
+                        if (ptlrpc_client_recv_or_unlink(req))
                                 continue;
 
                         /* Turn repl fail_loc off to prevent it from looping
@@ -1240,13 +1240,25 @@ int ptlrpc_check_set(struct ptlrpc_request_set *set)
                                                OBD_FAIL_ONCE);
                         }
 
+                        /* Move to next phase if reply was successfully 
+                         * unlinked. */
+                        ptlrpc_rqphase_move(req, req->rq_next_phase);
+                }
+
+                if (req->rq_phase == RQ_PHASE_BULK_UNREGISTERING) {
+                        LASSERT(req->rq_next_phase != req->rq_phase);
+                        LASSERT(req->rq_next_phase != RQ_PHASE_UNDEFINED);
+
+                        if (ptlrpc_client_bulk_active(req))
+                                continue;
+
                         /* Turn off bulk fail_loc. */
                         if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_BULK_UNLINK)) {
                                 OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_BULK_UNLINK |
                                                OBD_FAIL_ONCE);
                         }
 
-                        /* Move to next phase if reply was successfully 
+                        /* Move to next phase if bulk was successfully 
                          * unlinked. */
                         ptlrpc_rqphase_move(req, req->rq_next_phase);
                 }
@@ -1583,7 +1595,8 @@ void ptlrpc_interrupted_set(void *data)
                         list_entry(tmp, struct ptlrpc_request, rq_set_chain);
 
                 if (req->rq_phase != RQ_PHASE_RPC &&
-                    req->rq_phase != RQ_PHASE_UNREGISTERING)
+                    req->rq_phase != RQ_PHASE_UNREGISTERING &&
+                    req->rq_phase != RQ_PHASE_BULK_UNREGISTERING)
                         continue;
 
                 ptlrpc_mark_interrupted(req);
diff --git a/lustre/ptlrpc/niobuf.c b/lustre/ptlrpc/niobuf.c
index 44b5711..c7634e1 100644
--- a/lustre/ptlrpc/niobuf.c
+++ b/lustre/ptlrpc/niobuf.c
@@ -314,7 +314,7 @@ int ptlrpc_unregister_bulk(struct ptlrpc_request *req, int async)
                 RETURN(1);                    /* never registered */
 
         /* Move to "Unregistering" phase as bulk was not unlinked yet. */
-        ptlrpc_rqphase_move(req, RQ_PHASE_UNREGISTERING);
+        ptlrpc_rqphase_move(req, RQ_PHASE_BULK_UNREGISTERING);
 
         /* Do not wait for unlink to finish. */
         if (async)
