LU-1854 ptlrpc: track culled request seq

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

diff --git a/lustre/ptlrpc/service.c b/lustre/ptlrpc/service.c
index 28bb89a..672704d 100644 (file)
--- a/lustre/ptlrpc/service.c
+++ b/lustre/ptlrpc/service.c
@@ -65,6 +65,7 @@ CFS_MODULE_PARM(at_extra, "i", int, 0644,
 /* forward ref */
 static int ptlrpc_server_post_idle_rqbds(struct ptlrpc_service_part *svcpt);
 static void ptlrpc_hpreq_fini(struct ptlrpc_request *req);
+static void ptlrpc_at_remove_timed(struct ptlrpc_request *req);
 
 static CFS_LIST_HEAD(ptlrpc_all_services);
 cfs_spinlock_t ptlrpc_all_services_lock;
@@ -175,6 +176,7 @@ ptlrpc_save_lock(struct ptlrpc_request *req,
                 rs->rs_no_ack = !!no_ack;
         }
 }
+EXPORT_SYMBOL(ptlrpc_save_lock);
 
 #ifdef __KERNEL__
 
@@ -391,6 +393,7 @@ ptlrpc_schedule_difficult_reply(struct ptlrpc_reply_state *rs)
         ptlrpc_dispatch_difficult_reply(rs);
         EXIT;
 }
+EXPORT_SYMBOL(ptlrpc_schedule_difficult_reply);
 
 void ptlrpc_commit_replies(struct obd_export *exp)
 {
@@ -418,6 +421,7 @@ void ptlrpc_commit_replies(struct obd_export *exp)
         rs_batch_fini(&batch);
         EXIT;
 }
+EXPORT_SYMBOL(ptlrpc_commit_replies);
 
 static int
 ptlrpc_server_post_idle_rqbds(struct ptlrpc_service_part *svcpt)
@@ -818,6 +822,7 @@ failed:
        ptlrpc_unregister_service(service);
        RETURN(ERR_PTR(rc));
 }
+EXPORT_SYMBOL(ptlrpc_register_service);
 
 /**
  * to actually free the request, must be called without holding svc_lock.
@@ -859,24 +864,16 @@ void ptlrpc_server_drop_request(struct ptlrpc_request *req)
                 return;
 
        if (req->rq_at_linked) {
-               struct ptlrpc_at_array *array = &svcpt->scp_at_array;
-                __u32 index = req->rq_at_index;
-
                cfs_spin_lock(&svcpt->scp_at_lock);
-
-                LASSERT(!cfs_list_empty(&req->rq_timed_list));
-                cfs_list_del_init(&req->rq_timed_list);
-                cfs_spin_lock(&req->rq_lock);
-                req->rq_at_linked = 0;
-                cfs_spin_unlock(&req->rq_lock);
-                array->paa_reqs_count[index]--;
-                array->paa_count--;
-
+               /* recheck with lock, in case it's unlinked by
+                * ptlrpc_at_check_timed() */
+               if (likely(req->rq_at_linked))
+                       ptlrpc_at_remove_timed(req);
                cfs_spin_unlock(&svcpt->scp_at_lock);
-       } else {
-               LASSERT(cfs_list_empty(&req->rq_timed_list));
        }
 
+       LASSERT(cfs_list_empty(&req->rq_timed_list));
+
         /* finalize request */
         if (req->rq_export) {
                 class_export_put(req->rq_export);
@@ -946,6 +943,10 @@ void ptlrpc_server_drop_request(struct ptlrpc_request *req)
                cfs_list_del(&req->rq_list);
                cfs_list_del_init(&req->rq_history_list);
 
+               /* Track the highest culled req seq */
+               if (req->rq_history_seq > svcpt->scp_hist_seq_culled)
+                       svcpt->scp_hist_seq_culled = req->rq_history_seq;
+
                cfs_spin_unlock(&svcpt->scp_lock);
 
                ptlrpc_server_free_request(req);
@@ -1179,6 +1180,25 @@ static int ptlrpc_at_add_timed(struct ptlrpc_request *req)
        return 0;
 }
 
+static void
+ptlrpc_at_remove_timed(struct ptlrpc_request *req)
+{
+       struct ptlrpc_at_array *array;
+
+       array = &req->rq_rqbd->rqbd_svcpt->scp_at_array;
+
+       /* NB: must call with hold svcpt::scp_at_lock */
+       LASSERT(!cfs_list_empty(&req->rq_timed_list));
+       cfs_list_del_init(&req->rq_timed_list);
+
+       cfs_spin_lock(&req->rq_lock);
+       req->rq_at_linked = 0;
+       cfs_spin_unlock(&req->rq_lock);
+
+       array->paa_reqs_count[req->rq_at_index]--;
+       array->paa_count--;
+}
+
 static int ptlrpc_at_send_early_reply(struct ptlrpc_request *req)
 {
        struct ptlrpc_service_part *svcpt = req->rq_rqbd->rqbd_svcpt;
@@ -1362,29 +1382,23 @@ static int ptlrpc_at_check_timed(struct ptlrpc_service_part *svcpt)
                 cfs_list_for_each_entry_safe(rq, n,
                                              &array->paa_reqs_array[index],
                                              rq_timed_list) {
-                        if (rq->rq_deadline <= now + at_early_margin) {
-                                cfs_list_del_init(&rq->rq_timed_list);
-                                /**
-                                 * ptlrpc_server_drop_request() may drop
-                                 * refcount to 0 already. Let's check this and
-                                 * don't add entry to work_list
-                                 */
-                                if (likely(cfs_atomic_inc_not_zero(&rq->rq_refcount)))
-                                        cfs_list_add(&rq->rq_timed_list, &work_list);
-                                counter++;
-                                array->paa_reqs_count[index]--;
-                                array->paa_count--;
-                                cfs_spin_lock(&rq->rq_lock);
-                                rq->rq_at_linked = 0;
-                                cfs_spin_unlock(&rq->rq_lock);
-                                continue;
-                        }
-
-                        /* update the earliest deadline */
-                        if (deadline == -1 || rq->rq_deadline < deadline)
-                                deadline = rq->rq_deadline;
+                       if (rq->rq_deadline > now + at_early_margin) {
+                               /* update the earliest deadline */
+                               if (deadline == -1 ||
+                                   rq->rq_deadline < deadline)
+                                       deadline = rq->rq_deadline;
+                               break;
+                       }
 
-                        break;
+                       ptlrpc_at_remove_timed(rq);
+                       /**
+                        * ptlrpc_server_drop_request() may drop
+                        * refcount to 0 already. Let's check this and
+                        * don't add entry to work_list
+                        */
+                       if (likely(cfs_atomic_inc_not_zero(&rq->rq_refcount)))
+                               cfs_list_add(&rq->rq_timed_list, &work_list);
+                       counter++;
                 }
 
                 if (++index >= array->paa_size)
@@ -1548,6 +1562,7 @@ void ptlrpc_hpreq_reorder(struct ptlrpc_request *req)
        cfs_spin_unlock(&svcpt->scp_req_lock);
        EXIT;
 }
+EXPORT_SYMBOL(ptlrpc_hpreq_reorder);
 
 /** Check if the request is a high priority one. */
 static int ptlrpc_server_hpreq_check(struct ptlrpc_service *svc,
@@ -2689,6 +2704,7 @@ void ptlrpc_stop_all_threads(struct ptlrpc_service *svc)
 
        EXIT;
 }
+EXPORT_SYMBOL(ptlrpc_stop_all_threads);
 
 int ptlrpc_start_threads(struct ptlrpc_service *svc)
 {
@@ -2720,6 +2736,7 @@ 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)
 {
@@ -3116,6 +3133,7 @@ int ptlrpc_unregister_service(struct ptlrpc_service *service)
 
        RETURN(0);
 }
+EXPORT_SYMBOL(ptlrpc_unregister_service);
 
 /**
  * Returns 0 if the service is healthy.
@@ -3176,3 +3194,4 @@ ptlrpc_service_health_check(struct ptlrpc_service *svc)
        }
        return 0;
 }
+EXPORT_SYMBOL(ptlrpc_service_health_check);