From: Bob Pearson <rpearsonhpe@gmail.com>
To: jgg@nvidia.com, zyjzyj2000@gmail.com, lizhijian@fujitsu.com,
linux-rdma@vger.kernel.org
Cc: Bob Pearson <rpearsonhpe@gmail.com>
Subject: [PATCH 2/2] providers/rxe: Implement the xrc transport protocol
Date: Fri, 16 Sep 2022 22:15:37 -0500 [thread overview]
Message-ID: <20220917031536.21354-3-rpearsonhpe@gmail.com> (raw)
In-Reply-To: <20220917031536.21354-1-rpearsonhpe@gmail.com>
Make changes to implement the xrc transport protocol.
Signed-off-by: Bob Pearson <rpearsonhpe@gmail.com>
---
providers/rxe/rxe-abi.h | 2 +
providers/rxe/rxe.c | 387 ++++++++++++++++++++++++++++------------
providers/rxe/rxe.h | 21 ++-
3 files changed, 290 insertions(+), 120 deletions(-)
diff --git a/providers/rxe/rxe-abi.h b/providers/rxe/rxe-abi.h
index 020201a9..07e90d81 100644
--- a/providers/rxe/rxe-abi.h
+++ b/providers/rxe/rxe-abi.h
@@ -51,6 +51,8 @@ DECLARE_DRV_CMD(urxe_create_qp_ex, IB_USER_VERBS_EX_CMD_CREATE_QP,
empty, rxe_create_qp_resp);
DECLARE_DRV_CMD(urxe_create_srq, IB_USER_VERBS_CMD_CREATE_SRQ,
empty, rxe_create_srq_resp);
+DECLARE_DRV_CMD(urxe_create_srq_ex, IB_USER_VERBS_CMD_CREATE_XSRQ,
+ empty, rxe_create_srq_resp);
DECLARE_DRV_CMD(urxe_modify_srq, IB_USER_VERBS_CMD_MODIFY_SRQ,
rxe_modify_srq_cmd, empty);
DECLARE_DRV_CMD(urxe_resize_cq, IB_USER_VERBS_CMD_RESIZE_CQ,
diff --git a/providers/rxe/rxe.c b/providers/rxe/rxe.c
index 0e8f5605..4acd7140 100644
--- a/providers/rxe/rxe.c
+++ b/providers/rxe/rxe.c
@@ -574,10 +574,52 @@ static int rxe_poll_cq(struct ibv_cq *ibcq, int ne, struct ibv_wc *wc)
return npolled;
}
-static struct ibv_srq *rxe_create_srq(struct ibv_pd *pd,
+static struct ibv_xrcd *rxe_open_xrcd(struct ibv_context *ibcontext,
+ struct ibv_xrcd_init_attr *attr)
+{
+ struct ibv_open_xrcd cmd;
+ struct ib_uverbs_open_xrcd_resp resp;
+ struct rxe_xrcd *xrcd;
+ struct verbs_xrcd *vxrcd;
+ int err;
+
+ xrcd = calloc(1, sizeof *xrcd);
+ if (!xrcd)
+ return NULL;
+
+ vxrcd = &xrcd->vxrcd;
+
+ err = ibv_cmd_open_xrcd(ibcontext, vxrcd, sizeof(*vxrcd), attr,
+ &cmd, sizeof cmd, &resp, sizeof resp);
+ if (err)
+ goto err_out;
+
+ return &vxrcd->xrcd;
+
+err_out:
+ errno = err;
+ free(xrcd);
+ return NULL;
+}
+
+static int rxe_close_xrcd(struct ibv_xrcd *ibxrcd)
+{
+ struct rxe_xrcd *xrcd = to_rxrcd(ibxrcd);
+ int err;
+
+ err = ibv_cmd_close_xrcd(&xrcd->vxrcd);
+ if (err)
+ return err;
+
+ free(xrcd);
+ return 0;
+}
+
+static struct ibv_srq *rxe_create_srq(struct ibv_pd *ibpd,
struct ibv_srq_init_attr *attr)
{
struct rxe_srq *srq;
+ struct ibv_srq *ibsrq;
struct ibv_create_srq cmd;
struct urxe_create_srq_resp resp;
int ret;
@@ -586,7 +628,9 @@ static struct ibv_srq *rxe_create_srq(struct ibv_pd *pd,
if (srq == NULL)
return NULL;
- ret = ibv_cmd_create_srq(pd, &srq->ibv_srq, attr, &cmd, sizeof(cmd),
+ ibsrq = &srq->vsrq.srq;
+
+ ret = ibv_cmd_create_srq(ibpd, ibsrq, attr, &cmd, sizeof(cmd),
&resp.ibv_resp, sizeof(resp));
if (ret) {
free(srq);
@@ -595,9 +639,9 @@ static struct ibv_srq *rxe_create_srq(struct ibv_pd *pd,
srq->rq.queue = mmap(NULL, resp.mi.size,
PROT_READ | PROT_WRITE, MAP_SHARED,
- pd->context->cmd_fd, resp.mi.offset);
+ ibpd->context->cmd_fd, resp.mi.offset);
if ((void *)srq->rq.queue == MAP_FAILED) {
- ibv_cmd_destroy_srq(&srq->ibv_srq);
+ ibv_cmd_destroy_srq(ibsrq);
free(srq);
return NULL;
}
@@ -606,16 +650,55 @@ static struct ibv_srq *rxe_create_srq(struct ibv_pd *pd,
srq->rq.max_sge = attr->attr.max_sge;
pthread_spin_init(&srq->rq.lock, PTHREAD_PROCESS_PRIVATE);
- return &srq->ibv_srq;
+ return ibsrq;
+}
+
+static struct ibv_srq *rxe_create_srq_ex(
+ struct ibv_context *ibcontext,
+ struct ibv_srq_init_attr_ex *attr_ex)
+{
+ struct rxe_srq *srq;
+ struct ibv_srq *ibsrq;
+ struct ibv_create_xsrq cmd;
+ struct urxe_create_srq_ex_resp resp;
+ int ret;
+
+ srq = calloc(1, sizeof(*srq));
+ if (srq == NULL)
+ return NULL;
+
+ ibsrq = &srq->vsrq.srq;
+
+ ret = ibv_cmd_create_srq_ex(ibcontext, &srq->vsrq, attr_ex,
+ &cmd, sizeof(cmd), &resp.ibv_resp, sizeof(resp));
+ if (ret) {
+ free(srq);
+ return NULL;
+ }
+
+ srq->rq.queue = mmap(NULL, resp.mi.size,
+ PROT_READ | PROT_WRITE, MAP_SHARED,
+ ibcontext->cmd_fd, resp.mi.offset);
+ if ((void *)srq->rq.queue == MAP_FAILED) {
+ ibv_cmd_destroy_srq(ibsrq);
+ free(srq);
+ return NULL;
+ }
+
+ srq->mmap_info = resp.mi;
+ srq->rq.max_sge = attr_ex->attr.max_sge;
+ pthread_spin_init(&srq->rq.lock, PTHREAD_PROCESS_PRIVATE);
+
+ return ibsrq;
}
-static int rxe_modify_srq(struct ibv_srq *ibsrq,
- struct ibv_srq_attr *attr, int attr_mask)
+static int rxe_modify_srq(struct ibv_srq *ibsrq, struct ibv_srq_attr *attr,
+ int attr_mask)
{
struct rxe_srq *srq = to_rsrq(ibsrq);
struct urxe_modify_srq cmd;
- int rc = 0;
struct mminfo mi;
+ int err;
mi.offset = 0;
mi.size = 0;
@@ -624,9 +707,9 @@ static int rxe_modify_srq(struct ibv_srq *ibsrq,
pthread_spin_lock(&srq->rq.lock);
cmd.mmap_info_addr = (__u64)(uintptr_t) &mi;
- rc = ibv_cmd_modify_srq(ibsrq, attr, attr_mask,
- &cmd.ibv_cmd, sizeof(cmd));
- if (rc)
+ err = ibv_cmd_modify_srq(ibsrq, attr, attr_mask,
+ &cmd.ibv_cmd, sizeof(cmd));
+ if (err)
goto out;
if (attr_mask & IBV_SRQ_MAX_WR) {
@@ -636,7 +719,7 @@ static int rxe_modify_srq(struct ibv_srq *ibsrq,
ibsrq->context->cmd_fd, mi.offset);
if ((void *)srq->rq.queue == MAP_FAILED) {
- rc = errno;
+ err = errno;
srq->rq.queue = NULL;
srq->mmap_info.size = 0;
goto out;
@@ -648,30 +731,43 @@ static int rxe_modify_srq(struct ibv_srq *ibsrq,
out:
if (attr_mask & IBV_SRQ_MAX_WR)
pthread_spin_unlock(&srq->rq.lock);
- return rc;
+
+ return err;
+}
+
+static int rxe_get_srq_num(struct ibv_srq *ibsrq, uint32_t *srq_num)
+{
+ struct rxe_srq *srq = to_rsrq(ibsrq);
+
+ if (!srq->vsrq.xrcd)
+ return EOPNOTSUPP;
+
+ *srq_num = srq->vsrq.srq_num;
+
+ return 0;
}
-static int rxe_query_srq(struct ibv_srq *srq, struct ibv_srq_attr *attr)
+static int rxe_query_srq(struct ibv_srq *ibsrq, struct ibv_srq_attr *attr)
{
struct ibv_query_srq cmd;
- return ibv_cmd_query_srq(srq, attr, &cmd, sizeof(cmd));
+ return ibv_cmd_query_srq(ibsrq, attr, &cmd, sizeof(cmd));
}
static int rxe_destroy_srq(struct ibv_srq *ibvsrq)
{
- int ret;
+ int err;
struct rxe_srq *srq = to_rsrq(ibvsrq);
struct rxe_queue_buf *q = srq->rq.queue;
- ret = ibv_cmd_destroy_srq(ibvsrq);
- if (!ret) {
+ err = ibv_cmd_destroy_srq(ibvsrq);
+ if (!err) {
if (srq->mmap_info.size)
munmap(q, srq->mmap_info.size);
free(srq);
}
- return ret;
+ return err;
}
static int rxe_post_one_recv(struct rxe_wq *rq, struct ibv_recv_wr *recv_wr)
@@ -715,11 +811,11 @@ out:
return rc;
}
-static int rxe_post_srq_recv(struct ibv_srq *ibvsrq,
+static int rxe_post_srq_recv(struct ibv_srq *ibsrq,
struct ibv_recv_wr *recv_wr,
struct ibv_recv_wr **bad_recv_wr)
{
- struct rxe_srq *srq = to_rsrq(ibvsrq);
+ struct rxe_srq *srq = to_rsrq(ibsrq);
int rc = 0;
pthread_spin_lock(&srq->rq.lock);
@@ -979,6 +1075,18 @@ static void wr_set_ud_addr(struct ibv_qp_ex *ibqp, struct ibv_ah *ibah,
memcpy(&wqe->wr.wr.ud.av, &ah->av, sizeof(ah->av));
}
+static void wr_set_xrc_srqn(struct ibv_qp_ex *ibqp, uint32_t remote_srqn)
+{
+ struct rxe_qp *qp = container_of(ibqp, struct rxe_qp, vqp.qp_ex);
+ struct rxe_send_wqe *wqe = addr_from_index(qp->sq.queue,
+ qp->cur_index - 1);
+
+ if (qp->err)
+ return;
+
+ wqe->wr.srq_num = remote_srqn;
+}
+
static void wr_set_inline_data(struct ibv_qp_ex *ibqp, void *addr,
size_t length)
{
@@ -1118,36 +1226,54 @@ static int map_queue_pair(int cmd_fd, struct rxe_qp *qp,
struct ibv_qp_init_attr *attr,
struct rxe_create_qp_resp *resp)
{
- if (attr->srq) {
- qp->rq.max_sge = 0;
- qp->rq.queue = NULL;
- qp->rq_mmap_info.size = 0;
- } else {
- qp->rq.max_sge = attr->cap.max_recv_sge;
- qp->rq.queue = mmap(NULL, resp->rq_mi.size, PROT_READ | PROT_WRITE,
- MAP_SHARED,
- cmd_fd, resp->rq_mi.offset);
- if ((void *)qp->rq.queue == MAP_FAILED)
+ switch (attr->qp_type) {
+ case IBV_QPT_RC:
+ case IBV_QPT_UC:
+ case IBV_QPT_UD:
+ if (attr->srq) {
+ qp->rq.max_sge = 0;
+ qp->rq.queue = NULL;
+ qp->rq_mmap_info.size = 0;
+ } else {
+ qp->rq.max_sge = attr->cap.max_recv_sge;
+ qp->rq.queue = mmap(NULL, resp->rq_mi.size,
+ PROT_READ | PROT_WRITE,
+ MAP_SHARED, cmd_fd,
+ resp->rq_mi.offset);
+ if ((void *)qp->rq.queue == MAP_FAILED)
+ return errno;
+
+ qp->rq_mmap_info = resp->rq_mi;
+ pthread_spin_init(&qp->rq.lock,
+ PTHREAD_PROCESS_PRIVATE);
+ }
+ /* fall through */
+ case IBV_QPT_XRC_SEND:
+ qp->sq.max_sge = attr->cap.max_send_sge;
+ qp->sq.max_inline = attr->cap.max_inline_data;
+ qp->sq.queue = mmap(NULL, resp->sq_mi.size,
+ PROT_READ | PROT_WRITE,
+ MAP_SHARED, cmd_fd,
+ resp->sq_mi.offset);
+ if ((void *)qp->sq.queue == MAP_FAILED) {
+ if (qp->rq_mmap_info.size)
+ munmap(qp->rq.queue, qp->rq_mmap_info.size);
return errno;
+ }
- qp->rq_mmap_info = resp->rq_mi;
- pthread_spin_init(&qp->rq.lock, PTHREAD_PROCESS_PRIVATE);
- }
-
- qp->sq.max_sge = attr->cap.max_send_sge;
- qp->sq.max_inline = attr->cap.max_inline_data;
- qp->sq.queue = mmap(NULL, resp->sq_mi.size, PROT_READ | PROT_WRITE,
- MAP_SHARED,
- cmd_fd, resp->sq_mi.offset);
- if ((void *)qp->sq.queue == MAP_FAILED) {
- if (qp->rq_mmap_info.size)
- munmap(qp->rq.queue, qp->rq_mmap_info.size);
- return errno;
+ qp->sq_mmap_info = resp->sq_mi;
+ pthread_spin_init(&qp->sq.lock, PTHREAD_PROCESS_PRIVATE);
+ break;
+ case IBV_QPT_XRC_RECV:
+ break;
+ case IBV_QPT_RAW_PACKET:
+ case IBV_QPT_DRIVER:
+ /* not reached */
+ return EOPNOTSUPP;
+ default:
+ return EINVAL;
}
- qp->sq_mmap_info = resp->sq_mi;
- pthread_spin_init(&qp->sq.lock, PTHREAD_PROCESS_PRIVATE);
-
return 0;
}
@@ -1189,7 +1315,7 @@ err:
enum {
RXE_QP_CREATE_FLAGS_SUP = 0,
- RXE_QP_COMP_MASK_SUP = IBV_QP_INIT_ATTR_PD |
+ RXE_QP_COMP_MASK_SUP = IBV_QP_INIT_ATTR_PD | IBV_QP_INIT_ATTR_XRCD |
IBV_QP_INIT_ATTR_CREATE_FLAGS | IBV_QP_INIT_ATTR_SEND_OPS_FLAGS,
RXE_SUP_RC_QP_SEND_OPS_FLAGS =
@@ -1206,6 +1332,13 @@ enum {
RXE_SUP_UD_QP_SEND_OPS_FLAGS =
IBV_QP_EX_WITH_SEND | IBV_QP_EX_WITH_SEND_WITH_IMM,
+
+ RXE_SUP_XRC_QP_SEND_OPS_FLAGS =
+ IBV_QP_EX_WITH_RDMA_WRITE | IBV_QP_EX_WITH_RDMA_WRITE_WITH_IMM |
+ IBV_QP_EX_WITH_SEND | IBV_QP_EX_WITH_SEND_WITH_IMM |
+ IBV_QP_EX_WITH_RDMA_READ | IBV_QP_EX_WITH_ATOMIC_CMP_AND_SWP |
+ IBV_QP_EX_WITH_ATOMIC_FETCH_AND_ADD | IBV_QP_EX_WITH_LOCAL_INV |
+ IBV_QP_EX_WITH_BIND_MW | IBV_QP_EX_WITH_SEND_WITH_INV,
};
static int check_qp_init_attr(struct ibv_qp_init_attr_ex *attr)
@@ -1220,17 +1353,28 @@ static int check_qp_init_attr(struct ibv_qp_init_attr_ex *attr)
if (attr->comp_mask & IBV_QP_INIT_ATTR_SEND_OPS_FLAGS) {
switch (attr->qp_type) {
case IBV_QPT_RC:
- if (attr->send_ops_flags & ~RXE_SUP_RC_QP_SEND_OPS_FLAGS)
+ if (attr->send_ops_flags &
+ ~RXE_SUP_RC_QP_SEND_OPS_FLAGS)
goto err;
break;
case IBV_QPT_UC:
- if (attr->send_ops_flags & ~RXE_SUP_UC_QP_SEND_OPS_FLAGS)
+ if (attr->send_ops_flags &
+ ~RXE_SUP_UC_QP_SEND_OPS_FLAGS)
goto err;
break;
case IBV_QPT_UD:
- if (attr->send_ops_flags & ~RXE_SUP_UD_QP_SEND_OPS_FLAGS)
+ if (attr->send_ops_flags &
+ ~RXE_SUP_UD_QP_SEND_OPS_FLAGS)
+ goto err;
+ break;
+ case IBV_QPT_XRC_SEND:
+ if (attr->send_ops_flags &
+ ~RXE_SUP_XRC_QP_SEND_OPS_FLAGS)
goto err;
break;
+ case IBV_QPT_XRC_RECV:
+ goto err;
+ break;
default:
goto err;
}
@@ -1275,6 +1419,7 @@ static void set_qp_send_ops(struct rxe_qp *qp, uint64_t flags)
qp->vqp.qp_ex.wr_send_inv = wr_send_inv;
qp->vqp.qp_ex.wr_set_ud_addr = wr_set_ud_addr;
+ qp->vqp.qp_ex.wr_set_xrc_srqn = wr_set_xrc_srqn;
qp->vqp.qp_ex.wr_set_inline_data = wr_set_inline_data;
qp->vqp.qp_ex.wr_set_inline_data_list = wr_set_inline_data_list;
qp->vqp.qp_ex.wr_set_sge = wr_set_sge;
@@ -1286,38 +1431,38 @@ static void set_qp_send_ops(struct rxe_qp *qp, uint64_t flags)
}
static struct ibv_qp *rxe_create_qp_ex(struct ibv_context *context,
- struct ibv_qp_init_attr_ex *attr)
+ struct ibv_qp_init_attr_ex *attr)
{
- int ret;
+ int err;
struct rxe_qp *qp;
struct ibv_create_qp_ex cmd = {};
struct urxe_create_qp_ex_resp resp = {};
size_t cmd_size = sizeof(cmd);
size_t resp_size = sizeof(resp);
- ret = check_qp_init_attr(attr);
- if (ret)
- goto err;
+ err = check_qp_init_attr(attr);
+ if (err)
+ goto err_out;
qp = calloc(1, sizeof(*qp));
if (!qp)
- goto err;
+ goto err_out;
if (attr->comp_mask & IBV_QP_INIT_ATTR_SEND_OPS_FLAGS)
set_qp_send_ops(qp, attr->send_ops_flags);
- ret = ibv_cmd_create_qp_ex2(context, &qp->vqp, attr,
+ err = ibv_cmd_create_qp_ex2(context, &qp->vqp, attr,
&cmd, cmd_size,
&resp.ibv_resp, resp_size);
- if (ret)
+ if (err)
goto err_free;
qp->vqp.comp_mask |= VERBS_QP_EX;
- ret = map_queue_pair(context->cmd_fd, qp,
- (struct ibv_qp_init_attr *)attr,
- &resp.drv_payload);
- if (ret)
+ err = map_queue_pair(context->cmd_fd, qp,
+ (struct ibv_qp_init_attr *)attr,
+ &resp.drv_payload);
+ if (err)
goto err_destroy;
return &qp->vqp.qp;
@@ -1326,7 +1471,8 @@ err_destroy:
ibv_cmd_destroy_qp(&qp->vqp.qp);
err_free:
free(qp);
-err:
+err_out:
+ errno = err;
return NULL;
}
@@ -1397,56 +1543,57 @@ static int validate_send_wr(struct rxe_qp *qp, struct ibv_send_wr *ibwr,
return 0;
}
-static void convert_send_wr(struct rxe_qp *qp, struct rxe_send_wr *kwr,
- struct ibv_send_wr *uwr)
+static void convert_send_wr(struct rxe_qp *qp, struct rxe_send_wr *wr,
+ struct ibv_send_wr *ibwr)
{
struct ibv_mw *ibmw;
struct ibv_mr *ibmr;
- memset(kwr, 0, sizeof(*kwr));
+ memset(wr, 0, sizeof(*wr));
- kwr->wr_id = uwr->wr_id;
- kwr->opcode = uwr->opcode;
- kwr->send_flags = uwr->send_flags;
- kwr->ex.imm_data = uwr->imm_data;
+ wr->wr_id = ibwr->wr_id;
+ wr->srq_num = ibwr->qp_type.xrc.remote_srqn;
+ wr->opcode = ibwr->opcode;
+ wr->send_flags = ibwr->send_flags;
+ wr->ex.imm_data = ibwr->imm_data;
- switch (uwr->opcode) {
+ switch (ibwr->opcode) {
case IBV_WR_RDMA_WRITE:
case IBV_WR_RDMA_WRITE_WITH_IMM:
case IBV_WR_RDMA_READ:
- kwr->wr.rdma.remote_addr = uwr->wr.rdma.remote_addr;
- kwr->wr.rdma.rkey = uwr->wr.rdma.rkey;
+ wr->wr.rdma.remote_addr = ibwr->wr.rdma.remote_addr;
+ wr->wr.rdma.rkey = ibwr->wr.rdma.rkey;
break;
case IBV_WR_SEND:
case IBV_WR_SEND_WITH_IMM:
if (qp_type(qp) == IBV_QPT_UD) {
- struct rxe_ah *ah = to_rah(uwr->wr.ud.ah);
+ struct rxe_ah *ah = to_rah(ibwr->wr.ud.ah);
- kwr->wr.ud.remote_qpn = uwr->wr.ud.remote_qpn;
- kwr->wr.ud.remote_qkey = uwr->wr.ud.remote_qkey;
- kwr->wr.ud.ah_num = ah->ah_num;
+ wr->wr.ud.remote_qpn = ibwr->wr.ud.remote_qpn;
+ wr->wr.ud.remote_qkey = ibwr->wr.ud.remote_qkey;
+ wr->wr.ud.ah_num = ah->ah_num;
}
break;
case IBV_WR_ATOMIC_CMP_AND_SWP:
case IBV_WR_ATOMIC_FETCH_AND_ADD:
- kwr->wr.atomic.remote_addr = uwr->wr.atomic.remote_addr;
- kwr->wr.atomic.compare_add = uwr->wr.atomic.compare_add;
- kwr->wr.atomic.swap = uwr->wr.atomic.swap;
- kwr->wr.atomic.rkey = uwr->wr.atomic.rkey;
+ wr->wr.atomic.remote_addr = ibwr->wr.atomic.remote_addr;
+ wr->wr.atomic.compare_add = ibwr->wr.atomic.compare_add;
+ wr->wr.atomic.swap = ibwr->wr.atomic.swap;
+ wr->wr.atomic.rkey = ibwr->wr.atomic.rkey;
break;
case IBV_WR_BIND_MW:
- ibmr = uwr->bind_mw.bind_info.mr;
- ibmw = uwr->bind_mw.mw;
-
- kwr->wr.mw.addr = uwr->bind_mw.bind_info.addr;
- kwr->wr.mw.length = uwr->bind_mw.bind_info.length;
- kwr->wr.mw.mr_lkey = ibmr->lkey;
- kwr->wr.mw.mw_rkey = ibmw->rkey;
- kwr->wr.mw.rkey = uwr->bind_mw.rkey;
- kwr->wr.mw.access = uwr->bind_mw.bind_info.mw_access_flags;
+ ibmr = ibwr->bind_mw.bind_info.mr;
+ ibmw = ibwr->bind_mw.mw;
+
+ wr->wr.mw.addr = ibwr->bind_mw.bind_info.addr;
+ wr->wr.mw.length = ibwr->bind_mw.bind_info.length;
+ wr->wr.mw.mr_lkey = ibmr->lkey;
+ wr->wr.mw.mw_rkey = ibmw->rkey;
+ wr->wr.mw.rkey = ibwr->bind_mw.rkey;
+ wr->wr.mw.access = ibwr->bind_mw.bind_info.mw_access_flags;
break;
default:
@@ -1539,6 +1686,7 @@ static int post_send_db(struct ibv_qp *ibqp)
{
struct ibv_post_send cmd;
struct ib_uverbs_post_send_resp resp;
+ ssize_t ret;
cmd.hdr.command = IB_USER_VERBS_CMD_POST_SEND;
cmd.hdr.in_words = sizeof(cmd) / 4;
@@ -1549,7 +1697,8 @@ static int post_send_db(struct ibv_qp *ibqp)
cmd.sge_count = 0;
cmd.wqe_size = sizeof(struct ibv_send_wr);
- if (write(ibqp->context->cmd_fd, &cmd, sizeof(cmd)) != sizeof(cmd))
+ ret = write(ibqp->context->cmd_fd, &cmd, sizeof(cmd));
+ if (ret != sizeof(cmd))
return errno;
return 0;
@@ -1729,38 +1878,42 @@ static int rxe_destroy_ah(struct ibv_ah *ibah)
}
static const struct verbs_context_ops rxe_ctx_ops = {
- .query_device_ex = rxe_query_device,
- .query_port = rxe_query_port,
- .alloc_pd = rxe_alloc_pd,
- .dealloc_pd = rxe_dealloc_pd,
- .reg_mr = rxe_reg_mr,
- .dereg_mr = rxe_dereg_mr,
.alloc_mw = rxe_alloc_mw,
- .dealloc_mw = rxe_dealloc_mw,
+ .alloc_pd = rxe_alloc_pd,
+ .attach_mcast = ibv_cmd_attach_mcast,
.bind_mw = rxe_bind_mw,
- .create_cq = rxe_create_cq,
+ .close_xrcd = rxe_close_xrcd,
+ .create_ah = rxe_create_ah,
.create_cq_ex = rxe_create_cq_ex,
- .poll_cq = rxe_poll_cq,
- .req_notify_cq = ibv_cmd_req_notify_cq,
- .resize_cq = rxe_resize_cq,
- .destroy_cq = rxe_destroy_cq,
- .create_srq = rxe_create_srq,
- .modify_srq = rxe_modify_srq,
- .query_srq = rxe_query_srq,
- .destroy_srq = rxe_destroy_srq,
- .post_srq_recv = rxe_post_srq_recv,
- .create_qp = rxe_create_qp,
+ .create_cq = rxe_create_cq,
.create_qp_ex = rxe_create_qp_ex,
- .query_qp = rxe_query_qp,
- .modify_qp = rxe_modify_qp,
- .destroy_qp = rxe_destroy_qp,
- .post_send = rxe_post_send,
- .post_recv = rxe_post_recv,
- .create_ah = rxe_create_ah,
+ .create_qp = rxe_create_qp,
+ .create_srq = rxe_create_srq,
+ .create_srq_ex = rxe_create_srq_ex,
+ .dealloc_mw = rxe_dealloc_mw,
+ .dealloc_pd = rxe_dealloc_pd,
+ .dereg_mr = rxe_dereg_mr,
.destroy_ah = rxe_destroy_ah,
- .attach_mcast = ibv_cmd_attach_mcast,
+ .destroy_cq = rxe_destroy_cq,
+ .destroy_qp = rxe_destroy_qp,
+ .destroy_srq = rxe_destroy_srq,
.detach_mcast = ibv_cmd_detach_mcast,
.free_context = rxe_free_context,
+ .get_srq_num = rxe_get_srq_num,
+ .modify_qp = rxe_modify_qp,
+ .modify_srq = rxe_modify_srq,
+ .open_xrcd = rxe_open_xrcd,
+ .poll_cq = rxe_poll_cq,
+ .post_recv = rxe_post_recv,
+ .post_send = rxe_post_send,
+ .post_srq_recv = rxe_post_srq_recv,
+ .query_device_ex = rxe_query_device,
+ .query_port = rxe_query_port,
+ .query_qp = rxe_query_qp,
+ .query_srq = rxe_query_srq,
+ .reg_mr = rxe_reg_mr,
+ .req_notify_cq = ibv_cmd_req_notify_cq,
+ .resize_cq = rxe_resize_cq,
};
static struct verbs_context *rxe_alloc_context(struct ibv_device *ibdev,
diff --git a/providers/rxe/rxe.h b/providers/rxe/rxe.h
index 6882d9c7..2023ecae 100644
--- a/providers/rxe/rxe.h
+++ b/providers/rxe/rxe.h
@@ -40,6 +40,8 @@
#include <sys/socket.h>
#include <netinet/in.h>
#include <rdma/rdma_user_rxe.h>
+#include <unistd.h>
+
#include "rxe-abi.h"
struct rxe_device {
@@ -90,13 +92,21 @@ struct rxe_qp {
int err;
};
+struct rxe_xrcd {
+ struct verbs_xrcd vxrcd;
+};
+
struct rxe_srq {
- struct ibv_srq ibv_srq;
+ struct verbs_srq vsrq;
struct mminfo mmap_info;
struct rxe_wq rq;
- uint32_t srq_num;
};
+static inline unsigned int srq_num(struct rxe_srq *srq)
+{
+ return srq->vsrq.srq_num;
+}
+
#define to_rxxx(xxx, type) container_of(ib##xxx, struct rxe_##type, ibv_##xxx)
static inline struct rxe_context *to_rctx(struct ibv_context *ibctx)
@@ -119,9 +129,14 @@ static inline struct rxe_qp *to_rqp(struct ibv_qp *ibqp)
return container_of(ibqp, struct rxe_qp, vqp.qp);
}
+static inline struct rxe_xrcd *to_rxrcd(struct ibv_xrcd *ibxrcd)
+{
+ return container_of(ibxrcd, struct rxe_xrcd, vxrcd.xrcd);
+}
+
static inline struct rxe_srq *to_rsrq(struct ibv_srq *ibsrq)
{
- return to_rxxx(srq, srq);
+ return container_of(ibsrq, struct rxe_srq, vsrq.srq);
}
static inline struct rxe_ah *to_rah(struct ibv_ah *ibah)
--
2.34.1
next prev parent reply other threads:[~2022-09-17 3:16 UTC|newest]
Thread overview: 4+ messages / expand[flat|nested] mbox.gz Atom feed top
2022-09-17 3:15 [PATCH 0/2] providers/rxe: Implement the xrc transport protocol Bob Pearson
2022-09-17 3:15 ` [PATCH 1/2] Update kernel headers Bob Pearson
2022-09-17 3:15 ` Bob Pearson [this message]
2022-09-26 17:58 ` [PATCH 2/2] providers/rxe: Implement the xrc transport protocol Jason Gunthorpe
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=20220917031536.21354-3-rpearsonhpe@gmail.com \
--to=rpearsonhpe@gmail.com \
--cc=jgg@nvidia.com \
--cc=linux-rdma@vger.kernel.org \
--cc=lizhijian@fujitsu.com \
--cc=zyjzyj2000@gmail.com \
/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
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.