Commit df158561 authored by Amrani, Ram's avatar Amrani, Ram Committed by Doug Ledford

RDMA/qedr: restructure functions that create/destroy QPs

Simplify function and sub-function flow of QP creation and destruction.
This also serves as a preparation for SRQ and iWARP support.
Signed-off-by: default avatarRam Amrani <Ram.Amrani@cavium.com>
Reviewed-by: default avatarMichal Kalderon <Michal.Kalderon@cavium.com>
Signed-off-by: default avatarDoug Ledford <dledford@redhat.com>
parent bb75f33c
...@@ -1076,30 +1076,6 @@ static inline int get_gid_info_from_table(struct ib_qp *ibqp, ...@@ -1076,30 +1076,6 @@ static inline int get_gid_info_from_table(struct ib_qp *ibqp,
return 0; return 0;
} }
static void qedr_cleanup_user_sq(struct qedr_dev *dev, struct qedr_qp *qp)
{
qedr_free_pbl(dev, &qp->usq.pbl_info, qp->usq.pbl_tbl);
ib_umem_release(qp->usq.umem);
}
static void qedr_cleanup_user_rq(struct qedr_dev *dev, struct qedr_qp *qp)
{
qedr_free_pbl(dev, &qp->urq.pbl_info, qp->urq.pbl_tbl);
ib_umem_release(qp->urq.umem);
}
static void qedr_cleanup_kernel_sq(struct qedr_dev *dev, struct qedr_qp *qp)
{
dev->ops->common->chain_free(dev->cdev, &qp->sq.pbl);
kfree(qp->wqe_wr_id);
}
static void qedr_cleanup_kernel_rq(struct qedr_dev *dev, struct qedr_qp *qp)
{
dev->ops->common->chain_free(dev->cdev, &qp->rq.pbl);
kfree(qp->rqe_wr_id);
}
static int qedr_check_qp_attrs(struct ib_pd *ibpd, struct qedr_dev *dev, static int qedr_check_qp_attrs(struct ib_pd *ibpd, struct qedr_dev *dev,
struct ib_qp_init_attr *attrs) struct ib_qp_init_attr *attrs)
{ {
...@@ -1188,15 +1164,13 @@ static int qedr_copy_qp_uresp(struct qedr_dev *dev, ...@@ -1188,15 +1164,13 @@ static int qedr_copy_qp_uresp(struct qedr_dev *dev,
return rc; return rc;
} }
static void qedr_set_qp_init_params(struct qedr_dev *dev, static void qedr_set_common_qp_params(struct qedr_dev *dev,
struct qedr_qp *qp, struct qedr_qp *qp,
struct qedr_pd *pd, struct qedr_pd *pd,
struct ib_qp_init_attr *attrs) struct ib_qp_init_attr *attrs)
{ {
qp->pd = pd;
spin_lock_init(&qp->q_lock); spin_lock_init(&qp->q_lock);
qp->pd = pd;
qp->qp_type = attrs->qp_type; qp->qp_type = attrs->qp_type;
qp->max_inline_data = attrs->cap.max_inline_data; qp->max_inline_data = attrs->cap.max_inline_data;
qp->sq.max_sges = attrs->cap.max_send_sge; qp->sq.max_sges = attrs->cap.max_send_sge;
...@@ -1205,7 +1179,11 @@ static void qedr_set_qp_init_params(struct qedr_dev *dev, ...@@ -1205,7 +1179,11 @@ static void qedr_set_qp_init_params(struct qedr_dev *dev,
qp->sq_cq = get_qedr_cq(attrs->send_cq); qp->sq_cq = get_qedr_cq(attrs->send_cq);
qp->rq_cq = get_qedr_cq(attrs->recv_cq); qp->rq_cq = get_qedr_cq(attrs->recv_cq);
qp->dev = dev; qp->dev = dev;
qp->rq.max_sges = attrs->cap.max_recv_sge;
DP_DEBUG(dev, QEDR_MSG_QP,
"RQ params:\trq_max_sges = %d, rq_cq_id = %d\n",
qp->rq.max_sges, qp->rq_cq->icid);
DP_DEBUG(dev, QEDR_MSG_QP, DP_DEBUG(dev, QEDR_MSG_QP,
"QP params:\tpd = %d, qp_type = %d, max_inline_data = %d, state = %d, signaled = %d, use_srq=%d\n", "QP params:\tpd = %d, qp_type = %d, max_inline_data = %d, state = %d, signaled = %d, use_srq=%d\n",
pd->pd_id, qp->qp_type, qp->max_inline_data, pd->pd_id, qp->qp_type, qp->max_inline_data,
...@@ -1213,95 +1191,149 @@ static void qedr_set_qp_init_params(struct qedr_dev *dev, ...@@ -1213,95 +1191,149 @@ static void qedr_set_qp_init_params(struct qedr_dev *dev,
DP_DEBUG(dev, QEDR_MSG_QP, DP_DEBUG(dev, QEDR_MSG_QP,
"SQ params:\tsq_max_sges = %d, sq_cq_id = %d\n", "SQ params:\tsq_max_sges = %d, sq_cq_id = %d\n",
qp->sq.max_sges, qp->sq_cq->icid); qp->sq.max_sges, qp->sq_cq->icid);
qp->rq.max_sges = attrs->cap.max_recv_sge;
DP_DEBUG(dev, QEDR_MSG_QP,
"RQ params:\trq_max_sges = %d, rq_cq_id = %d\n",
qp->rq.max_sges, qp->rq_cq->icid);
} }
static inline void static void qedr_set_roce_db_info(struct qedr_dev *dev, struct qedr_qp *qp)
qedr_init_qp_user_params(struct qed_rdma_create_qp_in_params *params,
struct qedr_create_qp_ureq *ureq)
{
/* QP handle to be written in CQE */
params->qp_handle_lo = ureq->qp_handle_lo;
params->qp_handle_hi = ureq->qp_handle_hi;
}
static inline void
qedr_init_qp_kernel_doorbell_sq(struct qedr_dev *dev, struct qedr_qp *qp)
{ {
qp->sq.db = dev->db_addr + qp->sq.db = dev->db_addr +
DB_ADDR_SHIFT(DQ_PWM_OFFSET_XCM_RDMA_SQ_PROD); DB_ADDR_SHIFT(DQ_PWM_OFFSET_XCM_RDMA_SQ_PROD);
qp->sq.db_data.data.icid = qp->icid + 1; qp->sq.db_data.data.icid = qp->icid + 1;
qp->rq.db = dev->db_addr +
DB_ADDR_SHIFT(DQ_PWM_OFFSET_TCM_ROCE_RQ_PROD);
qp->rq.db_data.data.icid = qp->icid;
} }
static inline void static inline void
qedr_init_qp_kernel_doorbell_rq(struct qedr_dev *dev, struct qedr_qp *qp) qedr_init_common_qp_in_params(struct qedr_dev *dev,
struct qedr_pd *pd,
struct qedr_qp *qp,
struct ib_qp_init_attr *attrs,
bool fmr_and_reserved_lkey,
struct qed_rdma_create_qp_in_params *params)
{ {
qp->rq.db = dev->db_addr + /* QP handle to be written in an async event */
DB_ADDR_SHIFT(DQ_PWM_OFFSET_TCM_ROCE_RQ_PROD); params->qp_handle_async_lo = lower_32_bits((uintptr_t) qp);
qp->rq.db_data.data.icid = qp->icid; params->qp_handle_async_hi = upper_32_bits((uintptr_t) qp);
params->signal_all = (attrs->sq_sig_type == IB_SIGNAL_ALL_WR);
params->fmr_and_reserved_lkey = fmr_and_reserved_lkey;
params->pd = pd->pd_id;
params->dpi = pd->uctx ? pd->uctx->dpi : dev->dpi;
params->sq_cq_id = get_qedr_cq(attrs->send_cq)->icid;
params->stats_queue = 0;
params->rq_cq_id = get_qedr_cq(attrs->recv_cq)->icid;
params->srq_id = 0;
params->use_srq = false;
} }
static inline int static inline void qedr_qp_user_print(struct qedr_dev *dev, struct qedr_qp *qp)
qedr_init_qp_kernel_params_rq(struct qedr_dev *dev,
struct qedr_qp *qp, struct ib_qp_init_attr *attrs)
{ {
/* Allocate driver internal RQ array */ DP_DEBUG(dev, QEDR_MSG_QP, "create qp: successfully created user QP. "
qp->rqe_wr_id = kcalloc(qp->rq.max_wr, sizeof(*qp->rqe_wr_id), "qp=%p. "
GFP_KERNEL); "sq_addr=0x%llx, "
if (!qp->rqe_wr_id) "sq_len=%zd, "
return -ENOMEM; "rq_addr=0x%llx, "
"rq_len=%zd"
"\n",
qp,
qp->usq.buf_addr,
qp->usq.buf_len, qp->urq.buf_addr, qp->urq.buf_len);
}
DP_DEBUG(dev, QEDR_MSG_QP, "RQ max_wr set to %d.\n", qp->rq.max_wr); static void qedr_cleanup_user(struct qedr_dev *dev, struct qedr_qp *qp)
{
if (qp->usq.umem)
ib_umem_release(qp->usq.umem);
qp->usq.umem = NULL;
return 0; if (qp->urq.umem)
ib_umem_release(qp->urq.umem);
qp->urq.umem = NULL;
} }
static inline int static int qedr_create_user_qp(struct qedr_dev *dev,
qedr_init_qp_kernel_params_sq(struct qedr_dev *dev,
struct qedr_qp *qp, struct qedr_qp *qp,
struct ib_qp_init_attr *attrs, struct ib_pd *ibpd,
struct qed_rdma_create_qp_in_params *params) struct ib_udata *udata,
struct ib_qp_init_attr *attrs)
{ {
u32 temp_max_wr; struct qed_rdma_create_qp_in_params in_params;
struct qed_rdma_create_qp_out_params out_params;
struct qedr_pd *pd = get_qedr_pd(ibpd);
struct ib_ucontext *ib_ctx = NULL;
struct qedr_ucontext *ctx = NULL;
struct qedr_create_qp_ureq ureq;
int rc = -EINVAL;
/* Allocate driver internal SQ array */ ib_ctx = ibpd->uobject->context;
temp_max_wr = attrs->cap.max_send_wr * dev->wq_multiplier; ctx = get_qedr_ucontext(ib_ctx);
temp_max_wr = min_t(u32, temp_max_wr, dev->attr.max_sqe);
/* temp_max_wr < attr->max_sqe < u16 so the casting is safe */ memset(&ureq, 0, sizeof(ureq));
qp->sq.max_wr = (u16)temp_max_wr; rc = ib_copy_from_udata(&ureq, udata, sizeof(ureq));
qp->wqe_wr_id = kcalloc(qp->sq.max_wr, sizeof(*qp->wqe_wr_id), if (rc) {
GFP_KERNEL); DP_ERR(dev, "Problem copying data from user space\n");
if (!qp->wqe_wr_id) return rc;
return -ENOMEM; }
DP_DEBUG(dev, QEDR_MSG_QP, "SQ max_wr set to %d.\n", qp->sq.max_wr); /* SQ - read access only (0), dma sync not required (0) */
rc = qedr_init_user_queue(ib_ctx, dev, &qp->usq, ureq.sq_addr,
ureq.sq_len, 0, 0);
if (rc)
return rc;
/* QP handle to be written in CQE */ /* RQ - read access only (0), dma sync not required (0) */
params->qp_handle_lo = lower_32_bits((uintptr_t)qp); rc = qedr_init_user_queue(ib_ctx, dev, &qp->urq, ureq.rq_addr,
params->qp_handle_hi = upper_32_bits((uintptr_t)qp); ureq.rq_len, 0, 0);
if (rc)
return rc;
memset(&in_params, 0, sizeof(in_params));
qedr_init_common_qp_in_params(dev, pd, qp, attrs, false, &in_params);
in_params.qp_handle_lo = ureq.qp_handle_lo;
in_params.qp_handle_hi = ureq.qp_handle_hi;
in_params.sq_num_pages = qp->usq.pbl_info.num_pbes;
in_params.sq_pbl_ptr = qp->usq.pbl_tbl->pa;
in_params.rq_num_pages = qp->urq.pbl_info.num_pbes;
in_params.rq_pbl_ptr = qp->urq.pbl_tbl->pa;
qp->qed_qp = dev->ops->rdma_create_qp(dev->rdma_ctx,
&in_params, &out_params);
if (!qp->qed_qp) {
rc = -ENOMEM;
goto err1;
}
qp->qp_id = out_params.qp_id;
qp->icid = out_params.icid;
rc = qedr_copy_qp_uresp(dev, qp, udata);
if (rc)
goto err;
qedr_qp_user_print(dev, qp);
return 0; return 0;
err:
rc = dev->ops->rdma_destroy_qp(dev->rdma_ctx, qp->qed_qp);
if (rc)
DP_ERR(dev, "create qp: fatal fault. rc=%d", rc);
err1:
qedr_cleanup_user(dev, qp);
return rc;
} }
static inline int qedr_init_qp_kernel_sq(struct qedr_dev *dev, static int
qedr_roce_create_kernel_qp(struct qedr_dev *dev,
struct qedr_qp *qp, struct qedr_qp *qp,
struct ib_qp_init_attr *attrs) struct qed_rdma_create_qp_in_params *in_params,
u32 n_sq_elems, u32 n_rq_elems)
{ {
u32 n_sq_elems, n_sq_entries; struct qed_rdma_create_qp_out_params out_params;
int rc; int rc;
/* A single work request may take up to QEDR_MAX_SQ_WQE_SIZE elements in
* the ring. The ring should allow at least a single WR, even if the
* user requested none, due to allocation issues.
*/
n_sq_entries = attrs->cap.max_send_wr;
n_sq_entries = min_t(u32, n_sq_entries, dev->attr.max_sqe);
n_sq_entries = max_t(u32, n_sq_entries, 1);
n_sq_elems = n_sq_entries * QEDR_MAX_SQE_ELEMENTS_PER_SQE;
rc = dev->ops->common->chain_alloc(dev->cdev, rc = dev->ops->common->chain_alloc(dev->cdev,
QED_CHAIN_USE_TO_PRODUCE, QED_CHAIN_USE_TO_PRODUCE,
QED_CHAIN_MODE_PBL, QED_CHAIN_MODE_PBL,
...@@ -1309,31 +1341,13 @@ static inline int qedr_init_qp_kernel_sq(struct qedr_dev *dev, ...@@ -1309,31 +1341,13 @@ static inline int qedr_init_qp_kernel_sq(struct qedr_dev *dev,
n_sq_elems, n_sq_elems,
QEDR_SQE_ELEMENT_SIZE, QEDR_SQE_ELEMENT_SIZE,
&qp->sq.pbl); &qp->sq.pbl);
if (rc) {
DP_ERR(dev, "failed to allocate QP %p SQ\n", qp); if (rc)
return rc; return rc;
}
DP_DEBUG(dev, QEDR_MSG_SQ, in_params->sq_num_pages = qed_chain_get_page_cnt(&qp->sq.pbl);
"SQ Pbl base addr = %llx max_send_wr=%d max_wr=%d capacity=%d, rc=%d\n", in_params->sq_pbl_ptr = qed_chain_get_pbl_phys(&qp->sq.pbl);
qed_chain_get_pbl_phys(&qp->sq.pbl), attrs->cap.max_send_wr,
n_sq_entries, qed_chain_get_capacity(&qp->sq.pbl), rc);
return 0;
}
static inline int qedr_init_qp_kernel_rq(struct qedr_dev *dev,
struct qedr_qp *qp,
struct ib_qp_init_attr *attrs)
{
u32 n_rq_elems, n_rq_entries;
int rc;
/* A single work request may take up to QEDR_MAX_RQ_WQE_SIZE elements in
* the ring. There ring should allow at least a single WR, even if the
* user requested none, due to allocation issues.
*/
n_rq_entries = max_t(u32, attrs->cap.max_recv_wr, 1);
n_rq_elems = n_rq_entries * QEDR_MAX_RQE_ELEMENTS_PER_RQE;
rc = dev->ops->common->chain_alloc(dev->cdev, rc = dev->ops->common->chain_alloc(dev->cdev,
QED_CHAIN_USE_TO_CONSUME_PRODUCE, QED_CHAIN_USE_TO_CONSUME_PRODUCE,
QED_CHAIN_MODE_PBL, QED_CHAIN_MODE_PBL,
...@@ -1341,136 +1355,102 @@ static inline int qedr_init_qp_kernel_rq(struct qedr_dev *dev, ...@@ -1341,136 +1355,102 @@ static inline int qedr_init_qp_kernel_rq(struct qedr_dev *dev,
n_rq_elems, n_rq_elems,
QEDR_RQE_ELEMENT_SIZE, QEDR_RQE_ELEMENT_SIZE,
&qp->rq.pbl); &qp->rq.pbl);
if (rc)
return rc;
if (rc) { in_params->rq_num_pages = qed_chain_get_page_cnt(&qp->rq.pbl);
DP_ERR(dev, "failed to allocate memory for QP %p RQ\n", qp); in_params->rq_pbl_ptr = qed_chain_get_pbl_phys(&qp->rq.pbl);
return -ENOMEM;
}
DP_DEBUG(dev, QEDR_MSG_RQ,
"RQ Pbl base addr = %llx max_recv_wr=%d max_wr=%d capacity=%d, rc=%d\n",
qed_chain_get_pbl_phys(&qp->rq.pbl), attrs->cap.max_recv_wr,
n_rq_entries, qed_chain_get_capacity(&qp->rq.pbl), rc);
/* n_rq_entries < u16 so the casting is safe */ qp->qed_qp = dev->ops->rdma_create_qp(dev->rdma_ctx,
qp->rq.max_wr = (u16)n_rq_entries; in_params, &out_params);
return 0; if (!qp->qed_qp)
} return -EINVAL;
static inline void qp->qp_id = out_params.qp_id;
qedr_init_qp_in_params_sq(struct qedr_dev *dev, qp->icid = out_params.icid;
struct qedr_pd *pd,
struct qedr_qp *qp,
struct ib_qp_init_attr *attrs,
struct ib_udata *udata,
struct qed_rdma_create_qp_in_params *params)
{
/* QP handle to be written in an async event */
params->qp_handle_async_lo = lower_32_bits((uintptr_t)qp);
params->qp_handle_async_hi = upper_32_bits((uintptr_t)qp);
params->signal_all = (attrs->sq_sig_type == IB_SIGNAL_ALL_WR); qedr_set_roce_db_info(dev, qp);
params->fmr_and_reserved_lkey = !udata;
params->pd = pd->pd_id;
params->dpi = pd->uctx ? pd->uctx->dpi : dev->dpi;
params->sq_cq_id = get_qedr_cq(attrs->send_cq)->icid;
params->max_sq_sges = 0;
params->stats_queue = 0;
if (udata) { return 0;
params->sq_num_pages = qp->usq.pbl_info.num_pbes;
params->sq_pbl_ptr = qp->usq.pbl_tbl->pa;
} else {
params->sq_num_pages = qed_chain_get_page_cnt(&qp->sq.pbl);
params->sq_pbl_ptr = qed_chain_get_pbl_phys(&qp->sq.pbl);
}
} }
static inline void static void qedr_cleanup_kernel(struct qedr_dev *dev, struct qedr_qp *qp)
qedr_init_qp_in_params_rq(struct qedr_qp *qp,
struct ib_qp_init_attr *attrs,
struct ib_udata *udata,
struct qed_rdma_create_qp_in_params *params)
{ {
params->rq_cq_id = get_qedr_cq(attrs->recv_cq)->icid; dev->ops->common->chain_free(dev->cdev, &qp->sq.pbl);
params->srq_id = 0; kfree(qp->wqe_wr_id);
params->use_srq = false;
if (udata) {
params->rq_num_pages = qp->urq.pbl_info.num_pbes;
params->rq_pbl_ptr = qp->urq.pbl_tbl->pa;
} else {
params->rq_num_pages = qed_chain_get_page_cnt(&qp->rq.pbl);
params->rq_pbl_ptr = qed_chain_get_pbl_phys(&qp->rq.pbl);
}
}
static inline void qedr_qp_user_print(struct qedr_dev *dev, struct qedr_qp *qp) dev->ops->common->chain_free(dev->cdev, &qp->rq.pbl);
{ kfree(qp->rqe_wr_id);
DP_DEBUG(dev, QEDR_MSG_QP,
"create qp: successfully created user QP. qp=%p, sq_addr=0x%llx, sq_len=%zd, rq_addr=0x%llx, rq_len=%zd\n",
qp, qp->usq.buf_addr, qp->usq.buf_len, qp->urq.buf_addr,
qp->urq.buf_len);
} }
static inline int qedr_init_user_qp(struct ib_ucontext *ib_ctx, static int qedr_create_kernel_qp(struct qedr_dev *dev,
struct qedr_dev *dev,
struct qedr_qp *qp, struct qedr_qp *qp,
struct qedr_create_qp_ureq *ureq) struct ib_pd *ibpd,
struct ib_qp_init_attr *attrs)
{ {
int rc; struct qed_rdma_create_qp_in_params in_params;
struct qedr_pd *pd = get_qedr_pd(ibpd);
int rc = -EINVAL;
u32 n_rq_elems;
u32 n_sq_elems;
u32 n_sq_entries;
/* SQ - read access only (0), dma sync not required (0) */ memset(&in_params, 0, sizeof(in_params));
rc = qedr_init_user_queue(ib_ctx, dev, &qp->usq, ureq->sq_addr,
ureq->sq_len, 0, 0);
if (rc)
return rc;
/* RQ - read access only (0), dma sync not required (0) */ /* A single work request may take up to QEDR_MAX_SQ_WQE_SIZE elements in
rc = qedr_init_user_queue(ib_ctx, dev, &qp->urq, ureq->rq_addr, * the ring. The ring should allow at least a single WR, even if the
ureq->rq_len, 0, 0); * user requested none, due to allocation issues.
* We should add an extra WR since the prod and cons indices of
* wqe_wr_id are managed in such a way that the WQ is considered full
* when (prod+1)%max_wr==cons. We currently don't do that because we
* double the number of entries due an iSER issue that pushes far more
* WRs than indicated. If we decline its ib_post_send() then we get
* error prints in the dmesg we'd like to avoid.
*/
qp->sq.max_wr = min_t(u32, attrs->cap.max_send_wr * dev->wq_multiplier,
dev->attr.max_sqe);
if (rc) qp->wqe_wr_id = kzalloc(qp->sq.max_wr * sizeof(*qp->wqe_wr_id),
qedr_cleanup_user_sq(dev, qp); GFP_KERNEL);
return rc; if (!qp->wqe_wr_id) {
} DP_ERR(dev, "create qp: failed SQ shadow memory allocation\n");
return -ENOMEM;
}
static inline int /* QP handle to be written in CQE */
qedr_init_kernel_qp(struct qedr_dev *dev, in_params.qp_handle_lo = lower_32_bits((uintptr_t) qp);
struct qedr_qp *qp, in_params.qp_handle_hi = upper_32_bits((uintptr_t) qp);
struct ib_qp_init_attr *attrs,
struct qed_rdma_create_qp_in_params *params)
{
int rc;
rc = qedr_init_qp_kernel_sq(dev, qp, attrs); /* A single work request may take up to QEDR_MAX_RQ_WQE_SIZE elements in
if (rc) { * the ring. There ring should allow at least a single WR, even if the
DP_ERR(dev, "failed to init kernel QP %p SQ\n", qp); * user requested none, due to allocation issues.
return rc; */
} qp->rq.max_wr = (u16) max_t(u32, attrs->cap.max_recv_wr, 1);
rc = qedr_init_qp_kernel_params_sq(dev, qp, attrs, params); /* Allocate driver internal RQ array */
if (rc) { qp->rqe_wr_id = kzalloc(qp->rq.max_wr * sizeof(*qp->rqe_wr_id),
dev->ops->common->chain_free(dev->cdev, &qp->sq.pbl); GFP_KERNEL);
DP_ERR(dev, "failed to init kernel QP %p SQ params\n", qp); if (!qp->rqe_wr_id) {
return rc; DP_ERR(dev,
"create qp: failed RQ shadow memory allocation\n");
kfree(qp->wqe_wr_id);
return -ENOMEM;
} }
rc = qedr_init_qp_kernel_rq(dev, qp, attrs); qedr_init_common_qp_in_params(dev, pd, qp, attrs, true, &in_params);
if (rc) {
qedr_cleanup_kernel_sq(dev, qp);
DP_ERR(dev, "failed to init kernel QP %p RQ\n", qp);
return rc;
}
rc = qedr_init_qp_kernel_params_rq(dev, qp, attrs); n_sq_entries = attrs->cap.max_send_wr;
if (rc) { n_sq_entries = min_t(u32, n_sq_entries, dev->attr.max_sqe);
DP_ERR(dev, "failed to init kernel QP %p RQ params\n", qp); n_sq_entries = max_t(u32, n_sq_entries, 1);
qedr_cleanup_kernel_sq(dev, qp); n_sq_elems = n_sq_entries * QEDR_MAX_SQE_ELEMENTS_PER_SQE;
dev->ops->common->chain_free(dev->cdev, &qp->rq.pbl);
return rc; n_rq_elems = qp->rq.max_wr * QEDR_MAX_RQE_ELEMENTS_PER_RQE;
}
rc = qedr_roce_create_kernel_qp(dev, qp, &in_params,
n_sq_elems, n_rq_elems);
if (rc)
qedr_cleanup_kernel(dev, qp);
return rc; return rc;
} }
...@@ -1480,12 +1460,7 @@ struct ib_qp *qedr_create_qp(struct ib_pd *ibpd, ...@@ -1480,12 +1460,7 @@ struct ib_qp *qedr_create_qp(struct ib_pd *ibpd,
struct ib_udata *udata) struct ib_udata *udata)
{ {
struct qedr_dev *dev = get_qedr_dev(ibpd->device); struct qedr_dev *dev = get_qedr_dev(ibpd->device);
struct qed_rdma_create_qp_out_params out_params;
struct qed_rdma_create_qp_in_params in_params;
struct qedr_pd *pd = get_qedr_pd(ibpd); struct qedr_pd *pd = get_qedr_pd(ibpd);
struct ib_ucontext *ib_ctx = NULL;
struct qedr_ucontext *ctx = NULL;
struct qedr_create_qp_ureq ureq;
struct qedr_qp *qp; struct qedr_qp *qp;
struct ib_qp *ibqp; struct ib_qp *ibqp;
int rc = 0; int rc = 0;
...@@ -1500,101 +1475,42 @@ struct ib_qp *qedr_create_qp(struct ib_pd *ibpd, ...@@ -1500,101 +1475,42 @@ struct ib_qp *qedr_create_qp(struct ib_pd *ibpd,
if (attrs->srq) if (attrs->srq)
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
qp = kzalloc(sizeof(*qp), GFP_KERNEL);
if (!qp)
return ERR_PTR(-ENOMEM);
DP_DEBUG(dev, QEDR_MSG_QP, DP_DEBUG(dev, QEDR_MSG_QP,
"create qp: sq_cq=%p, sq_icid=%d, rq_cq=%p, rq_icid=%d\n", "create qp: called from %s, event_handler=%p, eepd=%p sq_cq=%p, sq_icid=%d, rq_cq=%p, rq_icid=%d\n",
udata ? "user library" : "kernel", attrs->event_handler, pd,
get_qedr_cq(attrs->send_cq), get_qedr_cq(attrs->send_cq),
get_qedr_cq(attrs->send_cq)->icid, get_qedr_cq(attrs->send_cq)->icid,
get_qedr_cq(attrs->recv_cq), get_qedr_cq(attrs->recv_cq),
get_qedr_cq(attrs->recv_cq)->icid); get_qedr_cq(attrs->recv_cq)->icid);
qedr_set_qp_init_params(dev, qp, pd, attrs); qp = kzalloc(sizeof(*qp), GFP_KERNEL);
if (!qp) {
DP_ERR(dev, "create qp: failed allocating memory\n");
return ERR_PTR(-ENOMEM);
}
qedr_set_common_qp_params(dev, qp, pd, attrs);
if (attrs->qp_type == IB_QPT_GSI) { if (attrs->qp_type == IB_QPT_GSI) {
if (udata) {
DP_ERR(dev,
"create qp: unexpected udata when creating GSI QP\n");
goto err0;
}
ibqp = qedr_create_gsi_qp(dev, attrs, qp); ibqp = qedr_create_gsi_qp(dev, attrs, qp);
if (IS_ERR(ibqp)) if (IS_ERR(ibqp))
kfree(qp); kfree(qp);
return ibqp; return ibqp;
} }
memset(&in_params, 0, sizeof(in_params)); if (udata)
rc = qedr_create_user_qp(dev, qp, ibpd, udata, attrs);
if (udata) { else
if (!(udata && ibpd->uobject && ibpd->uobject->context)) rc = qedr_create_kernel_qp(dev, qp, ibpd, attrs);
goto err0;
ib_ctx = ibpd->uobject->context;
ctx = get_qedr_ucontext(ib_ctx);
memset(&ureq, 0, sizeof(ureq));
if (ib_copy_from_udata(&ureq, udata, sizeof(ureq))) {
DP_ERR(dev,
"create qp: problem copying data from user space\n");
goto err0;
}
rc = qedr_init_user_qp(ib_ctx, dev, qp, &ureq);
if (rc)
goto err0;
qedr_init_qp_user_params(&in_params, &ureq);
} else {
rc = qedr_init_kernel_qp(dev, qp, attrs, &in_params);
if (rc) if (rc)
goto err0; goto err;
}
qedr_init_qp_in_params_sq(dev, pd, qp, attrs, udata, &in_params);
qedr_init_qp_in_params_rq(qp, attrs, udata, &in_params);
qp->qed_qp = dev->ops->rdma_create_qp(dev->rdma_ctx,
&in_params, &out_params);
if (!qp->qed_qp)
goto err1;
qp->qp_id = out_params.qp_id;
qp->icid = out_params.icid;
qp->ibqp.qp_num = qp->qp_id; qp->ibqp.qp_num = qp->qp_id;
if (udata) {
rc = qedr_copy_qp_uresp(dev, qp, udata);
if (rc)
goto err2;
qedr_qp_user_print(dev, qp);
} else {
qedr_init_qp_kernel_doorbell_sq(dev, qp);
qedr_init_qp_kernel_doorbell_rq(dev, qp);
}
DP_DEBUG(dev, QEDR_MSG_QP, "created %s space QP %p\n",
udata ? "user" : "kernel", qp);
return &qp->ibqp; return &qp->ibqp;
err2: err:
rc = dev->ops->rdma_destroy_qp(dev->rdma_ctx, qp->qed_qp);
if (rc)
DP_ERR(dev, "create qp: fatal fault. rc=%d", rc);
err1:
if (udata) {
qedr_cleanup_user_sq(dev, qp);
qedr_cleanup_user_rq(dev, qp);
} else {
qedr_cleanup_kernel_sq(dev, qp);
qedr_cleanup_kernel_rq(dev, qp);
}
err0:
kfree(qp); kfree(qp);
return ERR_PTR(-EFAULT); return ERR_PTR(-EFAULT);
...@@ -2067,6 +1983,24 @@ int qedr_query_qp(struct ib_qp *ibqp, ...@@ -2067,6 +1983,24 @@ int qedr_query_qp(struct ib_qp *ibqp,
return rc; return rc;
} }
int qedr_free_qp_resources(struct qedr_dev *dev, struct qedr_qp *qp)
{
int rc = 0;
if (qp->qp_type != IB_QPT_GSI) {
rc = dev->ops->rdma_destroy_qp(dev->rdma_ctx, qp->qed_qp);
if (rc)
return rc;
}
if (qp->ibqp.uobject && qp->ibqp.uobject->context)
qedr_cleanup_user(dev, qp);
else
qedr_cleanup_kernel(dev, qp);
return 0;
}
int qedr_destroy_qp(struct ib_qp *ibqp) int qedr_destroy_qp(struct ib_qp *ibqp)
{ {
struct qedr_qp *qp = get_qedr_qp(ibqp); struct qedr_qp *qp = get_qedr_qp(ibqp);
...@@ -2089,21 +2023,10 @@ int qedr_destroy_qp(struct ib_qp *ibqp) ...@@ -2089,21 +2023,10 @@ int qedr_destroy_qp(struct ib_qp *ibqp)
qedr_modify_qp(ibqp, &attr, attr_mask, NULL); qedr_modify_qp(ibqp, &attr, attr_mask, NULL);
} }
if (qp->qp_type != IB_QPT_GSI) { if (qp->qp_type == IB_QPT_GSI)
rc = dev->ops->rdma_destroy_qp(dev->rdma_ctx, qp->qed_qp);
if (rc)
return rc;
} else {
qedr_destroy_gsi_qp(dev); qedr_destroy_gsi_qp(dev);
}
if (ibqp->uobject && ibqp->uobject->context) { qedr_free_qp_resources(dev, qp);
qedr_cleanup_user_sq(dev, qp);
qedr_cleanup_user_rq(dev, qp);
} else {
qedr_cleanup_kernel_sq(dev, qp);
qedr_cleanup_kernel_rq(dev, qp);
}
kfree(qp); kfree(qp);
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment