linux-rdma.vger.kernel.org archive mirror
 help / color / mirror / Atom feed
From: Bob Pearson <rpearsonhpe@gmail.com>
To: Zhu Yanjun <zyjzyj2000@gmail.com>
Cc: Jason Gunthorpe <jgg@nvidia.com>,
	RDMA mailing list <linux-rdma@vger.kernel.org>,
	mie@igel.co.jp, Bart Van Assche <bvanassche@acm.org>
Subject: Re: [PATCH for-rc v3 1/6] RDMA/rxe: Add memory barriers to kernel queues
Date: Thu, 9 Sep 2021 23:01:11 -0500	[thread overview]
Message-ID: <4ba88d4f-7a44-1d05-9a10-1c5ed12cc751@gmail.com> (raw)
In-Reply-To: <CAD=hENdMigPXzSsHX5jg=tNimZYVHVdKPfOCmn5WfTXA_Upy1w@mail.gmail.com>

On 9/9/21 8:19 PM, Zhu Yanjun wrote:
> On Fri, Sep 10, 2021 at 4:46 AM Bob Pearson <rpearsonhpe@gmail.com> wrote:
>>
>> Earlier patches added memory barriers to protect user space to kernel
>> space communications. The user space queues were previously shown to
>> have occasional memory synchonization errors which were removed by
>> adding smp_load_acquire, smp_store_release barriers.
>>
>> This patch extends that to the case where queues are used between kernel
>> space threads.
>>
>> Signed-off-by: Bob Pearson <rpearsonhpe@gmail.com>
>> ---
>>  drivers/infiniband/sw/rxe/rxe_comp.c  | 10 +---
>>  drivers/infiniband/sw/rxe/rxe_cq.c    | 25 ++-------
>>  drivers/infiniband/sw/rxe/rxe_qp.c    | 10 ++--
>>  drivers/infiniband/sw/rxe/rxe_queue.h | 73 ++++++++-------------------
>>  drivers/infiniband/sw/rxe/rxe_req.c   | 21 ++------
>>  drivers/infiniband/sw/rxe/rxe_resp.c  | 38 ++++----------
>>  drivers/infiniband/sw/rxe/rxe_srq.c   |  2 +-
>>  drivers/infiniband/sw/rxe/rxe_verbs.c | 53 ++++---------------
>>  8 files changed, 55 insertions(+), 177 deletions(-)
>>
>> diff --git a/drivers/infiniband/sw/rxe/rxe_comp.c b/drivers/infiniband/sw/rxe/rxe_comp.c
>> index d2d802c776fd..ed4e3f29bd65 100644
>> --- a/drivers/infiniband/sw/rxe/rxe_comp.c
>> +++ b/drivers/infiniband/sw/rxe/rxe_comp.c
>> @@ -142,10 +142,7 @@ static inline enum comp_state get_wqe(struct rxe_qp *qp,
>>         /* we come here whether or not we found a response packet to see if
>>          * there are any posted WQEs
>>          */
>> -       if (qp->is_user)
>> -               wqe = queue_head(qp->sq.queue, QUEUE_TYPE_FROM_USER);
>> -       else
>> -               wqe = queue_head(qp->sq.queue, QUEUE_TYPE_KERNEL);
> 
> This commit is very similar to the commit in
> https://lore.kernel.org/linux-rdma/20210902084640.679744-5-yangx.jy@fujitsu.com/T/
> 
> Zhu Yanjun
> 
>> +       wqe = queue_head(qp->sq.queue, QUEUE_TYPE_FROM_CLIENT);
>>         *wqe_p = wqe;
>>
>>         /* no WQE or requester has not started it yet */
>> @@ -432,10 +429,7 @@ static void do_complete(struct rxe_qp *qp, struct rxe_send_wqe *wqe)
>>         if (post)
>>                 make_send_cqe(qp, wqe, &cqe);
>>
>> -       if (qp->is_user)
>> -               advance_consumer(qp->sq.queue, QUEUE_TYPE_FROM_USER);
>> -       else
>> -               advance_consumer(qp->sq.queue, QUEUE_TYPE_KERNEL);
>> +       advance_consumer(qp->sq.queue, QUEUE_TYPE_FROM_CLIENT);
>>
>>         if (post)
>>                 rxe_cq_post(qp->scq, &cqe, 0);
>> diff --git a/drivers/infiniband/sw/rxe/rxe_cq.c b/drivers/infiniband/sw/rxe/rxe_cq.c
>> index aef288f164fd..4e26c2ea4a59 100644
>> --- a/drivers/infiniband/sw/rxe/rxe_cq.c
>> +++ b/drivers/infiniband/sw/rxe/rxe_cq.c
>> @@ -25,11 +25,7 @@ int rxe_cq_chk_attr(struct rxe_dev *rxe, struct rxe_cq *cq,
>>         }
>>
>>         if (cq) {
>> -               if (cq->is_user)
>> -                       count = queue_count(cq->queue, QUEUE_TYPE_TO_USER);
>> -               else
>> -                       count = queue_count(cq->queue, QUEUE_TYPE_KERNEL);
>> -
>> +               count = queue_count(cq->queue, QUEUE_TYPE_TO_CLIENT);
>>                 if (cqe < count) {
>>                         pr_warn("cqe(%d) < current # elements in queue (%d)",
>>                                 cqe, count);
>> @@ -65,7 +61,7 @@ int rxe_cq_from_init(struct rxe_dev *rxe, struct rxe_cq *cq, int cqe,
>>         int err;
>>         enum queue_type type;
>>
>> -       type = uresp ? QUEUE_TYPE_TO_USER : QUEUE_TYPE_KERNEL;
>> +       type = QUEUE_TYPE_TO_CLIENT;
>>         cq->queue = rxe_queue_init(rxe, &cqe,
>>                         sizeof(struct rxe_cqe), type);
>>         if (!cq->queue) {
>> @@ -117,11 +113,7 @@ int rxe_cq_post(struct rxe_cq *cq, struct rxe_cqe *cqe, int solicited)
>>
>>         spin_lock_irqsave(&cq->cq_lock, flags);
>>
>> -       if (cq->is_user)
>> -               full = queue_full(cq->queue, QUEUE_TYPE_TO_USER);
>> -       else
>> -               full = queue_full(cq->queue, QUEUE_TYPE_KERNEL);
>> -
>> +       full = queue_full(cq->queue, QUEUE_TYPE_TO_CLIENT);
>>         if (unlikely(full)) {
>>                 spin_unlock_irqrestore(&cq->cq_lock, flags);
>>                 if (cq->ibcq.event_handler) {
>> @@ -134,17 +126,10 @@ int rxe_cq_post(struct rxe_cq *cq, struct rxe_cqe *cqe, int solicited)
>>                 return -EBUSY;
>>         }
>>
>> -       if (cq->is_user)
>> -               addr = producer_addr(cq->queue, QUEUE_TYPE_TO_USER);
>> -       else
>> -               addr = producer_addr(cq->queue, QUEUE_TYPE_KERNEL);
>> -
>> +       addr = producer_addr(cq->queue, QUEUE_TYPE_TO_CLIENT);
>>         memcpy(addr, cqe, sizeof(*cqe));
>>
>> -       if (cq->is_user)
>> -               advance_producer(cq->queue, QUEUE_TYPE_TO_USER);
>> -       else
>> -               advance_producer(cq->queue, QUEUE_TYPE_KERNEL);
>> +       advance_producer(cq->queue, QUEUE_TYPE_TO_CLIENT);
>>
>>         spin_unlock_irqrestore(&cq->cq_lock, flags);
>>
>> diff --git a/drivers/infiniband/sw/rxe/rxe_qp.c b/drivers/infiniband/sw/rxe/rxe_qp.c
>> index 1ab6af7ddb25..2e923af642f8 100644
>> --- a/drivers/infiniband/sw/rxe/rxe_qp.c
>> +++ b/drivers/infiniband/sw/rxe/rxe_qp.c
>> @@ -231,7 +231,7 @@ static int rxe_qp_init_req(struct rxe_dev *rxe, struct rxe_qp *qp,
>>         qp->sq.max_inline = init->cap.max_inline_data = wqe_size;
>>         wqe_size += sizeof(struct rxe_send_wqe);
>>
>> -       type = uresp ? QUEUE_TYPE_FROM_USER : QUEUE_TYPE_KERNEL;
>> +       type = QUEUE_TYPE_FROM_CLIENT;
>>         qp->sq.queue = rxe_queue_init(rxe, &qp->sq.max_wr,
>>                                 wqe_size, type);
>>         if (!qp->sq.queue)
>> @@ -248,12 +248,8 @@ static int rxe_qp_init_req(struct rxe_dev *rxe, struct rxe_qp *qp,
>>                 return err;
>>         }
>>
>> -       if (qp->is_user)
>>                 qp->req.wqe_index = producer_index(qp->sq.queue,
>> -                                               QUEUE_TYPE_FROM_USER);
>> -       else
>> -               qp->req.wqe_index = producer_index(qp->sq.queue,
>> -                                               QUEUE_TYPE_KERNEL);
>> +                                       QUEUE_TYPE_FROM_CLIENT);
>>
>>         qp->req.state           = QP_STATE_RESET;
>>         qp->req.opcode          = -1;
>> @@ -293,7 +289,7 @@ static int rxe_qp_init_resp(struct rxe_dev *rxe, struct rxe_qp *qp,
>>                 pr_debug("qp#%d max_wr = %d, max_sge = %d, wqe_size = %d\n",
>>                          qp_num(qp), qp->rq.max_wr, qp->rq.max_sge, wqe_size);
>>
>> -               type = uresp ? QUEUE_TYPE_FROM_USER : QUEUE_TYPE_KERNEL;
>> +               type = QUEUE_TYPE_FROM_CLIENT;
>>                 qp->rq.queue = rxe_queue_init(rxe, &qp->rq.max_wr,
>>                                         wqe_size, type);
>>                 if (!qp->rq.queue)
>> diff --git a/drivers/infiniband/sw/rxe/rxe_queue.h b/drivers/infiniband/sw/rxe/rxe_queue.h
>> index 2702b0e55fc3..d465aa9342e1 100644
>> --- a/drivers/infiniband/sw/rxe/rxe_queue.h
>> +++ b/drivers/infiniband/sw/rxe/rxe_queue.h
>> @@ -35,9 +35,8 @@
>>
>>  /* type of queue */
>>  enum queue_type {
>> -       QUEUE_TYPE_KERNEL,
>> -       QUEUE_TYPE_TO_USER,
>> -       QUEUE_TYPE_FROM_USER,
>> +       QUEUE_TYPE_TO_CLIENT,
>> +       QUEUE_TYPE_FROM_CLIENT,
>>  };
>>
>>  struct rxe_queue {
>> @@ -87,20 +86,16 @@ static inline int queue_empty(struct rxe_queue *q, enum queue_type type)
>>         u32 cons;
>>
>>         switch (type) {
>> -       case QUEUE_TYPE_FROM_USER:
>> +       case QUEUE_TYPE_FROM_CLIENT:
>>                 /* protect user space index */
>>                 prod = smp_load_acquire(&q->buf->producer_index);
>>                 cons = q->index;
>>                 break;
>> -       case QUEUE_TYPE_TO_USER:
>> +       case QUEUE_TYPE_TO_CLIENT:
>>                 prod = q->index;
>>                 /* protect user space index */
>>                 cons = smp_load_acquire(&q->buf->consumer_index);
>>                 break;
>> -       case QUEUE_TYPE_KERNEL:
>> -               prod = q->buf->producer_index;
>> -               cons = q->buf->consumer_index;
>> -               break;
>>         }
>>
>>         return ((prod - cons) & q->index_mask) == 0;
>> @@ -112,20 +107,16 @@ static inline int queue_full(struct rxe_queue *q, enum queue_type type)
>>         u32 cons;
>>
>>         switch (type) {
>> -       case QUEUE_TYPE_FROM_USER:
>> +       case QUEUE_TYPE_FROM_CLIENT:
>>                 /* protect user space index */
>>                 prod = smp_load_acquire(&q->buf->producer_index);
>>                 cons = q->index;
>>                 break;
>> -       case QUEUE_TYPE_TO_USER:
>> +       case QUEUE_TYPE_TO_CLIENT:
>>                 prod = q->index;
>>                 /* protect user space index */
>>                 cons = smp_load_acquire(&q->buf->consumer_index);
>>                 break;
>> -       case QUEUE_TYPE_KERNEL:
>> -               prod = q->buf->producer_index;
>> -               cons = q->buf->consumer_index;
>> -               break;
>>         }
>>
>>         return ((prod + 1 - cons) & q->index_mask) == 0;
>> @@ -138,20 +129,16 @@ static inline unsigned int queue_count(const struct rxe_queue *q,
>>         u32 cons;
>>
>>         switch (type) {
>> -       case QUEUE_TYPE_FROM_USER:
>> +       case QUEUE_TYPE_FROM_CLIENT:
>>                 /* protect user space index */
>>                 prod = smp_load_acquire(&q->buf->producer_index);
>>                 cons = q->index;
>>                 break;
>> -       case QUEUE_TYPE_TO_USER:
>> +       case QUEUE_TYPE_TO_CLIENT:
>>                 prod = q->index;
>>                 /* protect user space index */
>>                 cons = smp_load_acquire(&q->buf->consumer_index);
>>                 break;
>> -       case QUEUE_TYPE_KERNEL:
>> -               prod = q->buf->producer_index;
>> -               cons = q->buf->consumer_index;
>> -               break;
>>         }
>>
>>         return (prod - cons) & q->index_mask;
>> @@ -162,7 +149,7 @@ static inline void advance_producer(struct rxe_queue *q, enum queue_type type)
>>         u32 prod;
>>
>>         switch (type) {
>> -       case QUEUE_TYPE_FROM_USER:
>> +       case QUEUE_TYPE_FROM_CLIENT:
>>                 pr_warn_once("Normally kernel should not write user space index\n");
>>                 /* protect user space index */
>>                 prod = smp_load_acquire(&q->buf->producer_index);
>> @@ -170,15 +157,11 @@ static inline void advance_producer(struct rxe_queue *q, enum queue_type type)
>>                 /* same */
>>                 smp_store_release(&q->buf->producer_index, prod);
>>                 break;
>> -       case QUEUE_TYPE_TO_USER:
>> +       case QUEUE_TYPE_TO_CLIENT:
>>                 prod = q->index;
>>                 q->index = (prod + 1) & q->index_mask;
>>                 q->buf->producer_index = q->index;
>>                 break;
>> -       case QUEUE_TYPE_KERNEL:
>> -               prod = q->buf->producer_index;
>> -               q->buf->producer_index = (prod + 1) & q->index_mask;
>> -               break;
>>         }
>>  }
>>
>> @@ -187,12 +170,12 @@ static inline void advance_consumer(struct rxe_queue *q, enum queue_type type)
>>         u32 cons;
>>
>>         switch (type) {
>> -       case QUEUE_TYPE_FROM_USER:
>> +       case QUEUE_TYPE_FROM_CLIENT:
>>                 cons = q->index;
>>                 q->index = (cons + 1) & q->index_mask;
>>                 q->buf->consumer_index = q->index;
>>                 break;
>> -       case QUEUE_TYPE_TO_USER:
>> +       case QUEUE_TYPE_TO_CLIENT:
>>                 pr_warn_once("Normally kernel should not write user space index\n");
>>                 /* protect user space index */
>>                 cons = smp_load_acquire(&q->buf->consumer_index);
>> @@ -200,10 +183,6 @@ static inline void advance_consumer(struct rxe_queue *q, enum queue_type type)
>>                 /* same */
>>                 smp_store_release(&q->buf->consumer_index, cons);
>>                 break;
>> -       case QUEUE_TYPE_KERNEL:
>> -               cons = q->buf->consumer_index;
>> -               q->buf->consumer_index = (cons + 1) & q->index_mask;
>> -               break;
>>         }
>>  }
>>
>> @@ -212,17 +191,14 @@ static inline void *producer_addr(struct rxe_queue *q, enum queue_type type)
>>         u32 prod;
>>
>>         switch (type) {
>> -       case QUEUE_TYPE_FROM_USER:
>> +       case QUEUE_TYPE_FROM_CLIENT:
>>                 /* protect user space index */
>>                 prod = smp_load_acquire(&q->buf->producer_index);
>>                 prod &= q->index_mask;
>>                 break;
>> -       case QUEUE_TYPE_TO_USER:
>> +       case QUEUE_TYPE_TO_CLIENT:
>>                 prod = q->index;
>>                 break;
>> -       case QUEUE_TYPE_KERNEL:
>> -               prod = q->buf->producer_index;
>> -               break;
>>         }
>>
>>         return q->buf->data + (prod << q->log2_elem_size);
>> @@ -233,17 +209,14 @@ static inline void *consumer_addr(struct rxe_queue *q, enum queue_type type)
>>         u32 cons;
>>
>>         switch (type) {
>> -       case QUEUE_TYPE_FROM_USER:
>> +       case QUEUE_TYPE_FROM_CLIENT:
>>                 cons = q->index;
>>                 break;
>> -       case QUEUE_TYPE_TO_USER:
>> +       case QUEUE_TYPE_TO_CLIENT:
>>                 /* protect user space index */
>>                 cons = smp_load_acquire(&q->buf->consumer_index);
>>                 cons &= q->index_mask;
>>                 break;
>> -       case QUEUE_TYPE_KERNEL:
>> -               cons = q->buf->consumer_index;
>> -               break;
>>         }
>>
>>         return q->buf->data + (cons << q->log2_elem_size);
>> @@ -255,17 +228,14 @@ static inline unsigned int producer_index(struct rxe_queue *q,
>>         u32 prod;
>>
>>         switch (type) {
>> -       case QUEUE_TYPE_FROM_USER:
>> +       case QUEUE_TYPE_FROM_CLIENT:
>>                 /* protect user space index */
>>                 prod = smp_load_acquire(&q->buf->producer_index);
>>                 prod &= q->index_mask;
>>                 break;
>> -       case QUEUE_TYPE_TO_USER:
>> +       case QUEUE_TYPE_TO_CLIENT:
>>                 prod = q->index;
>>                 break;
>> -       case QUEUE_TYPE_KERNEL:
>> -               prod = q->buf->producer_index;
>> -               break;
>>         }
>>
>>         return prod;
>> @@ -277,17 +247,14 @@ static inline unsigned int consumer_index(struct rxe_queue *q,
>>         u32 cons;
>>
>>         switch (type) {
>> -       case QUEUE_TYPE_FROM_USER:
>> +       case QUEUE_TYPE_FROM_CLIENT:
>>                 cons = q->index;
>>                 break;
>> -       case QUEUE_TYPE_TO_USER:
>> +       case QUEUE_TYPE_TO_CLIENT:
>>                 /* protect user space index */
>>                 cons = smp_load_acquire(&q->buf->consumer_index);
>>                 cons &= q->index_mask;
>>                 break;
>> -       case QUEUE_TYPE_KERNEL:
>> -               cons = q->buf->consumer_index;
>> -               break;
>>         }
>>
>>         return cons;
>> diff --git a/drivers/infiniband/sw/rxe/rxe_req.c b/drivers/infiniband/sw/rxe/rxe_req.c
>> index 3894197a82f6..22c3edb28945 100644
>> --- a/drivers/infiniband/sw/rxe/rxe_req.c
>> +++ b/drivers/infiniband/sw/rxe/rxe_req.c
>> @@ -49,13 +49,8 @@ static void req_retry(struct rxe_qp *qp)
>>         unsigned int cons;
>>         unsigned int prod;
>>
>> -       if (qp->is_user) {
>> -               cons = consumer_index(q, QUEUE_TYPE_FROM_USER);
>> -               prod = producer_index(q, QUEUE_TYPE_FROM_USER);
>> -       } else {
>> -               cons = consumer_index(q, QUEUE_TYPE_KERNEL);
>> -               prod = producer_index(q, QUEUE_TYPE_KERNEL);
>> -       }
>> +       cons = consumer_index(q, QUEUE_TYPE_FROM_CLIENT);
>> +       prod = producer_index(q, QUEUE_TYPE_FROM_CLIENT);
>>
>>         qp->req.wqe_index       = cons;
>>         qp->req.psn             = qp->comp.psn;
>> @@ -121,15 +116,9 @@ static struct rxe_send_wqe *req_next_wqe(struct rxe_qp *qp)
>>         unsigned int cons;
>>         unsigned int prod;
>>
>> -       if (qp->is_user) {
>> -               wqe = queue_head(q, QUEUE_TYPE_FROM_USER);
>> -               cons = consumer_index(q, QUEUE_TYPE_FROM_USER);
>> -               prod = producer_index(q, QUEUE_TYPE_FROM_USER);
>> -       } else {
>> -               wqe = queue_head(q, QUEUE_TYPE_KERNEL);
>> -               cons = consumer_index(q, QUEUE_TYPE_KERNEL);
>> -               prod = producer_index(q, QUEUE_TYPE_KERNEL);
>> -       }
>> +       wqe = queue_head(q, QUEUE_TYPE_FROM_CLIENT);
>> +       cons = consumer_index(q, QUEUE_TYPE_FROM_CLIENT);
>> +       prod = producer_index(q, QUEUE_TYPE_FROM_CLIENT);
>>
>>         if (unlikely(qp->req.state == QP_STATE_DRAIN)) {
>>                 /* check to see if we are drained;
>> diff --git a/drivers/infiniband/sw/rxe/rxe_resp.c b/drivers/infiniband/sw/rxe/rxe_resp.c
>> index 5501227ddc65..596be002d33d 100644
>> --- a/drivers/infiniband/sw/rxe/rxe_resp.c
>> +++ b/drivers/infiniband/sw/rxe/rxe_resp.c
>> @@ -303,10 +303,7 @@ static enum resp_states get_srq_wqe(struct rxe_qp *qp)
>>
>>         spin_lock_bh(&srq->rq.consumer_lock);
>>
>> -       if (qp->is_user)
>> -               wqe = queue_head(q, QUEUE_TYPE_FROM_USER);
>> -       else
>> -               wqe = queue_head(q, QUEUE_TYPE_KERNEL);
>> +       wqe = queue_head(q, QUEUE_TYPE_FROM_CLIENT);
>>         if (!wqe) {
>>                 spin_unlock_bh(&srq->rq.consumer_lock);
>>                 return RESPST_ERR_RNR;
>> @@ -322,13 +319,8 @@ static enum resp_states get_srq_wqe(struct rxe_qp *qp)
>>         memcpy(&qp->resp.srq_wqe, wqe, size);
>>
>>         qp->resp.wqe = &qp->resp.srq_wqe.wqe;
>> -       if (qp->is_user) {
>> -               advance_consumer(q, QUEUE_TYPE_FROM_USER);
>> -               count = queue_count(q, QUEUE_TYPE_FROM_USER);
>> -       } else {
>> -               advance_consumer(q, QUEUE_TYPE_KERNEL);
>> -               count = queue_count(q, QUEUE_TYPE_KERNEL);
>> -       }
>> +       advance_consumer(q, QUEUE_TYPE_FROM_CLIENT);
>> +       count = queue_count(q, QUEUE_TYPE_FROM_CLIENT);
>>
>>         if (srq->limit && srq->ibsrq.event_handler && (count < srq->limit)) {
>>                 srq->limit = 0;
>> @@ -357,12 +349,8 @@ static enum resp_states check_resource(struct rxe_qp *qp,
>>                         qp->resp.status = IB_WC_WR_FLUSH_ERR;
>>                         return RESPST_COMPLETE;
>>                 } else if (!srq) {
>> -                       if (qp->is_user)
>> -                               qp->resp.wqe = queue_head(qp->rq.queue,
>> -                                               QUEUE_TYPE_FROM_USER);
>> -                       else
>> -                               qp->resp.wqe = queue_head(qp->rq.queue,
>> -                                               QUEUE_TYPE_KERNEL);
>> +                       qp->resp.wqe = queue_head(qp->rq.queue,
>> +                                       QUEUE_TYPE_FROM_CLIENT);
>>                         if (qp->resp.wqe) {
>>                                 qp->resp.status = IB_WC_WR_FLUSH_ERR;
>>                                 return RESPST_COMPLETE;
>> @@ -389,12 +377,8 @@ static enum resp_states check_resource(struct rxe_qp *qp,
>>                 if (srq)
>>                         return get_srq_wqe(qp);
>>
>> -               if (qp->is_user)
>> -                       qp->resp.wqe = queue_head(qp->rq.queue,
>> -                                       QUEUE_TYPE_FROM_USER);
>> -               else
>> -                       qp->resp.wqe = queue_head(qp->rq.queue,
>> -                                       QUEUE_TYPE_KERNEL);
>> +               qp->resp.wqe = queue_head(qp->rq.queue,
>> +                               QUEUE_TYPE_FROM_CLIENT);
>>                 return (qp->resp.wqe) ? RESPST_CHK_LENGTH : RESPST_ERR_RNR;
>>         }
>>
>> @@ -936,12 +920,8 @@ static enum resp_states do_complete(struct rxe_qp *qp,
>>         }
>>
>>         /* have copy for srq and reference for !srq */
>> -       if (!qp->srq) {
>> -               if (qp->is_user)
>> -                       advance_consumer(qp->rq.queue, QUEUE_TYPE_FROM_USER);
>> -               else
>> -                       advance_consumer(qp->rq.queue, QUEUE_TYPE_KERNEL);
>> -       }
>> +       if (!qp->srq)
>> +               advance_consumer(qp->rq.queue, QUEUE_TYPE_FROM_CLIENT);
>>
>>         qp->resp.wqe = NULL;
>>
>> diff --git a/drivers/infiniband/sw/rxe/rxe_srq.c b/drivers/infiniband/sw/rxe/rxe_srq.c
>> index 610c98d24b5c..a9e7817e2732 100644
>> --- a/drivers/infiniband/sw/rxe/rxe_srq.c
>> +++ b/drivers/infiniband/sw/rxe/rxe_srq.c
>> @@ -93,7 +93,7 @@ int rxe_srq_from_init(struct rxe_dev *rxe, struct rxe_srq *srq,
>>         spin_lock_init(&srq->rq.producer_lock);
>>         spin_lock_init(&srq->rq.consumer_lock);
>>
>> -       type = uresp ? QUEUE_TYPE_FROM_USER : QUEUE_TYPE_KERNEL;
>> +       type = QUEUE_TYPE_FROM_CLIENT;
>>         q = rxe_queue_init(rxe, &srq->rq.max_wr,
>>                         srq_wqe_size, type);
>>         if (!q) {
>> diff --git a/drivers/infiniband/sw/rxe/rxe_verbs.c b/drivers/infiniband/sw/rxe/rxe_verbs.c
>> index 267b5a9c345d..dc70e3edeba6 100644
>> --- a/drivers/infiniband/sw/rxe/rxe_verbs.c
>> +++ b/drivers/infiniband/sw/rxe/rxe_verbs.c
>> @@ -218,11 +218,7 @@ static int post_one_recv(struct rxe_rq *rq, const struct ib_recv_wr *ibwr)
>>         int num_sge = ibwr->num_sge;
>>         int full;
>>
>> -       if (rq->is_user)
>> -               full = queue_full(rq->queue, QUEUE_TYPE_FROM_USER);
>> -       else
>> -               full = queue_full(rq->queue, QUEUE_TYPE_KERNEL);
>> -
>> +       full = queue_full(rq->queue, QUEUE_TYPE_FROM_CLIENT);
>>         if (unlikely(full)) {
>>                 err = -ENOMEM;
>>                 goto err1;
>> @@ -237,11 +233,7 @@ static int post_one_recv(struct rxe_rq *rq, const struct ib_recv_wr *ibwr)
>>         for (i = 0; i < num_sge; i++)
>>                 length += ibwr->sg_list[i].length;
>>
>> -       if (rq->is_user)
>> -               recv_wqe = producer_addr(rq->queue, QUEUE_TYPE_FROM_USER);
>> -       else
>> -               recv_wqe = producer_addr(rq->queue, QUEUE_TYPE_KERNEL);
>> -
>> +       recv_wqe = producer_addr(rq->queue, QUEUE_TYPE_FROM_CLIENT);
>>         recv_wqe->wr_id = ibwr->wr_id;
>>         recv_wqe->num_sge = num_sge;
>>
>> @@ -254,10 +246,7 @@ static int post_one_recv(struct rxe_rq *rq, const struct ib_recv_wr *ibwr)
>>         recv_wqe->dma.cur_sge           = 0;
>>         recv_wqe->dma.sge_offset        = 0;
>>
>> -       if (rq->is_user)
>> -               advance_producer(rq->queue, QUEUE_TYPE_FROM_USER);
>> -       else
>> -               advance_producer(rq->queue, QUEUE_TYPE_KERNEL);
>> +       advance_producer(rq->queue, QUEUE_TYPE_FROM_CLIENT);
>>
>>         return 0;
>>
>> @@ -633,27 +622,17 @@ static int post_one_send(struct rxe_qp *qp, const struct ib_send_wr *ibwr,
>>
>>         spin_lock_irqsave(&qp->sq.sq_lock, flags);
>>
>> -       if (qp->is_user)
>> -               full = queue_full(sq->queue, QUEUE_TYPE_FROM_USER);
>> -       else
>> -               full = queue_full(sq->queue, QUEUE_TYPE_KERNEL);
>> +       full = queue_full(sq->queue, QUEUE_TYPE_FROM_CLIENT);
>>
>>         if (unlikely(full)) {
>>                 spin_unlock_irqrestore(&qp->sq.sq_lock, flags);
>>                 return -ENOMEM;
>>         }
>>
>> -       if (qp->is_user)
>> -               send_wqe = producer_addr(sq->queue, QUEUE_TYPE_FROM_USER);
>> -       else
>> -               send_wqe = producer_addr(sq->queue, QUEUE_TYPE_KERNEL);
>> -
>> +       send_wqe = producer_addr(sq->queue, QUEUE_TYPE_FROM_CLIENT);
>>         init_send_wqe(qp, ibwr, mask, length, send_wqe);
>>
>> -       if (qp->is_user)
>> -               advance_producer(sq->queue, QUEUE_TYPE_FROM_USER);
>> -       else
>> -               advance_producer(sq->queue, QUEUE_TYPE_KERNEL);
>> +       advance_producer(sq->queue, QUEUE_TYPE_FROM_CLIENT);
>>
>>         spin_unlock_irqrestore(&qp->sq.sq_lock, flags);
>>
>> @@ -845,18 +824,12 @@ static int rxe_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *wc)
>>
>>         spin_lock_irqsave(&cq->cq_lock, flags);
>>         for (i = 0; i < num_entries; i++) {
>> -               if (cq->is_user)
>> -                       cqe = queue_head(cq->queue, QUEUE_TYPE_TO_USER);
>> -               else
>> -                       cqe = queue_head(cq->queue, QUEUE_TYPE_KERNEL);
>> +               cqe = queue_head(cq->queue, QUEUE_TYPE_TO_CLIENT);
>>                 if (!cqe)
>>                         break;
>>
>>                 memcpy(wc++, &cqe->ibwc, sizeof(*wc));
>> -               if (cq->is_user)
>> -                       advance_consumer(cq->queue, QUEUE_TYPE_TO_USER);
>> -               else
>> -                       advance_consumer(cq->queue, QUEUE_TYPE_KERNEL);
>> +               advance_consumer(cq->queue, QUEUE_TYPE_TO_CLIENT);
>>         }
>>         spin_unlock_irqrestore(&cq->cq_lock, flags);
>>
>> @@ -868,10 +841,7 @@ static int rxe_peek_cq(struct ib_cq *ibcq, int wc_cnt)
>>         struct rxe_cq *cq = to_rcq(ibcq);
>>         int count;
>>
>> -       if (cq->is_user)
>> -               count = queue_count(cq->queue, QUEUE_TYPE_TO_USER);
>> -       else
>> -               count = queue_count(cq->queue, QUEUE_TYPE_KERNEL);
>> +       count = queue_count(cq->queue, QUEUE_TYPE_TO_CLIENT);
>>
>>         return (count > wc_cnt) ? wc_cnt : count;
>>  }
>> @@ -887,10 +857,7 @@ static int rxe_req_notify_cq(struct ib_cq *ibcq, enum ib_cq_notify_flags flags)
>>         if (cq->notify != IB_CQ_NEXT_COMP)
>>                 cq->notify = flags & IB_CQ_SOLICITED_MASK;
>>
>> -       if (cq->is_user)
>> -               empty = queue_empty(cq->queue, QUEUE_TYPE_TO_USER);
>> -       else
>> -               empty = queue_empty(cq->queue, QUEUE_TYPE_KERNEL);
>> +       empty = queue_empty(cq->queue, QUEUE_TYPE_TO_CLIENT);
>>
>>         if ((flags & IB_CQ_REPORT_MISSED_EVENTS) && !empty)
>>                 ret = 1;
>> --
>> 2.30.2
>>


It's the same one. In the cover letter that is called out. It still needs to get done.



Bob




  reply	other threads:[~2021-09-10  4:01 UTC|newest]

Thread overview: 22+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2021-09-09 20:44 [PATCH for-rc v3 0/6] RDMA/rxe: Various bug fixes Bob Pearson
2021-09-09 20:44 ` [PATCH for-rc v3 1/6] RDMA/rxe: Add memory barriers to kernel queues Bob Pearson
2021-09-10  1:19   ` Zhu Yanjun
2021-09-10  4:01     ` Bob Pearson [this message]
2021-09-14  6:04   ` 回复: " yangx.jy
2021-09-14 15:47     ` Bob Pearson
2021-09-09 20:44 ` [PATCH for-rc v3 2/6] RDMA/rxe: Fix memory allocation while locked Bob Pearson
2021-09-09 20:44 ` [PATCH for-rc v3 3/6] RDMA/rxe: Cleanup MR status and type enums Bob Pearson
2021-09-09 20:44 ` [PATCH for-rc v3 4/6] RDMA/rxe: Separate HW and SW l/rkeys Bob Pearson
2021-09-09 20:44 ` [PATCH for-rc v3 5/6] RDMA/rxe: Create duplicate mapping tables for FMRs Bob Pearson
2021-09-09 20:44 ` [PATCH for-rc v3 6/6] RDMA/rxe: Only allow invalidate for appropriate MRs Bob Pearson
2021-09-09 21:52 ` [PATCH for-rc v3 0/6] RDMA/rxe: Various bug fixes Bart Van Assche
2021-09-10 19:38   ` Pearson, Robert B
2021-09-10 20:23     ` Bart Van Assche
2021-09-10 21:16       ` Bob Pearson
2021-09-10 21:47       ` Bob Pearson
2021-09-10 21:50         ` Bob Pearson
2021-09-10 22:07         ` Bart Van Assche
2021-09-12 14:41           ` Bob Pearson
2021-09-14  3:26             ` Bart Van Assche
2021-09-14  4:18               ` Bob Pearson
2021-09-12 14:42           ` Bob Pearson

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=4ba88d4f-7a44-1d05-9a10-1c5ed12cc751@gmail.com \
    --to=rpearsonhpe@gmail.com \
    --cc=bvanassche@acm.org \
    --cc=jgg@nvidia.com \
    --cc=linux-rdma@vger.kernel.org \
    --cc=mie@igel.co.jp \
    --cc=zyjzyj2000@gmail.com \
    --subject='Re: [PATCH for-rc v3 1/6] RDMA/rxe: Add memory barriers to kernel queues' \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).