Merge remote-tracking branch 'staging/staging-next'

[deliverable/linux.git] / drivers / staging / lustre / lustre / ptlrpc / service.c

diff --git a/drivers/staging/lustre/lustre/ptlrpc/service.c b/drivers/staging/lustre/lustre/ptlrpc/service.c
index 4788c4940c2aba30a7669b6b60f28f377cb68403..a2fce664b4ecb2d69902228836b4ec08df608c23 100644 (file)
--- a/drivers/staging/lustre/lustre/ptlrpc/service.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/service.c
@@ -1005,13 +1005,16 @@ ptlrpc_at_remove_timed(struct ptlrpc_request *req)
        array->paa_count--;
 }
 
+/*
+ * Attempt to extend the request deadline by sending an early reply to the
+ * client.
+ */
 static int ptlrpc_at_send_early_reply(struct ptlrpc_request *req)
 {
        struct ptlrpc_service_part *svcpt = req->rq_rqbd->rqbd_svcpt;
        struct ptlrpc_request *reqcopy;
        struct lustre_msg *reqmsg;
        long olddl = req->rq_deadline - ktime_get_real_seconds();
-       time64_t newdl;
        int rc;
 
        /* deadline is when the client expects us to reply, margin is the
@@ -1039,8 +1042,13 @@ static int ptlrpc_at_send_early_reply(struct ptlrpc_request *req)
                return -ENOSYS;
        }
 
-       /* Fake our processing time into the future to ask the clients
-        * for some extra amount of time
+       /*
+        * We want to extend the request deadline by at_extra seconds,
+        * so we set our service estimate to reflect how much time has
+        * passed since this request arrived plus an additional
+        * at_extra seconds. The client will calculate the new deadline
+        * based on this service estimate (plus some additional time to
+        * account for network latency). See ptlrpc_at_recv_early_reply
         */
        at_measured(&svcpt->scp_at_estimate, at_extra +
                    ktime_get_real_seconds() - req->rq_arrival_time.tv_sec);
@@ -1056,7 +1064,6 @@ static int ptlrpc_at_send_early_reply(struct ptlrpc_request *req)
                          ktime_get_real_seconds());
                return -ETIMEDOUT;
        }
-       newdl = ktime_get_real_seconds() + at_get(&svcpt->scp_at_estimate);
 
        reqcopy = ptlrpc_request_cache_alloc(GFP_NOFS);
        if (!reqcopy)
@@ -1110,7 +1117,8 @@ static int ptlrpc_at_send_early_reply(struct ptlrpc_request *req)
 
        if (!rc) {
                /* Adjust our own deadline to what we told the client */
-               req->rq_deadline = newdl;
+               req->rq_deadline = req->rq_arrival_time.tv_sec +
+                                  at_get(&svcpt->scp_at_estimate);
                req->rq_early_count++; /* number sent, server side */
        } else {
                DEBUG_REQ(D_ERROR, req, "Early reply send failed %d", rc);
@@ -1982,11 +1990,12 @@ ptlrpc_wait_event(struct ptlrpc_service_part *svcpt,
        cond_resched();
 
        l_wait_event_exclusive_head(svcpt->scp_waitq,
-                               ptlrpc_thread_stopping(thread) ||
-                               ptlrpc_server_request_incoming(svcpt) ||
-                               ptlrpc_server_request_pending(svcpt, false) ||
-                               ptlrpc_rqbd_pending(svcpt) ||
-                               ptlrpc_at_check(svcpt), &lwi);
+                                   ptlrpc_thread_stopping(thread) ||
+                                   ptlrpc_server_request_incoming(svcpt) ||
+                                   ptlrpc_server_request_pending(svcpt,
+                                                                 false) ||
+                                   ptlrpc_rqbd_pending(svcpt) ||
+                                   ptlrpc_at_check(svcpt), &lwi);
 
        if (ptlrpc_thread_stopping(thread))
                return -EINTR;
@@ -2049,7 +2058,7 @@ static int ptlrpc_main(void *arg)
        }
 
        rc = lu_context_init(&env->le_ctx,
-                            svc->srv_ctx_tags|LCT_REMEMBER|LCT_NOREF);
+                            svc->srv_ctx_tags | LCT_REMEMBER | LCT_NOREF);
        if (rc)
                goto out_srv_fini;
 
@@ -2349,7 +2358,7 @@ static void ptlrpc_svcpt_stop_threads(struct ptlrpc_service_part *svcpt)
 
        while (!list_empty(&zombie)) {
                thread = list_entry(zombie.next,
-                                       struct ptlrpc_thread, t_link);
+                                   struct ptlrpc_thread, t_link);
                list_del(&thread->t_link);
                kfree(thread);
        }
@@ -2539,8 +2548,8 @@ int ptlrpc_hr_init(void)
                LASSERT(hrp->hrp_nthrs > 0);
                hrp->hrp_thrs =
                        kzalloc_node(hrp->hrp_nthrs * sizeof(*hrt), GFP_NOFS,
-                               cfs_cpt_spread_node(ptlrpc_hr.hr_cpt_table,
-                                                   i));
+                                    cfs_cpt_spread_node(ptlrpc_hr.hr_cpt_table,
+                                                        i));
                if (!hrp->hrp_thrs) {
                        rc = -ENOMEM;
                        goto out;
@@ -2593,7 +2602,8 @@ static void ptlrpc_wait_replies(struct ptlrpc_service_part *svcpt)
                                                     NULL, NULL);
 
                rc = l_wait_event(svcpt->scp_waitq,
-                    atomic_read(&svcpt->scp_nreps_difficult) == 0, &lwi);
+                                 atomic_read(&svcpt->scp_nreps_difficult) == 0,
+                                 &lwi);
                if (rc == 0)
                        break;
                CWARN("Unexpectedly long timeout %s %p\n",
@@ -2639,7 +2649,7 @@ ptlrpc_service_unlink_rqbd(struct ptlrpc_service *svc)
                 * event with its 'unlink' flag set for each posted rqbd
                 */
                list_for_each_entry(rqbd, &svcpt->scp_rqbd_posted,
-                                       rqbd_list) {
+                                   rqbd_list) {
                        rc = LNetMDUnlink(rqbd->rqbd_md_h);
                        LASSERT(rc == 0 || rc == -ENOENT);
                }