RDMA/rxe: Split rxe_run_task() into two subroutines

Split rxe_run_task(task, sched) into rxe_run_task(task) and
rxe_sched_task(task).

Link: https://lore.kernel.org/r/20221021200118.2163-5-rpearsonhpe@gmail.com
Signed-off-by: Ian Ziemba <ian.ziemba@hpe.com>
Signed-off-by: Bob Pearson <rpearsonhpe@gmail.com>
Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>

diff --git a/drivers/infiniband/sw/rxe/rxe_comp.c b/drivers/infiniband/sw/rxe/rxe_comp.c
index c9170dd99f3aa766e151396bf41a3aba6a6c132b..66f392810c860bfeced708320f7acb21cd6ef99b 100644 (file)
--- a/drivers/infiniband/sw/rxe/rxe_comp.c
+++ b/drivers/infiniband/sw/rxe/rxe_comp.c
@@ -118,7 +118,7 @@ void retransmit_timer(struct timer_list *t)
 
        if (qp->valid) {
                qp->comp.timeout = 1;
-               rxe_run_task(&qp->comp.task, 1);
+               rxe_sched_task(&qp->comp.task);
        }
 }
 
@@ -132,7 +132,10 @@ void rxe_comp_queue_pkt(struct rxe_qp *qp, struct sk_buff *skb)
        if (must_sched != 0)
                rxe_counter_inc(SKB_TO_PKT(skb)->rxe, RXE_CNT_COMPLETER_SCHED);
 
-       rxe_run_task(&qp->comp.task, must_sched);
+       if (must_sched)
+               rxe_sched_task(&qp->comp.task);
+       else
+               rxe_run_task(&qp->comp.task);
 }
 
 static inline enum comp_state get_wqe(struct rxe_qp *qp,
@@ -313,7 +316,7 @@ static inline enum comp_state check_ack(struct rxe_qp *qp,
                                        qp->comp.psn = pkt->psn;
                                        if (qp->req.wait_psn) {
                                                qp->req.wait_psn = 0;
-                                               rxe_run_task(&qp->req.task, 0);
+                                               rxe_run_task(&qp->req.task);
                                        }
                                }
                                return COMPST_ERROR_RETRY;
@@ -460,7 +463,7 @@ static void do_complete(struct rxe_qp *qp, struct rxe_send_wqe *wqe)
         */
        if (qp->req.wait_fence) {
                qp->req.wait_fence = 0;
-               rxe_run_task(&qp->req.task, 0);
+               rxe_run_task(&qp->req.task);
        }
 }
 
@@ -474,7 +477,7 @@ static inline enum comp_state complete_ack(struct rxe_qp *qp,
                if (qp->req.need_rd_atomic) {
                        qp->comp.timeout_retry = 0;
                        qp->req.need_rd_atomic = 0;
-                       rxe_run_task(&qp->req.task, 0);
+                       rxe_run_task(&qp->req.task);
                }
        }
 
@@ -520,7 +523,7 @@ static inline enum comp_state complete_wqe(struct rxe_qp *qp,
 
                if (qp->req.wait_psn) {
                        qp->req.wait_psn = 0;
-                       rxe_run_task(&qp->req.task, 1);
+                       rxe_sched_task(&qp->req.task);
                }
        }
 
@@ -654,7 +657,7 @@ int rxe_completer(void *arg)
 
                        if (qp->req.wait_psn) {
                                qp->req.wait_psn = 0;
-                               rxe_run_task(&qp->req.task, 1);
+                               rxe_sched_task(&qp->req.task);
                        }
 
                        state = COMPST_DONE;
@@ -722,7 +725,7 @@ int rxe_completer(void *arg)
                                                        RXE_CNT_COMP_RETRY);
                                        qp->req.need_retry = 1;
                                        qp->comp.started_retry = 1;
-                                       rxe_run_task(&qp->req.task, 0);
+                                       rxe_run_task(&qp->req.task);
                                }
                                goto done;
 

diff --git a/drivers/infiniband/sw/rxe/rxe_net.c b/drivers/infiniband/sw/rxe/rxe_net.c
index 35f327b9d4b8ec28e3435a73139149742f8128c7..c36cad9c7a6642759c0756194b6aa7c5ed10a62d 100644 (file)
--- a/drivers/infiniband/sw/rxe/rxe_net.c
+++ b/drivers/infiniband/sw/rxe/rxe_net.c
@@ -345,7 +345,7 @@ static void rxe_skb_tx_dtor(struct sk_buff *skb)
 
        if (unlikely(qp->need_req_skb &&
                     skb_out < RXE_INFLIGHT_SKBS_PER_QP_LOW))
-               rxe_run_task(&qp->req.task, 1);
+               rxe_sched_task(&qp->req.task);
 
        rxe_put(qp);
 }
@@ -429,7 +429,7 @@ int rxe_xmit_packet(struct rxe_qp *qp, struct rxe_pkt_info *pkt,
        if ((qp_type(qp) != IB_QPT_RC) &&
            (pkt->mask & RXE_END_MASK)) {
                pkt->wqe->state = wqe_state_done;
-               rxe_run_task(&qp->comp.task, 1);
+               rxe_sched_task(&qp->comp.task);
        }
 
        rxe_counter_inc(rxe, RXE_CNT_SENT_PKTS);

diff --git a/drivers/infiniband/sw/rxe/rxe_qp.c b/drivers/infiniband/sw/rxe/rxe_qp.c
index 03bd9f3e9956a947cf497e997e07d71cc676a329..3f6d62a80bea99fc736de10eb7dd7911798f16ad 100644 (file)
--- a/drivers/infiniband/sw/rxe/rxe_qp.c
+++ b/drivers/infiniband/sw/rxe/rxe_qp.c
@@ -536,10 +536,10 @@ static void rxe_qp_drain(struct rxe_qp *qp)
                if (qp->req.state != QP_STATE_DRAINED) {
                        qp->req.state = QP_STATE_DRAIN;
                        if (qp_type(qp) == IB_QPT_RC)
-                               rxe_run_task(&qp->comp.task, 1);
+                               rxe_sched_task(&qp->comp.task);
                        else
                                __rxe_do_task(&qp->comp.task);
-                       rxe_run_task(&qp->req.task, 1);
+                       rxe_sched_task(&qp->req.task);
                }
        }
 }
@@ -553,13 +553,13 @@ void rxe_qp_error(struct rxe_qp *qp)
        qp->attr.qp_state = IB_QPS_ERR;
 
        /* drain work and packet queues */
-       rxe_run_task(&qp->resp.task, 1);
+       rxe_sched_task(&qp->resp.task);
 
        if (qp_type(qp) == IB_QPT_RC)
-               rxe_run_task(&qp->comp.task, 1);
+               rxe_sched_task(&qp->comp.task);
        else
                __rxe_do_task(&qp->comp.task);
-       rxe_run_task(&qp->req.task, 1);
+       rxe_sched_task(&qp->req.task);
 }
 
 /* called by the modify qp verb */

diff --git a/drivers/infiniband/sw/rxe/rxe_req.c b/drivers/infiniband/sw/rxe/rxe_req.c
index f637712079705f85f7f4c3547c90b5284ce81cfe..41f1d84f0acbfcf92280b0c4e966449fafc7afd7 100644 (file)
--- a/drivers/infiniband/sw/rxe/rxe_req.c
+++ b/drivers/infiniband/sw/rxe/rxe_req.c
@@ -105,7 +105,7 @@ void rnr_nak_timer(struct timer_list *t)
        /* request a send queue retry */
        qp->req.need_retry = 1;
        qp->req.wait_for_rnr_timer = 0;
-       rxe_run_task(&qp->req.task, 1);
+       rxe_sched_task(&qp->req.task);
 }
 
 static struct rxe_send_wqe *req_next_wqe(struct rxe_qp *qp)
@@ -608,7 +608,7 @@ static int rxe_do_local_ops(struct rxe_qp *qp, struct rxe_send_wqe *wqe)
         * which can lead to a deadlock. So go ahead and complete
         * it now.
         */
-       rxe_run_task(&qp->comp.task, 1);
+       rxe_sched_task(&qp->comp.task);
 
        return 0;
 }
@@ -733,7 +733,7 @@ int rxe_requester(void *arg)
                                                       qp->req.wqe_index);
                        wqe->state = wqe_state_done;
                        wqe->status = IB_WC_SUCCESS;
-                       rxe_run_task(&qp->comp.task, 0);
+                       rxe_run_task(&qp->comp.task);
                        goto done;
                }
                payload = mtu;
@@ -795,7 +795,7 @@ int rxe_requester(void *arg)
                rollback_state(wqe, qp, &rollback_wqe, rollback_psn);
 
                if (err == -EAGAIN) {
-                       rxe_run_task(&qp->req.task, 1);
+                       rxe_sched_task(&qp->req.task);
                        goto exit;
                }
 
@@ -817,7 +817,7 @@ err:
        qp->req.wqe_index = queue_next_index(qp->sq.queue, qp->req.wqe_index);
        wqe->state = wqe_state_error;
        qp->req.state = QP_STATE_ERROR;
-       rxe_run_task(&qp->comp.task, 0);
+       rxe_run_task(&qp->comp.task);
 exit:
        ret = -EAGAIN;
 out:

diff --git a/drivers/infiniband/sw/rxe/rxe_resp.c b/drivers/infiniband/sw/rxe/rxe_resp.c
index 95d372db934d795899c0d854ee73d614e75fc945..c32bc12cc82f7e3046bc2d4851e2dd014e58368c 100644 (file)
--- a/drivers/infiniband/sw/rxe/rxe_resp.c
+++ b/drivers/infiniband/sw/rxe/rxe_resp.c
@@ -91,7 +91,10 @@ void rxe_resp_queue_pkt(struct rxe_qp *qp, struct sk_buff *skb)
        must_sched = (pkt->opcode == IB_OPCODE_RC_RDMA_READ_REQUEST) ||
                        (skb_queue_len(&qp->req_pkts) > 1);
 
-       rxe_run_task(&qp->resp.task, must_sched);
+       if (must_sched)
+               rxe_sched_task(&qp->resp.task);
+       else
+               rxe_run_task(&qp->resp.task);
 }
 
 static inline enum resp_states get_req(struct rxe_qp *qp,

diff --git a/drivers/infiniband/sw/rxe/rxe_task.c b/drivers/infiniband/sw/rxe/rxe_task.c
index 0cbba455fefd805ccf8846cc422c586709e76f31..442b7348acdc3539f25ecbecbaf8c5a6553ace1b 100644 (file)
--- a/drivers/infiniband/sw/rxe/rxe_task.c
+++ b/drivers/infiniband/sw/rxe/rxe_task.c
@@ -123,15 +123,20 @@ void rxe_cleanup_task(struct rxe_task *task)
        tasklet_kill(&task->tasklet);
 }
 
-void rxe_run_task(struct rxe_task *task, int sched)
+void rxe_run_task(struct rxe_task *task)
 {
        if (task->destroyed)
                return;
 
-       if (sched)
-               tasklet_schedule(&task->tasklet);
-       else
-               rxe_do_task(&task->tasklet);
+       rxe_do_task(&task->tasklet);
+}
+
+void rxe_sched_task(struct rxe_task *task)
+{
+       if (task->destroyed)
+               return;
+
+       tasklet_schedule(&task->tasklet);
 }
 
 void rxe_disable_task(struct rxe_task *task)

diff --git a/drivers/infiniband/sw/rxe/rxe_task.h b/drivers/infiniband/sw/rxe/rxe_task.h
index b3dfd970d1dc6b2d558d594e684364fc849cb9a0..590b1c1d7e7caf43be0f8f81f951cf5993fb5b22 100644 (file)
--- a/drivers/infiniband/sw/rxe/rxe_task.h
+++ b/drivers/infiniband/sw/rxe/rxe_task.h
@@ -52,10 +52,9 @@ int __rxe_do_task(struct rxe_task *task);
  */
 void rxe_do_task(struct tasklet_struct *t);
 
-/* run a task, else schedule it to run as a tasklet, The decision
- * to run or schedule tasklet is based on the parameter sched.
- */
-void rxe_run_task(struct rxe_task *task, int sched);
+void rxe_run_task(struct rxe_task *task);
+
+void rxe_sched_task(struct rxe_task *task);
 
 /* keep a task from scheduling */
 void rxe_disable_task(struct rxe_task *task);

diff --git a/drivers/infiniband/sw/rxe/rxe_verbs.c b/drivers/infiniband/sw/rxe/rxe_verbs.c
index 88825edc7dce19c0ac4a2806586fe68202e7d4aa..f2f82efbaf6d696ba51ff4391fdcb1ae14c9b407 100644 (file)
--- a/drivers/infiniband/sw/rxe/rxe_verbs.c
+++ b/drivers/infiniband/sw/rxe/rxe_verbs.c
@@ -695,9 +695,9 @@ static int rxe_post_send_kernel(struct rxe_qp *qp, const struct ib_send_wr *wr,
                wr = next;
        }
 
-       rxe_run_task(&qp->req.task, 1);
+       rxe_sched_task(&qp->req.task);
        if (unlikely(qp->req.state == QP_STATE_ERROR))
-               rxe_run_task(&qp->comp.task, 1);
+               rxe_sched_task(&qp->comp.task);
 
        return err;
 }
@@ -719,7 +719,7 @@ static int rxe_post_send(struct ib_qp *ibqp, const struct ib_send_wr *wr,
 
        if (qp->is_user) {
                /* Utilize process context to do protocol processing */
-               rxe_run_task(&qp->req.task, 0);
+               rxe_run_task(&qp->req.task);
                return 0;
        } else
                return rxe_post_send_kernel(qp, wr, bad_wr);
@@ -759,7 +759,7 @@ static int rxe_post_recv(struct ib_qp *ibqp, const struct ib_recv_wr *wr,
        spin_unlock_irqrestore(&rq->producer_lock, flags);
 
        if (qp->resp.state == QP_STATE_ERROR)
-               rxe_run_task(&qp->resp.task, 1);
+               rxe_sched_task(&qp->resp.task);
 
 err1:
        return err;