static struct fi_info *
fi_ibv_eq_cm_getinfo(struct fi_ibv_fabric *fab, struct rdma_cm_event *event,
struct fi_info *pep_info)
{
struct fi_info *info, *fi;
struct fi_ibv_connreq *connreq;
const char *devname = ibv_get_device_name(event->id->verbs->device);
if (strcmp(devname, fab->info->domain_attr->name)) {
fi = fi_ibv_get_verbs_info(fab->all_infos, devname);
if (!fi)
return NULL;
} else {
fi = fab->info;
}
info = fi_dupinfo(fi);
if (!info)
return NULL;
info->fabric_attr->fabric = &fab->util_fabric.fabric_fid;
if (!(info->fabric_attr->prov_name = strdup(VERBS_PROV_NAME)))
goto err;
ofi_alter_info(info, pep_info, fab->util_fabric.fabric_fid.api_version);
info->src_addrlen = fi_ibv_sockaddr_len(rdma_get_local_addr(event->id));
if (!(info->src_addr = malloc(info->src_addrlen)))
goto err;
memcpy(info->src_addr, rdma_get_local_addr(event->id), info->src_addrlen);
info->dest_addrlen = fi_ibv_sockaddr_len(rdma_get_peer_addr(event->id));
if (!(info->dest_addr = malloc(info->dest_addrlen)))
goto err;
memcpy(info->dest_addr, rdma_get_peer_addr(event->id), info->dest_addrlen);
VERBS_INFO(FI_LOG_CORE, "src_addr: %s:%d\n",
inet_ntoa(((struct sockaddr_in *)info->src_addr)->sin_addr),
ntohs(((struct sockaddr_in *)info->src_addr)->sin_port));
VERBS_INFO(FI_LOG_CORE, "dst_addr: %s:%d\n",
inet_ntoa(((struct sockaddr_in *)info->dest_addr)->sin_addr),
ntohs(((struct sockaddr_in *)info->dest_addr)->sin_port));
connreq = calloc(1, sizeof *connreq);
if (!connreq)
goto err;
connreq->handle.fclass = FI_CLASS_CONNREQ;
connreq->id = event->id;
info->handle = &connreq->handle;
return info;
err:
fi_freeinfo(info);
return NULL;
}
/* TODO: This should copy the listening fi_info as the base */
static struct fi_info *
fi_ibv_eq_cm_getinfo(struct fi_ibv_fabric *fab, struct rdma_cm_event *event)
{
struct fi_info *info, *fi;
struct fi_ibv_connreq *connreq;
fi = fi_ibv_get_verbs_info(ibv_get_device_name(event->id->verbs->device));
if (!fi)
return NULL;
info = fi_dupinfo(fi);
if (!info)
return NULL;
info->fabric_attr->fabric = &fab->fabric_fid;
if (!(info->fabric_attr->prov_name = strdup(VERBS_PROV_NAME)))
goto err;
fi_ibv_update_info(NULL, info);
info->src_addrlen = fi_ibv_sockaddr_len(rdma_get_local_addr(event->id));
if (!(info->src_addr = malloc(info->src_addrlen)))
goto err;
memcpy(info->src_addr, rdma_get_local_addr(event->id), info->src_addrlen);
info->dest_addrlen = fi_ibv_sockaddr_len(rdma_get_peer_addr(event->id));
if (!(info->dest_addr = malloc(info->dest_addrlen)))
goto err;
memcpy(info->dest_addr, rdma_get_peer_addr(event->id), info->dest_addrlen);
FI_INFO(&fi_ibv_prov, FI_LOG_CORE, "src_addr: %s:%d\n",
inet_ntoa(((struct sockaddr_in *)info->src_addr)->sin_addr),
ntohs(((struct sockaddr_in *)info->src_addr)->sin_port));
FI_INFO(&fi_ibv_prov, FI_LOG_CORE, "dst_addr: %s:%d\n",
inet_ntoa(((struct sockaddr_in *)info->dest_addr)->sin_addr),
ntohs(((struct sockaddr_in *)info->dest_addr)->sin_port));
connreq = calloc(1, sizeof *connreq);
if (!connreq)
goto err;
connreq->handle.fclass = FI_CLASS_CONNREQ;
connreq->id = event->id;
info->handle = &connreq->handle;
return info;
err:
fi_freeinfo(info);
return NULL;
}
int fi_ibv_accept_xrc(struct fi_ibv_xrc_ep *ep, int reciprocal,
void *param, size_t paramlen)
{
struct sockaddr *addr;
struct fi_ibv_connreq *connreq;
struct rdma_conn_param conn_param = { 0 };
struct fi_ibv_xrc_cm_data *cm_data = param;
int ret;
addr = rdma_get_local_addr(ep->tgt_id);
if (addr)
ofi_straddr_dbg(&fi_ibv_prov, FI_LOG_CORE, "src_addr", addr);
addr = rdma_get_peer_addr(ep->tgt_id);
if (addr)
ofi_straddr_dbg(&fi_ibv_prov, FI_LOG_CORE, "dest_addr", addr);
connreq = container_of(ep->base_ep.info->handle,
struct fi_ibv_connreq, handle);
ret = fi_ibv_ep_create_tgt_qp(ep, connreq->xrc.conn_data);
if (ret)
return ret;
fi_ibv_set_xrc_cm_data(cm_data, connreq->xrc.is_reciprocal,
connreq->xrc.conn_tag, connreq->xrc.port,
ep->srqn);
conn_param.private_data = cm_data;
conn_param.private_data_len = paramlen;
conn_param.responder_resources = RDMA_MAX_RESP_RES;
conn_param.initiator_depth = RDMA_MAX_INIT_DEPTH;
conn_param.flow_control = 1;
conn_param.rnr_retry_count = 7;
if (ep->base_ep.srq_ep)
conn_param.srq = 1;
/* Shared INI/TGT QP connection use a temporarily reserved QP number
* avoid the appearance of being a stale/duplicate IB CM message */
if (!ep->tgt_id->qp)
conn_param.qp_num = ep->conn_setup->rsvd_tgt_qpn->qp_num;
if (connreq->xrc.is_reciprocal)
fi_ibv_eq_clear_xrc_conn_tag(ep);
else
ep->conn_setup->conn_tag = connreq->xrc.conn_tag;
assert(ep->conn_state == FI_IBV_XRC_UNCONNECTED ||
ep->conn_state == FI_IBV_XRC_ORIG_CONNECTED);
fi_ibv_next_xrc_conn_state(ep);
ret = rdma_accept(ep->tgt_id, &conn_param);
if (ret) {
ret = -errno;
VERBS_INFO_ERRNO(FI_LOG_EP_CTRL,
"XRC TGT, ibv_open_qp", errno);
fi_ibv_prev_xrc_conn_state(ep);
}
free(connreq);
return ret;
}
static int fi_ibv_msg_ep_getpeer(struct fid_ep *ep, void *addr, size_t *addrlen)
{
struct fi_ibv_msg_ep *_ep;
struct sockaddr *sa;
_ep = container_of(ep, struct fi_ibv_msg_ep, ep_fid);
sa = rdma_get_peer_addr(_ep->id);
return fi_ibv_copy_addr(addr, addrlen, sa);
}
static struct fi_info *
__fi_eq_cm_getinfo(struct __fid_fabric *fab, struct rdma_cm_event *event)
{
struct fi_info *fi;
fi = calloc(1, sizeof *fi);
if (!fi)
return NULL;
fi->type = FID_MSG;
if (event->id->verbs->device->transport_type == IBV_TRANSPORT_IWARP) {
fi->protocol = FI_PROTO_IWARP;
} else {
fi->protocol = FI_PROTO_IB_RC;
}
fi->ep_cap = FI_MSG | FI_RMA;
fi->src_addrlen = fi_sockaddr_len(rdma_get_local_addr(event->id));
if (!(fi->src_addr = malloc(fi->src_addrlen)))
goto err;
memcpy(fi->src_addr, rdma_get_local_addr(event->id), fi->src_addrlen);
fi->dest_addrlen = fi_sockaddr_len(rdma_get_peer_addr(event->id));
if (!(fi->dest_addr = malloc(fi->dest_addrlen)))
goto err;
memcpy(fi->dest_addr, rdma_get_peer_addr(event->id), fi->dest_addrlen);
if (!(fi->fabric_name = strdup(fab->name)))
goto err;
if (!(fi->domain_name = strdup(event->id->verbs->device->name)))
goto err;
fi->datalen = sizeof event->id;
fi->data = event->id;
return fi;
err:
fi_freeinfo(fi);
return NULL;
}
/*
* svc_rdma_ncreate: waits for connection request and returns transport
*/
SVCXPRT *
svc_rdma_ncreate(void *arg, const u_int sendsize, const u_int recvsize,
const u_int flags)
{
struct svc_rdma_xdr *sm;
struct sockaddr_storage *ss;
RDMAXPRT *l_xprt = arg;
RDMAXPRT *xprt = rpc_rdma_accept_wait(l_xprt, l_xprt->xa->timeout);
if (!xprt) {
__warnx(TIRPC_DEBUG_FLAG_ERROR,
"%s:%u ERROR (return)",
__func__, __LINE__);
return (NULL);
}
sm = mem_zalloc(sizeof (*sm));
sm->sm_xdrs.x_lib[1] = xprt;
xprt->xprt.xp_p2 = sm;
xprt->xprt.xp_flags = flags;
/* fixme: put something here, but make it not work on fd operations. */
xprt->xprt.xp_fd = -1;
ss = (struct sockaddr_storage *)rdma_get_local_addr(xprt->cm_id);
__rpc_set_address(&xprt->xprt.xp_local, ss, 0);
ss = (struct sockaddr_storage *)rdma_get_peer_addr(xprt->cm_id);
__rpc_set_address(&xprt->xprt.xp_remote, ss, 0);
svc_rdma_ops(&xprt->xprt);
if (xdr_rdma_create(&sm->sm_xdrs, xprt, sendsize, recvsize, flags)) {
goto freedata;
}
if (rpc_rdma_accept_finalize(xprt)) {
goto freedata;
}
return (&xprt->xprt);
freedata:
mem_free(sm, sizeof (*sm));
xprt->xprt.xp_p2 = NULL;
xprt_unregister(&xprt->xprt);
return (NULL);
}
void fi_ibv_log_ep_conn(struct fi_ibv_xrc_ep *ep, char *desc)
{
struct sockaddr *addr;
char buf[OFI_ADDRSTRLEN];
size_t len = sizeof(buf);
if (!fi_log_enabled(&fi_ibv_prov, FI_LOG_INFO, FI_LOG_FABRIC))
return;
VERBS_INFO(FI_LOG_FABRIC, "EP %p, %s\n", ep, desc);
VERBS_INFO(FI_LOG_FABRIC,
"EP %p, CM ID %p, TGT CM ID %p, SRQN %d Peer SRQN %d\n",
ep, ep->base_ep.id, ep->tgt_id, ep->srqn, ep->peer_srqn);
assert(ep->base_ep.id);
addr = rdma_get_local_addr(ep->base_ep.id);
if (addr) {
ofi_straddr(buf, &len, ep->base_ep.info->addr_format, addr);
VERBS_INFO(FI_LOG_FABRIC, "EP %p src_addr: %s\n", ep, buf);
}
addr = rdma_get_peer_addr(ep->base_ep.id);
if (addr) {
len = sizeof(buf);
ofi_straddr(buf, &len, ep->base_ep.info->addr_format, addr);
VERBS_INFO(FI_LOG_FABRIC, "EP %p dst_addr: %s\n", ep, buf);
}
if (ep->base_ep.ibv_qp) {
VERBS_INFO(FI_LOG_FABRIC, "EP %p, INI QP Num %d\n",
ep, ep->base_ep.ibv_qp->qp_num);
VERBS_INFO(FI_LOG_FABRIC, "EP %p, Remote TGT QP Num %d\n", ep,
ep->ini_conn->tgt_qpn);
}
if (ep->tgt_ibv_qp)
VERBS_INFO(FI_LOG_FABRIC, "EP %p, TGT QP Num %d\n",
ep, ep->tgt_ibv_qp->qp_num);
if (ep->conn_setup && ep->conn_setup->rsvd_ini_qpn)
VERBS_INFO(FI_LOG_FABRIC, "EP %p, Reserved INI QPN %d\n",
ep, ep->conn_setup->rsvd_ini_qpn->qp_num);
if (ep->conn_setup && ep->conn_setup->rsvd_tgt_qpn)
VERBS_INFO(FI_LOG_FABRIC, "EP %p, Reserved TGT QPN %d\n",
ep, ep->conn_setup->rsvd_tgt_qpn->qp_num);
}
static int
fi_ibv_msg_ep_connect(struct fid_ep *ep, const void *addr,
const void *param, size_t paramlen)
{
struct fi_ibv_msg_ep *_ep;
struct rdma_conn_param conn_param;
struct sockaddr *src_addr, *dst_addr;
int ret;
_ep = container_of(ep, struct fi_ibv_msg_ep, ep_fid);
if (!_ep->id->qp) {
ret = ep->fid.ops->control(&ep->fid, FI_ENABLE, NULL);
if (ret)
return ret;
}
memset(&conn_param, 0, sizeof conn_param);
conn_param.private_data = param;
conn_param.private_data_len = paramlen;
conn_param.responder_resources = RDMA_MAX_RESP_RES;
conn_param.initiator_depth = RDMA_MAX_INIT_DEPTH;
conn_param.flow_control = 1;
conn_param.retry_count = 15;
conn_param.rnr_retry_count = 7;
if (_ep->srq_ep)
conn_param.srq = 1;
src_addr = rdma_get_local_addr(_ep->id);
if (src_addr) {
FI_INFO(&fi_ibv_prov, FI_LOG_CORE, "src_addr: %s:%d\n",
inet_ntoa(((struct sockaddr_in *)src_addr)->sin_addr),
ntohs(((struct sockaddr_in *)src_addr)->sin_port));
}
dst_addr = rdma_get_peer_addr(_ep->id);
if (dst_addr) {
FI_INFO(&fi_ibv_prov, FI_LOG_CORE, "dst_addr: %s:%d\n",
inet_ntoa(((struct sockaddr_in *)dst_addr)->sin_addr),
ntohs(((struct sockaddr_in *)dst_addr)->sin_port));
}
return rdma_connect(_ep->id, &conn_param) ? -errno : 0;
}
int fi_ibv_connect_xrc(struct fi_ibv_xrc_ep *ep, struct sockaddr *addr,
int reciprocal, void *param, size_t paramlen)
{
struct fi_ibv_domain *domain = fi_ibv_ep_to_domain(&ep->base_ep);
struct sockaddr *peer_addr;
int ret;
assert(ep->base_ep.id && !ep->base_ep.ibv_qp && !ep->ini_conn);
peer_addr = rdma_get_local_addr(ep->base_ep.id);
if (peer_addr)
ofi_straddr_dbg(&fi_ibv_prov, FI_LOG_FABRIC,
"XRC connect src_addr", peer_addr);
peer_addr = rdma_get_peer_addr(ep->base_ep.id);
if (peer_addr)
ofi_straddr_dbg(&fi_ibv_prov, FI_LOG_FABRIC,
"XRC connect dest_addr", peer_addr);
if (!reciprocal) {
ep->conn_setup = calloc(1, sizeof(*ep->conn_setup));
if (!ep->conn_setup)
return -FI_ENOMEM;
}
fastlock_acquire(&domain->xrc.ini_mgmt_lock);
ret = fi_ibv_get_shared_ini_conn(ep, &ep->ini_conn);
if (ret) {
VERBS_WARN(FI_LOG_FABRIC,
"Get of shared XRC INI connection failed %d\n", ret);
fastlock_release(&domain->xrc.ini_mgmt_lock);
if (!reciprocal) {
free(ep->conn_setup);
ep->conn_setup = NULL;
}
return ret;
}
fi_ibv_add_pending_ini_conn(ep, reciprocal, param, paramlen);
fi_ibv_sched_ini_conn(ep->ini_conn);
fastlock_release(&domain->xrc.ini_mgmt_lock);
return FI_SUCCESS;
}
