LU-13509 ptlrpc: Clear bd_registered in ptlrpc_unregister_bulk

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

diff --git a/lustre/ptlrpc/niobuf.c b/lustre/ptlrpc/niobuf.c
index aed657d..bca143e 100644 (file)
--- a/lustre/ptlrpc/niobuf.c
+++ b/lustre/ptlrpc/niobuf.c
@@ -31,6 +31,7 @@
  */
 
 #define DEBUG_SUBSYSTEM S_RPC
+#include <libcfs/linux/linux-mem.h>
 #include <obd_support.h>
 #include <lustre_net.h>
 #include <lustre_lib.h>
@@ -75,7 +76,7 @@ static int ptl_send_buf(struct lnet_handle_md *mdh, void *base, int len,
                ack = LNET_NOACK_REQ;
        }
 
-       rc = LNetMDBind (md, LNET_UNLINK, mdh);
+       rc = LNetMDBind(&md, LNET_UNLINK, mdh);
        if (unlikely(rc != 0)) {
                CERROR ("LNetMDBind failed: %d\n", rc);
                LASSERT (rc == -ENOMEM);
@@ -207,7 +208,7 @@ int ptlrpc_start_bulk_transfer(struct ptlrpc_bulk_desc *desc)
                 * page-aligned. Otherwise we'd have to send client bulk
                 * sizes over and split server buffer accordingly */
                ptlrpc_fill_bulk_md(&md, desc, posted_md);
-               rc = LNetMDBind(md, LNET_UNLINK, &desc->bd_mds[posted_md]);
+               rc = LNetMDBind(&md, LNET_UNLINK, &desc->bd_mds[posted_md]);
                if (rc != 0) {
                        CERROR("%s: LNetMDBind failed for MD %u: rc = %d\n",
                               exp->exp_obd->obd_name, posted_md, rc);
@@ -291,7 +292,7 @@ void ptlrpc_abort_bulk(struct ptlrpc_bulk_desc *desc)
        for (;;) {
                /* Network access will complete in finite time but the HUGE
                 * timeout lets us CWARN for visibility of sluggish NALs */
-               int seconds = LONG_UNLINK;
+               int seconds = PTLRPC_REQ_LONG_UNLINK;
 
                while (seconds > 0 &&
                       wait_event_idle_timeout(desc->bd_waitq,
@@ -392,7 +393,7 @@ int ptlrpc_register_bulk(struct ptlrpc_request *req)
                percpu_ref_get(&ptlrpc_pending);
 
                /* About to let the network at it... */
-               rc = LNetMDAttach(me, md, LNET_UNLINK,
+               rc = LNetMDAttach(me, &md, LNET_UNLINK,
                                  &desc->bd_mds[posted_md]);
                if (rc != 0) {
                        CERROR("%s: LNetMDAttach failed x%llu/%d: rc = %d\n",
@@ -445,10 +446,14 @@ int ptlrpc_unregister_bulk(struct ptlrpc_request *req, int async)
 
        LASSERT(!in_interrupt());     /* might sleep */
 
+       if (desc)
+               desc->bd_registered = 0;
+
        /* Let's setup deadline for reply unlink. */
        if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_BULK_UNLINK) &&
            async && req->rq_bulk_deadline == 0 && cfs_fail_val == 0)
-               req->rq_bulk_deadline = ktime_get_real_seconds() + LONG_UNLINK;
+               req->rq_bulk_deadline = ktime_get_real_seconds() +
+                                       PTLRPC_REQ_LONG_UNLINK;
 
        if (ptlrpc_client_bulk_active(req) == 0)        /* completed or */
                RETURN(1);                              /* never registered */
@@ -481,7 +486,7 @@ int ptlrpc_unregister_bulk(struct ptlrpc_request *req, int async)
                 * Network access will complete in finite time but the HUGE
                 * timeout lets us CWARN for visibility of sluggish NALs.
                 */
-               int seconds = LONG_UNLINK;
+               int seconds = PTLRPC_REQ_LONG_UNLINK;
 
                while (seconds > 0 &&
                       wait_event_idle_timeout(*wq,
@@ -515,9 +520,10 @@ static void ptlrpc_at_set_reply(struct ptlrpc_request *req, int flags)
               (MSG_RESENT | MSG_REPLAY |
                MSG_REQ_REPLAY_DONE | MSG_LOCK_REPLAY_DONE))) {
                 /* early replies, errors and recovery requests don't count
-                 * toward our service time estimate */
-               int oldse = at_measured(&svcpt->scp_at_estimate,
-                                       service_timeout);
+                * toward our service time estimate
+                */
+               timeout_t oldse = at_measured(&svcpt->scp_at_estimate,
+                                             service_timeout);
 
                if (oldse != 0) {
                        DEBUG_REQ(D_ADAPTTO, req,
@@ -537,7 +543,7 @@ static void ptlrpc_at_set_reply(struct ptlrpc_request *req, int flags)
             req->rq_export->exp_obd->obd_recovering)) {
                lustre_msg_set_timeout(req->rq_repmsg, 0);
        } else {
-               time64_t timeout;
+               timeout_t timeout;
 
                if (req->rq_export && req->rq_reqmsg != NULL &&
                    (flags & PTLRPC_REPLY_EARLY) &&
@@ -547,7 +553,7 @@ static void ptlrpc_at_set_reply(struct ptlrpc_request *req, int flags)
 
                        timeout = ktime_get_real_seconds() -
                                  req->rq_arrival_time.tv_sec +
-                                 min_t(time64_t, at_extra,
+                                 min_t(timeout_t, at_extra,
                                        exp_obd->obd_recovery_timeout / 4);
                } else {
                        timeout = at_get(&svcpt->scp_at_estimate);
@@ -784,7 +790,7 @@ int ptl_send_rpc(struct ptlrpc_request *request, int noreply)
                        request->rq_resend_cb(request, &request->rq_async_args);
        }
        if (request->rq_memalloc)
-               mpflag = cfs_memory_pressure_get_and_set();
+               mpflag = memalloc_noreclaim_save();
 
        rc = sptlrpc_cli_wrap_request(request);
        if (rc)
@@ -824,9 +830,16 @@ int ptl_send_rpc(struct ptlrpc_request *request, int noreply)
                        request->rq_repmsg = NULL;
                }
 
-               reply_me = LNetMEAttach(request->rq_reply_portal,
-                                       connection->c_peer, request->rq_xid, 0,
-                                       LNET_UNLINK, LNET_INS_AFTER);
+               if (request->rq_bulk &&
+                   OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_BULK_REPLY_ATTACH)) {
+                       reply_me = ERR_PTR(-ENOMEM);
+               } else {
+                       reply_me = LNetMEAttach(request->rq_reply_portal,
+                                               connection->c_peer,
+                                               request->rq_xid, 0,
+                                               LNET_UNLINK, LNET_INS_AFTER);
+               }
+
                if (IS_ERR(reply_me)) {
                        rc = PTR_ERR(reply_me);
                        CERROR("LNetMEAttach failed: %d\n", rc);
@@ -864,7 +877,7 @@ int ptl_send_rpc(struct ptlrpc_request *request, int noreply)
 
                /* We must see the unlink callback to set rq_reply_unlinked,
                 * so we can't auto-unlink */
-               rc = LNetMDAttach(reply_me, reply_md, LNET_RETAIN,
+               rc = LNetMDAttach(reply_me, &reply_md, LNET_RETAIN,
                                  &request->rq_reply_md_h);
                if (rc != 0) {
                        CERROR("LNetMDAttach failed: %d\n", rc);
@@ -928,9 +941,7 @@ int ptl_send_rpc(struct ptlrpc_request *request, int noreply)
  cleanup_bulk:
        /* We do sync unlink here as there was no real transfer here so
         * the chance to have long unlink to sluggish net is smaller here. */
-        ptlrpc_unregister_bulk(request, 0);
-       if (request->rq_bulk != NULL)
-               request->rq_bulk->bd_registered = 0;
+       ptlrpc_unregister_bulk(request, 0);
  out:
        if (rc == -ENOMEM) {
                /* set rq_sent so that this request is treated
@@ -939,7 +950,7 @@ int ptl_send_rpc(struct ptlrpc_request *request, int noreply)
        }
 
        if (request->rq_memalloc)
-               cfs_memory_pressure_restore(mpflag);
+               memalloc_noreclaim_restore(mpflag);
 
        return rc;
 }
@@ -988,7 +999,7 @@ int ptlrpc_register_rqbd(struct ptlrpc_request_buffer_desc *rqbd)
        md.user_ptr  = &rqbd->rqbd_cbid;
        md.handler   = ptlrpc_handler;
 
-       rc = LNetMDAttach(me, md, LNET_UNLINK, &rqbd->rqbd_md_h);
+       rc = LNetMDAttach(me, &md, LNET_UNLINK, &rqbd->rqbd_md_h);
        if (rc == 0) {
                percpu_ref_get(&ptlrpc_pending);
                return 0;