Merge branch 'work.misc' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

[cascardo/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 4788c49..72f3930 100644 (file)
--- a/drivers/staging/lustre/lustre/ptlrpc/service.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/service.c
@@ -1005,6 +1005,10 @@ 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;
@@ -1039,24 +1043,26 @@ 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);
+       newdl = req->rq_arrival_time.tv_sec + at_get(&svcpt->scp_at_estimate);
 
        /* Check to see if we've actually increased the deadline -
         * we may be past adaptive_max
         */
-       if (req->rq_deadline >= req->rq_arrival_time.tv_sec +
-           at_get(&svcpt->scp_at_estimate)) {
+       if (req->rq_deadline >= newdl) {
                DEBUG_REQ(D_WARNING, req, "Couldn't add any time (%ld/%lld), not sending early reply\n",
-                         olddl, req->rq_arrival_time.tv_sec +
-                         at_get(&svcpt->scp_at_estimate) -
-                         ktime_get_real_seconds());
+                         olddl, newdl - 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)
@@ -1982,11 +1988,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 +2056,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 +2356,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);
        }
@@ -2398,7 +2405,6 @@ int ptlrpc_start_threads(struct ptlrpc_service *svc)
        ptlrpc_stop_all_threads(svc);
        return rc;
 }
-EXPORT_SYMBOL(ptlrpc_start_threads);
 
 int ptlrpc_start_thread(struct ptlrpc_service_part *svcpt, int wait)
 {
@@ -2539,8 +2545,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 +2599,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 +2646,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);
                }