/*
* Minimum siw_query_qp() verb interface.
*
* @qp_attr_mask is not used but all available information is provided
*/
int siw_query_qp(struct ib_qp *ofa_qp, struct ib_qp_attr *qp_attr,
int qp_attr_mask, struct ib_qp_init_attr *qp_init_attr)
{
struct siw_qp *qp;
struct siw_dev *sdev;
if (ofa_qp && qp_attr && qp_init_attr) {
qp = siw_qp_ofa2siw(ofa_qp);
sdev = siw_dev_ofa2siw(ofa_qp->device);
} else
return -EINVAL;
qp_attr->cap.max_inline_data = SIW_MAX_INLINE;
qp_init_attr->cap.max_inline_data = SIW_MAX_INLINE;
qp_attr->cap.max_send_wr = qp->attrs.sq_size;
qp_attr->cap.max_recv_wr = qp->attrs.rq_size;
qp_attr->cap.max_send_sge = qp->attrs.sq_max_sges;
qp_attr->cap.max_recv_sge = qp->attrs.rq_max_sges;
qp_attr->path_mtu = siw_mtu_net2ofa(sdev->netdev->mtu);
qp_attr->max_rd_atomic = qp->attrs.ird;
qp_attr->max_dest_rd_atomic = qp->attrs.ord;
qp_attr->qp_access_flags = IB_ACCESS_LOCAL_WRITE |
IB_ACCESS_REMOTE_WRITE | IB_ACCESS_REMOTE_READ;
qp_init_attr->cap = qp_attr->cap;
return 0;
}
void siw_qp_put_ref(struct ib_qp *ofa_qp)
{
struct siw_qp *qp = siw_qp_ofa2siw(ofa_qp);
dprint(DBG_OBJ|DBG_CM, "(QP%d): Put Reference\n", QP_ID(qp));
siw_qp_put(qp);
}
void siw_qp_put_ref(struct ib_qp *ofa_qp)
{
struct siw_qp *qp = siw_qp_ofa2siw(ofa_qp);
pr_debug(DBG_OBJ DBG_CM "(QP%d): Put Reference\n", QP_ID(qp));
siw_qp_put(qp);
}
int siw_ofed_modify_qp(struct ib_qp *ofa_qp, struct ib_qp_attr *attr,
int attr_mask, struct ib_udata *udata)
{
struct siw_qp_attrs new_attrs;
enum siw_qp_attr_mask siw_attr_mask = 0;
struct siw_qp *qp = siw_qp_ofa2siw(ofa_qp);
int rv = 0;
if (!attr_mask) {
dprint(DBG_CM, "(QP%d): attr_mask==0 ignored\n", QP_ID(qp));
goto out;
}
siw_dprint_qp_attr_mask(attr_mask);
memset(&new_attrs, 0, sizeof new_attrs);
if (attr_mask & IB_QP_ACCESS_FLAGS) {
siw_attr_mask |= SIW_QP_ATTR_ACCESS_FLAGS;
if (attr->qp_access_flags & IB_ACCESS_REMOTE_READ)
new_attrs.flags |= SIW_RDMA_READ_ENABLED;
if (attr->qp_access_flags & IB_ACCESS_REMOTE_WRITE)
new_attrs.flags |= SIW_RDMA_WRITE_ENABLED;
if (attr->qp_access_flags & IB_ACCESS_MW_BIND)
new_attrs.flags |= SIW_RDMA_BIND_ENABLED;
}
if (attr_mask & IB_QP_STATE) {
dprint(DBG_CM, "(QP%d): Desired IB QP state: %s\n",
QP_ID(qp), ib_qp_state_to_string[attr->qp_state]);
new_attrs.state = ib_qp_state_to_siw_qp_state[attr->qp_state];
if (new_attrs.state > SIW_QP_STATE_RTS)
qp->tx_ctx.tx_suspend = 1;
/* TODO: SIW_QP_STATE_UNDEF is currently not possible ... */
if (new_attrs.state == SIW_QP_STATE_UNDEF)
return -EINVAL;
siw_attr_mask |= SIW_QP_ATTR_STATE;
}
if (!attr_mask)
goto out;
down_write(&qp->state_lock);
rv = siw_qp_modify(qp, &new_attrs, siw_attr_mask);
up_write(&qp->state_lock);
out:
dprint(DBG_CM, "(QP%d): Exit with %d\n", QP_ID(qp), rv);
return rv;
}
int siw_destroy_qp(struct ib_qp *ofa_qp)
{
struct siw_qp *qp = siw_qp_ofa2siw(ofa_qp);
struct siw_qp_attrs qp_attrs;
dprint(DBG_CM, "(QP%d): SIW QP state=%d, cep=0x%p\n",
QP_ID(qp), qp->attrs.state, qp->cep);
/*
* Mark QP as in process of destruction to prevent from eventual async
* callbacks to OFA core
*/
qp->attrs.flags |= SIW_QP_IN_DESTROY;
qp->rx_ctx.rx_suspend = 1;
down_write(&qp->state_lock);
qp_attrs.state = SIW_QP_STATE_ERROR;
(void)siw_qp_modify(qp, &qp_attrs, SIW_QP_ATTR_STATE);
if (qp->cep) {
siw_cep_put(qp->cep);
qp->cep = NULL;
}
up_write(&qp->state_lock);
if (qp->rx_ctx.crc_enabled)
crypto_free_hash(qp->rx_ctx.mpa_crc_hd.tfm);
if (qp->tx_ctx.crc_enabled)
crypto_free_hash(qp->tx_ctx.mpa_crc_hd.tfm);
/* Drop references */
siw_cq_put(qp->scq);
siw_cq_put(qp->rcq);
siw_pd_put(qp->pd);
qp->scq = qp->rcq = NULL;
siw_qp_put(qp);
return 0;
}
int siw_destroy_qp(struct ib_qp *ofa_qp)
{
struct siw_qp *qp = siw_qp_ofa2siw(ofa_qp);
struct siw_qp_attrs qp_attrs;
pr_debug(DBG_CM "(QP%d): SIW QP state=%d, cep=0x%p\n",
QP_ID(qp), qp->attrs.state, qp->cep);
/*
* Mark QP as in process of destruction to prevent from eventual async
* callbacks to OFA core
*/
qp->attrs.flags |= SIW_QP_IN_DESTROY;
down_write(&qp->state_lock);
qp_attrs.state = SIW_QP_STATE_ERROR;
(void)siw_qp_modify(qp, &qp_attrs, SIW_QP_ATTR_STATE);
if (qp->cep) {
siw_cep_put(qp->cep);
qp->cep = NULL;
}
up_write(&qp->state_lock);
/* Drop references */
siw_cq_put(qp->scq);
siw_cq_put(qp->rcq);
siw_pd_put(qp->pd);
qp->scq = qp->rcq = NULL;
siw_qp_put(qp);
return 0;
}
/*
* siw_post_send()
*
* Post a list of S-WR's to a SQ.
*
* @ofa_qp: OFA QP contained in siw QP
* @wr: Null terminated list of user WR's
* @bad_wr: Points to failing WR in case of synchronous failure.
*/
int siw_post_send(struct ib_qp *ofa_qp, struct ib_send_wr *wr,
struct ib_send_wr **bad_wr)
{
struct siw_wqe *wqe = NULL;
struct siw_qp *qp = siw_qp_ofa2siw(ofa_qp);
unsigned long flags;
int rv = 0;
dprint(DBG_WR|DBG_TX, "(QP%d): state=%d\n",
QP_ID(qp), qp->attrs.state);
/*
* Try to acquire QP state lock. Must be non-blocking
* to accommodate kernel clients needs.
*/
if (!down_read_trylock(&qp->state_lock)) {
*bad_wr = wr;
return -ENOTCONN;
}
if (qp->attrs.state != SIW_QP_STATE_RTS) {
dprint(DBG_WR|DBG_ON, "(QP%d): state=%d\n",
QP_ID(qp), qp->attrs.state);
up_read(&qp->state_lock);
*bad_wr = wr;
return -ENOTCONN;
}
dprint(DBG_WR|DBG_TX, "(QP%d): sq_space(#1)=%d\n",
QP_ID(qp), atomic_read(&qp->sq_space));
while (wr) {
wqe = siw_wqe_alloc(qp, opcode_ofa2siw(wr->opcode));
if (!wqe) {
dprint(DBG_ON, " siw_wqe_alloc\n");
rv = -ENOMEM;
break;
}
wr_type(wqe) = opcode_ofa2siw(wr->opcode);
wr_id(wqe) = wr->wr_id;
wr_flags(wqe) = wr->send_flags;
if (qp->attrs.flags & SIW_SIGNAL_ALL_WR)
wr_flags(wqe) |= IB_SEND_SIGNALED;
if (wr->num_sge > qp->attrs.sq_max_sges) {
/*
* NOTE: we allow for zero length wr's here.
*/
dprint(DBG_WR, "(QP%d): Num SGE: %d\n",
QP_ID(qp), wr->num_sge);
rv = -EINVAL;
break;
}
switch (wr->opcode) {
case IB_WR_SEND:
if (!SIW_INLINED_DATA(wqe)) {
rv = siw_copy_sgl(wr->sg_list,
wqe->wr.send.sge,
wr->num_sge);
wqe->wr.send.num_sge = wr->num_sge;
} else
rv = siw_copy_inline_sgl(wr, wqe);
if (rv < 0) {
rv = -EINVAL;
break;
}
wqe->bytes = rv;
break;
case IB_WR_RDMA_READ:
/*
* OFED WR restricts RREAD sink to SGL containing
* 1 SGE only. we could relax to SGL with multiple
* elements referring the SAME ltag or even sending
* a private per-rreq tag referring to a checked
* local sgl with MULTIPLE ltag's. would be easy
* to do...
*/
if (wr->num_sge != 1) {
rv = -EINVAL;
break;
}
rv = siw_copy_sgl(wr->sg_list, wqe->wr.rread.sge, 1);
/*
* NOTE: zero length RREAD is allowed!
*/
wqe->wr.rread.raddr = wr->wr.rdma.remote_addr;
wqe->wr.rread.rtag = wr->wr.rdma.rkey;
wqe->wr.rread.num_sge = 1;
wqe->bytes = rv;
break;
case IB_WR_RDMA_WRITE:
if (!SIW_INLINED_DATA(wqe)) {
rv = siw_copy_sgl(wr->sg_list,
wqe->wr.send.sge,
wr->num_sge);
wqe->wr.write.num_sge = wr->num_sge;
} else
rv = siw_copy_inline_sgl(wr, wqe);
/*
* NOTE: zero length WRITE is allowed!
*/
if (rv < 0) {
rv = -EINVAL;
break;
}
wqe->wr.write.raddr = wr->wr.rdma.remote_addr;
wqe->wr.write.rtag = wr->wr.rdma.rkey;
wqe->bytes = rv;
break;
default:
dprint(DBG_WR|DBG_TX|DBG_ON,
"(QP%d): Opcode %d not yet implemented\n",
QP_ID(qp), wr->opcode);
wqe->wr.sgl.num_sge = 0;
rv = -ENOSYS;
break;
}
dprint(DBG_WR|DBG_TX, "(QP%d): opcode %d, bytes %d, "
"flags 0x%x\n",
QP_ID(qp), wr_type(wqe), wqe->bytes,
wr_flags(wqe));
if (rv < 0)
break;
wqe->wr_status = SR_WR_QUEUED;
lock_sq_rxsave(qp, flags);
list_add_tail(&wqe->list, &qp->sq);
unlock_sq_rxsave(qp, flags);
wr = wr->next;
}
/*
* Send directly if SQ processing is not in progress.
* Eventual immediate errors (rv < 0) do not affect the involved
* RI resources (Verbs, 8.3.1) and thus do not prevent from SQ
* processing, if new work is already pending. But rv must be passed
* to caller.
*/
lock_sq_rxsave(qp, flags);
if (tx_wqe(qp) == NULL) {
struct siw_wqe *next = siw_next_tx_wqe(qp);
if (next != NULL) {
if (wr_type(next) != SIW_WR_RDMA_READ_REQ ||
!ORD_SUSPEND_SQ(qp)) {
tx_wqe(qp) = next;
if (wr_type(next) != SIW_WR_RDMA_READ_REQ)
list_del_init(&next->list);
else
siw_rreq_queue(next, qp);
unlock_sq_rxsave(qp, flags);
dprint(DBG_WR|DBG_TX,
"(QP%d): Direct sending...\n",
QP_ID(qp));
if (qp->attrs.flags & SIW_KERNEL_VERBS)
siw_sq_queue_work(qp);
else if (siw_qp_sq_process(qp, 1) != 0 &&
!(qp->tx_ctx.tx_suspend))
siw_qp_cm_drop(qp, 0);
} else
unlock_sq_rxsave(qp, flags);
} else
unlock_sq_rxsave(qp, flags);
} else
unlock_sq_rxsave(qp, flags);
up_read(&qp->state_lock);
dprint(DBG_WR|DBG_TX, "(QP%d): sq_space(#2)=%d\n", QP_ID(qp),
atomic_read(&qp->sq_space));
if (rv >= 0)
return 0;
/*
* Immediate error
*/
dprint(DBG_WR|DBG_ON, "(QP%d): error=%d\n", QP_ID(qp), rv);
if (wqe != NULL)
siw_wqe_put(wqe);
*bad_wr = wr;
return rv;
}
/*
* siw_post_receive()
*
* Post a list of R-WR's to a RQ.
*
* @ofa_qp: OFA QP contained in siw QP
* @wr: Null terminated list of user WR's
* @bad_wr: Points to failing WR in case of synchronous failure.
*/
int siw_post_receive(struct ib_qp *ofa_qp, struct ib_recv_wr *wr,
struct ib_recv_wr **bad_wr)
{
struct siw_wqe *wqe = NULL;
struct siw_qp *qp = siw_qp_ofa2siw(ofa_qp);
unsigned long flags;
int rv = 0;
dprint(DBG_WR|DBG_TX, "(QP%d): state=%d\n", QP_ID(qp),
qp->attrs.state);
if (unlikely(qp->srq)) {
*bad_wr = wr;
return -EOPNOTSUPP; /* what else from errno.h? */
}
/*
* Try to acquire QP state lock. Must be non-blocking
* to accommodate kernel clients needs.
*/
if (!down_read_trylock(&qp->state_lock)) {
*bad_wr = wr;
return -ENOTCONN;
}
if (qp->attrs.state > SIW_QP_STATE_RTS) {
up_read(&qp->state_lock);
dprint(DBG_ON, " (QP%d): state=%d\n", QP_ID(qp),
qp->attrs.state);
*bad_wr = wr;
return -EINVAL;
}
while (wr) {
wqe = siw_wqe_alloc(qp, SIW_WR_RECEIVE);
if (!wqe) {
rv = -ENOMEM;
break;
}
if (wr->num_sge > qp->attrs.rq_max_sges) {
dprint(DBG_WR|DBG_ON, "(QP%d): Num SGE: %d\n",
QP_ID(qp), wr->num_sge);
rv = -EINVAL;
break;
}
wr_type(wqe) = SIW_WR_RECEIVE;
wr_id(wqe) = wr->wr_id;
rv = siw_copy_sgl(wr->sg_list, wqe->wr.recv.sge, wr->num_sge);
if (rv < 0) {
/*
* XXX tentatively allow zero length receive
*/
rv = -EINVAL;
break;
}
wqe->wr.recv.num_sge = wr->num_sge;
wqe->bytes = rv;
wqe->wr_status = SR_WR_QUEUED;
lock_rq_rxsave(qp, flags);
list_add_tail(&wqe->list, &qp->rq);
unlock_rq_rxsave(qp, flags);
wr = wr->next;
}
if (rv <= 0) {
dprint(DBG_WR|DBG_ON, "(QP%d): error=%d\n", QP_ID(qp), rv);
if (wqe != NULL)
siw_wqe_put(wqe);
*bad_wr = wr;
}
dprint(DBG_WR|DBG_RX, "(QP%d): rq_space=%d\n", QP_ID(qp),
atomic_read(&qp->rq_space));
up_read(&qp->state_lock);
return rv > 0 ? 0 : rv;
}