Merge tag 'nfs-rdma-for-5.3-1' of git://git.linux-nfs.org/projects/anna/linux-nfs

[mirror_ubuntu-jammy-kernel.git] / net / sunrpc / xprt.c

diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index b1f54b7ccc0cdd8c80ff6741d3c235bad2e8d501..70a704c44c6d01cef42dc428a4f5e39ad8f99c98 100644 (file)
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -302,9 +302,9 @@ static inline int xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task)
 
        if (test_bit(XPRT_LOCKED, &xprt->state) && xprt->snd_task == task)
                return 1;
-       spin_lock_bh(&xprt->transport_lock);
+       spin_lock(&xprt->transport_lock);
        retval = xprt->ops->reserve_xprt(xprt, task);
-       spin_unlock_bh(&xprt->transport_lock);
+       spin_unlock(&xprt->transport_lock);
        return retval;
 }
 
@@ -381,9 +381,9 @@ static inline void xprt_release_write(struct rpc_xprt *xprt, struct rpc_task *ta
 {
        if (xprt->snd_task != task)
                return;
-       spin_lock_bh(&xprt->transport_lock);
+       spin_lock(&xprt->transport_lock);
        xprt->ops->release_xprt(xprt, task);
-       spin_unlock_bh(&xprt->transport_lock);
+       spin_unlock(&xprt->transport_lock);
 }
 
 /*
@@ -435,9 +435,9 @@ xprt_request_get_cong(struct rpc_xprt *xprt, struct rpc_rqst *req)
 
        if (req->rq_cong)
                return true;
-       spin_lock_bh(&xprt->transport_lock);
+       spin_lock(&xprt->transport_lock);
        ret = __xprt_get_cong(xprt, req) != 0;
-       spin_unlock_bh(&xprt->transport_lock);
+       spin_unlock(&xprt->transport_lock);
        return ret;
 }
 EXPORT_SYMBOL_GPL(xprt_request_get_cong);
@@ -464,9 +464,9 @@ static void
 xprt_clear_congestion_window_wait(struct rpc_xprt *xprt)
 {
        if (test_and_clear_bit(XPRT_CWND_WAIT, &xprt->state)) {
-               spin_lock_bh(&xprt->transport_lock);
+               spin_lock(&xprt->transport_lock);
                __xprt_lock_write_next_cong(xprt);
-               spin_unlock_bh(&xprt->transport_lock);
+               spin_unlock(&xprt->transport_lock);
        }
 }
 
@@ -563,9 +563,9 @@ bool xprt_write_space(struct rpc_xprt *xprt)
 
        if (!test_bit(XPRT_WRITE_SPACE, &xprt->state))
                return false;
-       spin_lock_bh(&xprt->transport_lock);
+       spin_lock(&xprt->transport_lock);
        ret = xprt_clear_write_space_locked(xprt);
-       spin_unlock_bh(&xprt->transport_lock);
+       spin_unlock(&xprt->transport_lock);
        return ret;
 }
 EXPORT_SYMBOL_GPL(xprt_write_space);
@@ -634,9 +634,9 @@ int xprt_adjust_timeout(struct rpc_rqst *req)
                req->rq_retries = 0;
                xprt_reset_majortimeo(req);
                /* Reset the RTT counters == "slow start" */
-               spin_lock_bh(&xprt->transport_lock);
+               spin_lock(&xprt->transport_lock);
                rpc_init_rtt(req->rq_task->tk_client->cl_rtt, to->to_initval);
-               spin_unlock_bh(&xprt->transport_lock);
+               spin_unlock(&xprt->transport_lock);
                status = -ETIMEDOUT;
        }
 
@@ -668,11 +668,11 @@ static void xprt_autoclose(struct work_struct *work)
 void xprt_disconnect_done(struct rpc_xprt *xprt)
 {
        dprintk("RPC:       disconnected transport %p\n", xprt);
-       spin_lock_bh(&xprt->transport_lock);
+       spin_lock(&xprt->transport_lock);
        xprt_clear_connected(xprt);
        xprt_clear_write_space_locked(xprt);
        xprt_wake_pending_tasks(xprt, -ENOTCONN);
-       spin_unlock_bh(&xprt->transport_lock);
+       spin_unlock(&xprt->transport_lock);
 }
 EXPORT_SYMBOL_GPL(xprt_disconnect_done);
 
@@ -684,7 +684,7 @@ EXPORT_SYMBOL_GPL(xprt_disconnect_done);
 void xprt_force_disconnect(struct rpc_xprt *xprt)
 {
        /* Don't race with the test_bit() in xprt_clear_locked() */
-       spin_lock_bh(&xprt->transport_lock);
+       spin_lock(&xprt->transport_lock);
        set_bit(XPRT_CLOSE_WAIT, &xprt->state);
        /* Try to schedule an autoclose RPC call */
        if (test_and_set_bit(XPRT_LOCKED, &xprt->state) == 0)
@@ -692,7 +692,7 @@ void xprt_force_disconnect(struct rpc_xprt *xprt)
        else if (xprt->snd_task)
                rpc_wake_up_queued_task_set_status(&xprt->pending,
                                xprt->snd_task, -ENOTCONN);
-       spin_unlock_bh(&xprt->transport_lock);
+       spin_unlock(&xprt->transport_lock);
 }
 EXPORT_SYMBOL_GPL(xprt_force_disconnect);
 
@@ -726,7 +726,7 @@ xprt_request_retransmit_after_disconnect(struct rpc_task *task)
 void xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie)
 {
        /* Don't race with the test_bit() in xprt_clear_locked() */
-       spin_lock_bh(&xprt->transport_lock);
+       spin_lock(&xprt->transport_lock);
        if (cookie != xprt->connect_cookie)
                goto out;
        if (test_bit(XPRT_CLOSING, &xprt->state))
@@ -737,7 +737,7 @@ void xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie)
                queue_work(xprtiod_workqueue, &xprt->task_cleanup);
        xprt_wake_pending_tasks(xprt, -EAGAIN);
 out:
-       spin_unlock_bh(&xprt->transport_lock);
+       spin_unlock(&xprt->transport_lock);
 }
 
 static bool
@@ -750,6 +750,7 @@ static void
 xprt_schedule_autodisconnect(struct rpc_xprt *xprt)
        __must_hold(&xprt->transport_lock)
 {
+       xprt->last_used = jiffies;
        if (RB_EMPTY_ROOT(&xprt->recv_queue) && xprt_has_timer(xprt))
                mod_timer(&xprt->timer, xprt->last_used + xprt->idle_timeout);
 }
@@ -759,18 +760,13 @@ xprt_init_autodisconnect(struct timer_list *t)
 {
        struct rpc_xprt *xprt = from_timer(xprt, t, timer);
 
-       spin_lock(&xprt->transport_lock);
        if (!RB_EMPTY_ROOT(&xprt->recv_queue))
-               goto out_abort;
+               return;
        /* Reset xprt->last_used to avoid connect/autodisconnect cycling */
        xprt->last_used = jiffies;
        if (test_and_set_bit(XPRT_LOCKED, &xprt->state))
-               goto out_abort;
-       spin_unlock(&xprt->transport_lock);
+               return;
        queue_work(xprtiod_workqueue, &xprt->task_cleanup);
-       return;
-out_abort:
-       spin_unlock(&xprt->transport_lock);
 }
 
 bool xprt_lock_connect(struct rpc_xprt *xprt,
@@ -779,7 +775,7 @@ bool xprt_lock_connect(struct rpc_xprt *xprt,
 {
        bool ret = false;
 
-       spin_lock_bh(&xprt->transport_lock);
+       spin_lock(&xprt->transport_lock);
        if (!test_bit(XPRT_LOCKED, &xprt->state))
                goto out;
        if (xprt->snd_task != task)
@@ -787,13 +783,13 @@ bool xprt_lock_connect(struct rpc_xprt *xprt,
        xprt->snd_task = cookie;
        ret = true;
 out:
-       spin_unlock_bh(&xprt->transport_lock);
+       spin_unlock(&xprt->transport_lock);
        return ret;
 }
 
 void xprt_unlock_connect(struct rpc_xprt *xprt, void *cookie)
 {
-       spin_lock_bh(&xprt->transport_lock);
+       spin_lock(&xprt->transport_lock);
        if (xprt->snd_task != cookie)
                goto out;
        if (!test_bit(XPRT_LOCKED, &xprt->state))
@@ -802,7 +798,7 @@ void xprt_unlock_connect(struct rpc_xprt *xprt, void *cookie)
        xprt->ops->release_xprt(xprt, NULL);
        xprt_schedule_autodisconnect(xprt);
 out:
-       spin_unlock_bh(&xprt->transport_lock);
+       spin_unlock(&xprt->transport_lock);
        wake_up_bit(&xprt->state, XPRT_LOCKED);
 }
 
@@ -1444,14 +1440,14 @@ xprt_request_transmit(struct rpc_rqst *req, struct rpc_task *snd_task)
        xprt_inject_disconnect(xprt);
 
        task->tk_flags |= RPC_TASK_SENT;
-       spin_lock_bh(&xprt->transport_lock);
+       spin_lock(&xprt->transport_lock);
 
        xprt->stat.sends++;
        xprt->stat.req_u += xprt->stat.sends - xprt->stat.recvs;
        xprt->stat.bklog_u += xprt->backlog.qlen;
        xprt->stat.sending_u += xprt->sending.qlen;
        xprt->stat.pending_u += xprt->pending.qlen;
-       spin_unlock_bh(&xprt->transport_lock);
+       spin_unlock(&xprt->transport_lock);
 
        req->rq_connect_cookie = connect_cookie;
 out_dequeue:
@@ -1797,18 +1793,13 @@ void xprt_release(struct rpc_task *task)
        }
 
        xprt = req->rq_xprt;
-       if (task->tk_ops->rpc_count_stats != NULL)
-               task->tk_ops->rpc_count_stats(task, task->tk_calldata);
-       else if (task->tk_client)
-               rpc_count_iostats(task, task->tk_client->cl_metrics);
        xprt_request_dequeue_all(task, req);
-       spin_lock_bh(&xprt->transport_lock);
+       spin_lock(&xprt->transport_lock);
        xprt->ops->release_xprt(xprt, task);
        if (xprt->ops->release_request)
                xprt->ops->release_request(task);
-       xprt->last_used = jiffies;
        xprt_schedule_autodisconnect(xprt);
-       spin_unlock_bh(&xprt->transport_lock);
+       spin_unlock(&xprt->transport_lock);
        if (req->rq_buffer)
                xprt->ops->buf_free(task);
        xprt_inject_disconnect(xprt);
@@ -1908,9 +1899,7 @@ found:
                xprt->idle_timeout = 0;
        INIT_WORK(&xprt->task_cleanup, xprt_autoclose);
        if (xprt_has_timer(xprt))
-               timer_setup(&xprt->timer,
-                               xprt_init_autodisconnect,
-                               TIMER_DEFERRABLE);
+               timer_setup(&xprt->timer, xprt_init_autodisconnect, 0);
        else
                timer_setup(&xprt->timer, NULL, 0);