Commit 21adfa7a authored by Bob Pearson's avatar Bob Pearson Committed by Jason Gunthorpe
Browse files

RDMA/rxe: Replace irqsave locks with bh locks 

Most of the locks in the rxe driver are _irqsave/restore locks but in fact
there are no interrupt threads that run rxe code or share data with
rxe. There are softirq threads and data sharing so the appropriate lock
type is _bh. This patch replaces all irqsave type locks with bh type
locks.

Link: https://lore.kernel.org/r/20211103050241.61293-2-rpearsonhpe@gmail.com


Signed-off-by: default avatarBob Pearson <rpearsonhpe@gmail.com>
Signed-off-by: default avatarJason Gunthorpe <jgg@nvidia.com>
parent 10f2d1cb

drivers/infiniband/sw/rxe/rxe_comp.c

+3 −5
Original line number Diff line number Diff line
@@ -458,8 +458,6 @@ static inline enum comp_state complete_ack(struct rxe_qp *qp, 
					   struct rxe_pkt_info *pkt,

					   struct rxe_send_wqe *wqe)

{

	unsigned long flags;



	if (wqe->has_rd_atomic) {

		wqe->has_rd_atomic = 0;

		atomic_inc(&qp->req.rd_atomic);
@@ -472,11 +470,11 @@ static inline enum comp_state complete_ack(struct rxe_qp *qp, 


	if (unlikely(qp->req.state == QP_STATE_DRAIN)) {

		/* state_lock used by requester & completer */

		spin_lock_irqsave(&qp->state_lock, flags);

		spin_lock_bh(&qp->state_lock);

		if ((qp->req.state == QP_STATE_DRAIN) &&

		    (qp->comp.psn == qp->req.psn)) {

			qp->req.state = QP_STATE_DRAINED;

			spin_unlock_irqrestore(&qp->state_lock, flags);

			spin_unlock_bh(&qp->state_lock);



			if (qp->ibqp.event_handler) {

				struct ib_event ev;
@@ -488,7 +486,7 @@ static inline enum comp_state complete_ack(struct rxe_qp *qp, 
					qp->ibqp.qp_context);

			}

		} else {

			spin_unlock_irqrestore(&qp->state_lock, flags);

			spin_unlock_bh(&qp->state_lock);

		}

	}

drivers/infiniband/sw/rxe/rxe_cq.c

+8 −12
Original line number Diff line number Diff line
@@ -42,14 +42,13 @@ int rxe_cq_chk_attr(struct rxe_dev *rxe, struct rxe_cq *cq, 
static void rxe_send_complete(struct tasklet_struct *t)

{

	struct rxe_cq *cq = from_tasklet(cq, t, comp_task);

	unsigned long flags;



	spin_lock_irqsave(&cq->cq_lock, flags);

	spin_lock_bh(&cq->cq_lock);

	if (cq->is_dying) {

		spin_unlock_irqrestore(&cq->cq_lock, flags);

		spin_unlock_bh(&cq->cq_lock);

		return;

	}

	spin_unlock_irqrestore(&cq->cq_lock, flags);

	spin_unlock_bh(&cq->cq_lock);



	cq->ibcq.comp_handler(&cq->ibcq, cq->ibcq.cq_context);

}
@@ -106,15 +105,14 @@ int rxe_cq_resize_queue(struct rxe_cq *cq, int cqe, 
int rxe_cq_post(struct rxe_cq *cq, struct rxe_cqe *cqe, int solicited)

{

	struct ib_event ev;

	unsigned long flags;

	int full;

	void *addr;



	spin_lock_irqsave(&cq->cq_lock, flags);

	spin_lock_bh(&cq->cq_lock);



	full = queue_full(cq->queue, QUEUE_TYPE_TO_CLIENT);

	if (unlikely(full)) {

		spin_unlock_irqrestore(&cq->cq_lock, flags);

		spin_unlock_bh(&cq->cq_lock);

		if (cq->ibcq.event_handler) {

			ev.device = cq->ibcq.device;

			ev.element.cq = &cq->ibcq;
@@ -130,7 +128,7 @@ int rxe_cq_post(struct rxe_cq *cq, struct rxe_cqe *cqe, int solicited) 


	queue_advance_producer(cq->queue, QUEUE_TYPE_TO_CLIENT);



	spin_unlock_irqrestore(&cq->cq_lock, flags);

	spin_unlock_bh(&cq->cq_lock);



	if ((cq->notify == IB_CQ_NEXT_COMP) ||

	    (cq->notify == IB_CQ_SOLICITED && solicited)) {
@@ -143,11 +141,9 @@ int rxe_cq_post(struct rxe_cq *cq, struct rxe_cqe *cqe, int solicited) 


void rxe_cq_disable(struct rxe_cq *cq)

{

	unsigned long flags;



	spin_lock_irqsave(&cq->cq_lock, flags);

	spin_lock_bh(&cq->cq_lock);

	cq->is_dying = true;

	spin_unlock_irqrestore(&cq->cq_lock, flags);

	spin_unlock_bh(&cq->cq_lock);

}



void rxe_cq_cleanup(struct rxe_pool_entry *arg)

drivers/infiniband/sw/rxe/rxe_mcast.c

+3 −4
Original line number Diff line number Diff line
@@ -40,12 +40,11 @@ int rxe_mcast_get_grp(struct rxe_dev *rxe, union ib_gid *mgid, 
	int err;

	struct rxe_mc_grp *grp;

	struct rxe_pool *pool = &rxe->mc_grp_pool;

	unsigned long flags;



	if (rxe->attr.max_mcast_qp_attach == 0)

		return -EINVAL;



	write_lock_irqsave(&pool->pool_lock, flags);

	write_lock_bh(&pool->pool_lock);



	grp = rxe_pool_get_key_locked(pool, mgid);

	if (grp)
@@ -53,13 +52,13 @@ int rxe_mcast_get_grp(struct rxe_dev *rxe, union ib_gid *mgid, 


	grp = create_grp(rxe, pool, mgid);

	if (IS_ERR(grp)) {

		write_unlock_irqrestore(&pool->pool_lock, flags);

		write_unlock_bh(&pool->pool_lock);

		err = PTR_ERR(grp);

		return err;

	}



done:

	write_unlock_irqrestore(&pool->pool_lock, flags);

	write_unlock_bh(&pool->pool_lock);

	*grp_p = grp;

	return 0;

}

drivers/infiniband/sw/rxe/rxe_mw.c

+6 −9
Original line number Diff line number Diff line
@@ -56,11 +56,10 @@ int rxe_dealloc_mw(struct ib_mw *ibmw) 
{

	struct rxe_mw *mw = to_rmw(ibmw);

	struct rxe_pd *pd = to_rpd(ibmw->pd);

	unsigned long flags;



	spin_lock_irqsave(&mw->lock, flags);

	spin_lock_bh(&mw->lock);

	rxe_do_dealloc_mw(mw);

	spin_unlock_irqrestore(&mw->lock, flags);

	spin_unlock_bh(&mw->lock);



	rxe_drop_ref(mw);

	rxe_drop_ref(pd);
@@ -197,7 +196,6 @@ int rxe_bind_mw(struct rxe_qp *qp, struct rxe_send_wqe *wqe) 
	struct rxe_dev *rxe = to_rdev(qp->ibqp.device);

	u32 mw_rkey = wqe->wr.wr.mw.mw_rkey;

	u32 mr_lkey = wqe->wr.wr.mw.mr_lkey;

	unsigned long flags;



	mw = rxe_pool_get_index(&rxe->mw_pool, mw_rkey >> 8);

	if (unlikely(!mw)) {
@@ -225,7 +223,7 @@ int rxe_bind_mw(struct rxe_qp *qp, struct rxe_send_wqe *wqe) 
		mr = NULL;

	}



	spin_lock_irqsave(&mw->lock, flags);

	spin_lock_bh(&mw->lock);



	ret = rxe_check_bind_mw(qp, wqe, mw, mr);

	if (ret)
@@ -233,7 +231,7 @@ int rxe_bind_mw(struct rxe_qp *qp, struct rxe_send_wqe *wqe) 


	rxe_do_bind_mw(qp, wqe, mw, mr);

err_unlock:

	spin_unlock_irqrestore(&mw->lock, flags);

	spin_unlock_bh(&mw->lock);

err_drop_mr:

	if (mr)

		rxe_drop_ref(mr);
@@ -280,7 +278,6 @@ static void rxe_do_invalidate_mw(struct rxe_mw *mw) 
int rxe_invalidate_mw(struct rxe_qp *qp, u32 rkey)

{

	struct rxe_dev *rxe = to_rdev(qp->ibqp.device);

	unsigned long flags;

	struct rxe_mw *mw;

	int ret;
@@ -295,7 +292,7 @@ int rxe_invalidate_mw(struct rxe_qp *qp, u32 rkey) 
		goto err_drop_ref;

	}



	spin_lock_irqsave(&mw->lock, flags);

	spin_lock_bh(&mw->lock);



	ret = rxe_check_invalidate_mw(qp, mw);

	if (ret)
@@ -303,7 +300,7 @@ int rxe_invalidate_mw(struct rxe_qp *qp, u32 rkey) 


	rxe_do_invalidate_mw(mw);

err_unlock:

	spin_unlock_irqrestore(&mw->lock, flags);

	spin_unlock_bh(&mw->lock);

err_drop_ref:

	rxe_drop_ref(mw);

err:

drivers/infiniband/sw/rxe/rxe_pool.c

+12 −18
Original line number Diff line number Diff line
@@ -261,12 +261,11 @@ int __rxe_add_key_locked(struct rxe_pool_entry *elem, void *key) 
int __rxe_add_key(struct rxe_pool_entry *elem, void *key)

{

	struct rxe_pool *pool = elem->pool;

	unsigned long flags;

	int err;



	write_lock_irqsave(&pool->pool_lock, flags);

	write_lock_bh(&pool->pool_lock);

	err = __rxe_add_key_locked(elem, key);

	write_unlock_irqrestore(&pool->pool_lock, flags);

	write_unlock_bh(&pool->pool_lock);



	return err;

}
@@ -281,11 +280,10 @@ void __rxe_drop_key_locked(struct rxe_pool_entry *elem) 
void __rxe_drop_key(struct rxe_pool_entry *elem)

{

	struct rxe_pool *pool = elem->pool;

	unsigned long flags;



	write_lock_irqsave(&pool->pool_lock, flags);

	write_lock_bh(&pool->pool_lock);

	__rxe_drop_key_locked(elem);

	write_unlock_irqrestore(&pool->pool_lock, flags);

	write_unlock_bh(&pool->pool_lock);

}



int __rxe_add_index_locked(struct rxe_pool_entry *elem)
@@ -302,12 +300,11 @@ int __rxe_add_index_locked(struct rxe_pool_entry *elem) 
int __rxe_add_index(struct rxe_pool_entry *elem)

{

	struct rxe_pool *pool = elem->pool;

	unsigned long flags;

	int err;



	write_lock_irqsave(&pool->pool_lock, flags);

	write_lock_bh(&pool->pool_lock);

	err = __rxe_add_index_locked(elem);

	write_unlock_irqrestore(&pool->pool_lock, flags);

	write_unlock_bh(&pool->pool_lock);



	return err;

}
@@ -323,11 +320,10 @@ void __rxe_drop_index_locked(struct rxe_pool_entry *elem) 
void __rxe_drop_index(struct rxe_pool_entry *elem)

{

	struct rxe_pool *pool = elem->pool;

	unsigned long flags;



	write_lock_irqsave(&pool->pool_lock, flags);

	write_lock_bh(&pool->pool_lock);

	__rxe_drop_index_locked(elem);

	write_unlock_irqrestore(&pool->pool_lock, flags);

	write_unlock_bh(&pool->pool_lock);

}



void *rxe_alloc_locked(struct rxe_pool *pool)
@@ -447,11 +443,10 @@ void *rxe_pool_get_index_locked(struct rxe_pool *pool, u32 index) 
void *rxe_pool_get_index(struct rxe_pool *pool, u32 index)

{

	u8 *obj;

	unsigned long flags;



	read_lock_irqsave(&pool->pool_lock, flags);

	read_lock_bh(&pool->pool_lock);

	obj = rxe_pool_get_index_locked(pool, index);

	read_unlock_irqrestore(&pool->pool_lock, flags);

	read_unlock_bh(&pool->pool_lock);



	return obj;

}
@@ -493,11 +488,10 @@ void *rxe_pool_get_key_locked(struct rxe_pool *pool, void *key) 
void *rxe_pool_get_key(struct rxe_pool *pool, void *key)

{

	u8 *obj;

	unsigned long flags;



	read_lock_irqsave(&pool->pool_lock, flags);

	read_lock_bh(&pool->pool_lock);

	obj = rxe_pool_get_key_locked(pool, key);

	read_unlock_irqrestore(&pool->pool_lock, flags);

	read_unlock_bh(&pool->pool_lock);



	return obj;

}