LU-14876 out: don't connect to busy MDS-MDS export

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

diff --git a/lustre/ptlrpc/service.c b/lustre/ptlrpc/service.c
index 9bc2bcd..6a68a19 100644 (file)
--- a/lustre/ptlrpc/service.c
+++ b/lustre/ptlrpc/service.c
@@ -448,9 +448,9 @@ static int ptlrpc_server_post_idle_rqbds(struct ptlrpc_service_part *svcpt)
                        return posted;
                }
 
-               rqbd = list_entry(svcpt->scp_rqbd_idle.next,
-                                     struct ptlrpc_request_buffer_desc,
-                                     rqbd_list);
+               rqbd = list_first_entry(&svcpt->scp_rqbd_idle,
+                                       struct ptlrpc_request_buffer_desc,
+                                       rqbd_list);
 
                /* assume we will post successfully */
                svcpt->scp_nrqbds_posted++;
@@ -949,9 +949,9 @@ void ptlrpc_server_drop_request(struct ptlrpc_request *req)
                 * I expect only about 1 or 2 rqbds need to be recycled here
                 */
                while (svcpt->scp_hist_nrqbds > svc->srv_hist_nrqbds_cpt_max) {
-                       rqbd = list_entry(svcpt->scp_hist_rqbds.next,
-                                         struct ptlrpc_request_buffer_desc,
-                                         rqbd_list);
+                       rqbd = list_first_entry(&svcpt->scp_hist_rqbds,
+                                               struct ptlrpc_request_buffer_desc,
+                                               rqbd_list);
 
                        list_del(&rqbd->rqbd_list);
                        svcpt->scp_hist_nrqbds--;
@@ -1616,9 +1616,9 @@ static int ptlrpc_at_check_timed(struct ptlrpc_service_part *svcpt)
         * we took additional refcount so entries can't be deleted from list, no
         * locking is needed
         */
-       while (!list_empty(&work_list)) {
-               rq = list_entry(work_list.next, struct ptlrpc_request,
-                               rq_timed_list);
+       while ((rq = list_first_entry_or_null(&work_list,
+                                             struct ptlrpc_request,
+                                             rq_timed_list)) != NULL) {
                list_del_init(&rq->rq_timed_list);
 
                if (ptlrpc_at_send_early_reply(rq) == 0)
@@ -1644,13 +1644,6 @@ ptlrpc_server_check_resend_in_progress(struct ptlrpc_request *req)
                return NULL;
 
        /*
-        * bulk request are aborted upon reconnect, don't try to
-        * find a match
-        */
-       if (req->rq_bulk_write || req->rq_bulk_read)
-               return NULL;
-
-       /*
         * This list should not be longer than max_requests in
         * flights on the client, so it is not all that long.
         * Also we only hit this codepath in case of a resent
@@ -2064,8 +2057,8 @@ static int ptlrpc_server_handle_req_in(struct ptlrpc_service_part *svcpt,
                RETURN(0);
        }
 
-       req = list_entry(svcpt->scp_req_incoming.next,
-                            struct ptlrpc_request, rq_list);
+       req = list_first_entry(&svcpt->scp_req_incoming,
+                              struct ptlrpc_request, rq_list);
        list_del_init(&req->rq_list);
        svcpt->scp_nreqs_incoming--;
        /*
@@ -3097,9 +3090,9 @@ static void ptlrpc_svcpt_stop_threads(struct ptlrpc_service_part *svcpt)
 
        wake_up_all(&svcpt->scp_waitq);
 
-       while (!list_empty(&svcpt->scp_threads)) {
-               thread = list_entry(svcpt->scp_threads.next,
-                                       struct ptlrpc_thread, t_link);
+       while ((thread = list_first_entry_or_null(&svcpt->scp_threads,
+                                                 struct ptlrpc_thread,
+                                                 t_link)) != NULL) {
                if (thread_is_stopped(thread)) {
                        list_move(&thread->t_link, &zombie);
                        continue;
@@ -3116,9 +3109,9 @@ static void ptlrpc_svcpt_stop_threads(struct ptlrpc_service_part *svcpt)
 
        spin_unlock(&svcpt->scp_lock);
 
-       while (!list_empty(&zombie)) {
-               thread = list_entry(zombie.next,
-                                       struct ptlrpc_thread, t_link);
+       while ((thread = list_first_entry_or_null(&zombie,
+                                                 struct ptlrpc_thread,
+                                                 t_link)) != NULL) {
                list_del(&thread->t_link);
                OBD_FREE_PTR(thread);
        }
@@ -3474,9 +3467,9 @@ ptlrpc_service_purge_all(struct ptlrpc_service *svc)
                        break;
 
                spin_lock(&svcpt->scp_rep_lock);
-               while (!list_empty(&svcpt->scp_rep_active)) {
-                       rs = list_entry(svcpt->scp_rep_active.next,
-                                           struct ptlrpc_reply_state, rs_list);
+               while ((rs = list_first_entry_or_null(&svcpt->scp_rep_active,
+                                                     struct ptlrpc_reply_state,
+                                                     rs_list)) != NULL) {
                        spin_lock(&rs->rs_lock);
                        ptlrpc_schedule_difficult_reply(rs);
                        spin_unlock(&rs->rs_lock);
@@ -3488,10 +3481,9 @@ ptlrpc_service_purge_all(struct ptlrpc_service *svc)
                 * all unlinked) and no service threads, so I'm the only
                 * thread noodling the request queue now
                 */
-               while (!list_empty(&svcpt->scp_req_incoming)) {
-                       req = list_entry(svcpt->scp_req_incoming.next,
-                                            struct ptlrpc_request, rq_list);
-
+               while ((req = list_first_entry_or_null(&svcpt->scp_req_incoming,
+                                                      struct ptlrpc_request,
+                                                      rq_list)) != NULL) {
                        list_del(&req->rq_list);
                        svcpt->scp_nreqs_incoming--;
                        ptlrpc_server_finish_request(svcpt, req);
@@ -3531,19 +3523,16 @@ ptlrpc_service_purge_all(struct ptlrpc_service *svc)
                 * Now free all the request buffers since nothing
                 * references them any more...
                 */
-
-               while (!list_empty(&svcpt->scp_rqbd_idle)) {
-                       rqbd = list_entry(svcpt->scp_rqbd_idle.next,
-                                             struct ptlrpc_request_buffer_desc,
-                                             rqbd_list);
+               while ((rqbd = list_first_entry_or_null(&svcpt->scp_rqbd_idle,
+                                                       struct ptlrpc_request_buffer_desc,
+                                                       rqbd_list)) != NULL)
                        ptlrpc_free_rqbd(rqbd);
-               }
+
                ptlrpc_wait_replies(svcpt);
 
-               while (!list_empty(&svcpt->scp_rep_idle)) {
-                       rs = list_entry(svcpt->scp_rep_idle.next,
-                                           struct ptlrpc_reply_state,
-                                           rs_list);
+               while ((rs = list_first_entry_or_null(&svcpt->scp_rep_idle,
+                                                     struct ptlrpc_reply_state,
+                                                     rs_list)) != NULL) {
                        list_del(&rs->rs_list);
                        OBD_FREE_LARGE(rs, svc->srv_max_reply_size);
                }