DIRECT_FN STATIC int gnix_accept(struct fid_ep *ep, const void *param,
size_t paramlen)
{
int ret;
struct gnix_vc *vc;
struct gnix_fid_ep *ep_priv;
struct gnix_pep_sock_conn *conn;
struct gnix_pep_sock_connresp resp;
struct fi_eq_cm_entry eq_entry, *eqe_ptr;
struct gnix_mbox *mbox = NULL;
struct gnix_av_addr_entry av_entry;
if (!ep || (paramlen && !param) || paramlen > GNIX_CM_DATA_MAX_SIZE)
return -FI_EINVAL;
ep_priv = container_of(ep, struct gnix_fid_ep, ep_fid.fid);
COND_ACQUIRE(ep_priv->requires_lock, &ep_priv->vc_lock);
/* Look up and unpack the connection request used to create this EP. */
conn = (struct gnix_pep_sock_conn *)ep_priv->info->handle;
if (!conn || conn->fid.fclass != FI_CLASS_CONNREQ) {
ret = -FI_EINVAL;
goto err_unlock;
}
/* Create new VC without CM data. */
av_entry.gnix_addr = ep_priv->dest_addr.gnix_addr;
av_entry.cm_nic_cdm_id = ep_priv->dest_addr.cm_nic_cdm_id;
ret = _gnix_vc_alloc(ep_priv, &av_entry, &vc);
if (ret != FI_SUCCESS) {
GNIX_WARN(FI_LOG_EP_CTRL, "Failed to create VC: %d\n", ret);
goto err_unlock;
}
ep_priv->vc = vc;
ep_priv->vc->peer_caps = conn->req.peer_caps;
ep_priv->vc->peer_id = conn->req.vc_id;
ret = _gnix_mbox_alloc(vc->ep->nic->mbox_hndl, &mbox);
if (ret != FI_SUCCESS) {
GNIX_WARN(FI_LOG_EP_DATA, "_gnix_mbox_alloc returned %s\n",
fi_strerror(-ret));
goto err_mbox_alloc;
}
vc->smsg_mbox = mbox;
/* Initialize the GNI connection. */
ret = _gnix_vc_smsg_init(vc, conn->req.vc_id,
&conn->req.vc_mbox_attr,
&conn->req.cq_irq_mdh);
if (ret != FI_SUCCESS) {
GNIX_WARN(FI_LOG_EP_CTRL,
"_gnix_vc_smsg_init returned %s\n",
fi_strerror(-ret));
goto err_smsg_init;
}
vc->conn_state = GNIX_VC_CONNECTED;
/* Send ACK with VC attrs to allow peer to initialize GNI connection. */
resp.cmd = GNIX_PEP_SOCK_RESP_ACCEPT;
resp.vc_id = vc->vc_id;
resp.vc_mbox_attr.msg_type = GNI_SMSG_TYPE_MBOX_AUTO_RETRANSMIT;
resp.vc_mbox_attr.msg_buffer = mbox->base;
resp.vc_mbox_attr.buff_size = vc->ep->nic->mem_per_mbox;
resp.vc_mbox_attr.mem_hndl = *mbox->memory_handle;
resp.vc_mbox_attr.mbox_offset = (uint64_t)mbox->offset;
resp.vc_mbox_attr.mbox_maxcredit =
ep_priv->domain->params.mbox_maxcredit;
resp.vc_mbox_attr.msg_maxsize =
ep_priv->domain->params.mbox_msg_maxsize;
resp.cq_irq_mdh = ep_priv->nic->irq_mem_hndl;
resp.peer_caps = ep_priv->caps;
resp.cm_data_len = paramlen;
if (paramlen) {
eqe_ptr = (struct fi_eq_cm_entry *)resp.eqe_buf;
memcpy(eqe_ptr->data, param, paramlen);
}
ret = write(conn->sock_fd, &resp, sizeof(resp));
if (ret != sizeof(resp)) {
GNIX_WARN(FI_LOG_EP_CTRL,
"Failed to send resp, errno: %d\n",
errno);
ret = -FI_EIO;
goto err_write;
}
/* Notify user that this side is connected. */
eq_entry.fid = &ep_priv->ep_fid.fid;
ret = fi_eq_write(&ep_priv->eq->eq_fid, FI_CONNECTED, &eq_entry,
sizeof(eq_entry), 0);
if (ret != sizeof(eq_entry)) {
GNIX_WARN(FI_LOG_EP_CTRL,
"fi_eq_write failed, err: %d\n", ret);
goto err_eq_write;
}
/* Free the connection request. */
free(conn);
ep_priv->conn_state = GNIX_EP_CONNECTED;
COND_RELEASE(ep_priv->requires_lock, &ep_priv->vc_lock);
GNIX_DEBUG(FI_LOG_EP_CTRL, "Sent conn accept: %p\n", ep_priv);
return FI_SUCCESS;
err_eq_write:
err_write:
err_smsg_init:
_gnix_mbox_free(ep_priv->vc->smsg_mbox);
ep_priv->vc->smsg_mbox = NULL;
err_mbox_alloc:
_gnix_vc_destroy(ep_priv->vc);
ep_priv->vc = NULL;
err_unlock:
COND_RELEASE(ep_priv->requires_lock, &ep_priv->vc_lock);
return ret;
}
/* Process a connection response on an FI_EP_MSG. */
static int __gnix_ep_connresp(struct gnix_fid_ep *ep,
struct gnix_pep_sock_connresp *resp)
{
int ret = FI_SUCCESS;
struct fi_eq_cm_entry *eq_entry;
int eqe_size;
switch (resp->cmd) {
case GNIX_PEP_SOCK_RESP_ACCEPT:
ep->vc->peer_caps = resp->peer_caps;
ep->vc->peer_id = resp->vc_id;
/* Initialize the GNI connection. */
ret = _gnix_vc_smsg_init(ep->vc, resp->vc_id,
&resp->vc_mbox_attr,
&resp->cq_irq_mdh);
if (ret != FI_SUCCESS) {
GNIX_WARN(FI_LOG_EP_CTRL,
"_gnix_vc_smsg_init returned %s\n",
fi_strerror(-ret));
return ret;
}
ep->vc->conn_state = GNIX_VC_CONNECTED;
ep->conn_state = GNIX_EP_CONNECTED;
/* Notify user that this side is connected. */
eq_entry = (struct fi_eq_cm_entry *)resp->eqe_buf;
eq_entry->fid = &ep->ep_fid.fid;
eqe_size = sizeof(*eq_entry) + resp->cm_data_len;
ret = fi_eq_write(&ep->eq->eq_fid, FI_CONNECTED, eq_entry,
eqe_size, 0);
if (ret != eqe_size) {
GNIX_WARN(FI_LOG_EP_CTRL,
"fi_eq_write failed, err: %d\n", ret);
return ret;
}
GNIX_DEBUG(FI_LOG_EP_CTRL, "Received conn accept: %p\n", ep);
break;
case GNIX_PEP_SOCK_RESP_REJECT:
/* Undo the connect and generate a failure EQE. */
close(ep->conn_fd);
ep->conn_fd = -1;
_gnix_mbox_free(ep->vc->smsg_mbox);
ep->vc->smsg_mbox = NULL;
_gnix_vc_destroy(ep->vc);
ep->vc = NULL;
ep->conn_state = GNIX_EP_UNCONNECTED;
/* Generate EQE. */
eq_entry = (struct fi_eq_cm_entry *)resp->eqe_buf;
eq_entry->fid = &ep->ep_fid.fid;
eq_entry = (struct fi_eq_cm_entry *)resp->eqe_buf;
ret = _gnix_eq_write_error(ep->eq, &ep->ep_fid.fid, NULL, 0,
FI_ECONNREFUSED, FI_ECONNREFUSED,
&eq_entry->data, resp->cm_data_len);
if (ret != FI_SUCCESS) {
GNIX_WARN(FI_LOG_EP_CTRL,
"fi_eq_write failed, err: %d\n", ret);
return ret;
}
GNIX_DEBUG(FI_LOG_EP_CTRL, "Conn rejected: %p\n", ep);
break;
default:
GNIX_INFO(FI_LOG_EP_CTRL, "Invalid response command: %d\n",
resp->cmd);
return -FI_EINVAL;
}
return FI_SUCCESS;
}
DIRECT_FN STATIC int gnix_connect(struct fid_ep *ep, const void *addr,
const void *param, size_t paramlen)
{
int ret;
struct gnix_fid_ep *ep_priv;
struct sockaddr_in saddr;
struct gnix_pep_sock_connreq req;
struct fi_eq_cm_entry *eqe_ptr;
struct gnix_vc *vc;
struct gnix_mbox *mbox = NULL;
struct gnix_av_addr_entry av_entry;
if (!ep || !addr || (paramlen && !param) ||
paramlen > GNIX_CM_DATA_MAX_SIZE)
return -FI_EINVAL;
ep_priv = container_of(ep, struct gnix_fid_ep, ep_fid.fid);
COND_ACQUIRE(ep_priv->requires_lock, &ep_priv->vc_lock);
if (ep_priv->conn_state != GNIX_EP_UNCONNECTED) {
ret = -FI_EINVAL;
goto err_unlock;
}
ret = _gnix_pe_to_ip(addr, &saddr);
if (ret != FI_SUCCESS) {
GNIX_INFO(FI_LOG_EP_CTRL,
"Failed to translate gnix_ep_name to IP\n");
goto err_unlock;
}
/* Create new VC without CM data. */
av_entry.gnix_addr = ep_priv->dest_addr.gnix_addr;
av_entry.cm_nic_cdm_id = ep_priv->dest_addr.cm_nic_cdm_id;
ret = _gnix_vc_alloc(ep_priv, &av_entry, &vc);
if (ret != FI_SUCCESS) {
GNIX_WARN(FI_LOG_EP_CTRL,
"Failed to create VC:: %d\n",
ret);
goto err_unlock;
}
ep_priv->vc = vc;
ret = _gnix_mbox_alloc(vc->ep->nic->mbox_hndl, &mbox);
if (ret != FI_SUCCESS) {
GNIX_WARN(FI_LOG_EP_DATA,
"_gnix_mbox_alloc returned %s\n",
fi_strerror(-ret));
goto err_mbox_alloc;
}
vc->smsg_mbox = mbox;
ep_priv->conn_fd = socket(AF_INET, SOCK_STREAM, 0);
if (ep_priv->conn_fd < 0) {
GNIX_WARN(FI_LOG_EP_CTRL,
"Failed to create connect socket, errno: %d\n",
errno);
ret = -FI_ENOSPC;
goto err_socket;
}
/* Currently blocks until connected. */
ret = connect(ep_priv->conn_fd, (struct sockaddr *)&saddr,
sizeof(saddr));
if (ret) {
GNIX_WARN(FI_LOG_EP_CTRL,
"Failed to connect, errno: %d\n",
errno);
ret = -FI_EIO;
goto err_connect;
}
req.info = *ep_priv->info;
/* Note addrs are swapped. */
memcpy(&req.dest_addr, (void *)&ep_priv->src_addr,
sizeof(req.dest_addr));
memcpy(&ep_priv->dest_addr, addr, sizeof(ep_priv->dest_addr));
memcpy(&req.src_addr, addr, sizeof(req.src_addr));
if (ep_priv->info->tx_attr)
req.tx_attr = *ep_priv->info->tx_attr;
if (ep_priv->info->rx_attr)
req.rx_attr = *ep_priv->info->rx_attr;
if (ep_priv->info->ep_attr)
req.ep_attr = *ep_priv->info->ep_attr;
if (ep_priv->info->domain_attr)
req.domain_attr = *ep_priv->info->domain_attr;
if (ep_priv->info->fabric_attr)
req.fabric_attr = *ep_priv->info->fabric_attr;
req.fabric_attr.fabric = NULL;
req.domain_attr.domain = NULL;
req.vc_id = vc->vc_id;
req.vc_mbox_attr.msg_type = GNI_SMSG_TYPE_MBOX_AUTO_RETRANSMIT;
req.vc_mbox_attr.msg_buffer = mbox->base;
req.vc_mbox_attr.buff_size = vc->ep->nic->mem_per_mbox;
req.vc_mbox_attr.mem_hndl = *mbox->memory_handle;
req.vc_mbox_attr.mbox_offset = (uint64_t)mbox->offset;
req.vc_mbox_attr.mbox_maxcredit =
ep_priv->domain->params.mbox_maxcredit;
req.vc_mbox_attr.msg_maxsize = ep_priv->domain->params.mbox_msg_maxsize;
req.cq_irq_mdh = ep_priv->nic->irq_mem_hndl;
req.peer_caps = ep_priv->caps;
req.cm_data_len = paramlen;
if (paramlen) {
eqe_ptr = (struct fi_eq_cm_entry *)req.eqe_buf;
memcpy(eqe_ptr->data, param, paramlen);
}
ret = write(ep_priv->conn_fd, &req, sizeof(req));
if (ret != sizeof(req)) {
GNIX_WARN(FI_LOG_EP_CTRL,
"Failed to send req, errno: %d\n",
errno);
ret = -FI_EIO;
goto err_write;
}
/* set fd to non-blocking now since we can't block within the eq
* progress system
*/
fi_fd_nonblock(ep_priv->conn_fd);
ep_priv->conn_state = GNIX_EP_CONNECTING;
COND_RELEASE(ep_priv->requires_lock, &ep_priv->vc_lock);
GNIX_DEBUG(FI_LOG_EP_CTRL, "Sent conn req: %p, %s\n",
ep_priv, inet_ntoa(saddr.sin_addr));
return FI_SUCCESS;
err_write:
err_connect:
close(ep_priv->conn_fd);
ep_priv->conn_fd = -1;
err_socket:
_gnix_mbox_free(ep_priv->vc->smsg_mbox);
ep_priv->vc->smsg_mbox = NULL;
err_mbox_alloc:
_gnix_vc_destroy(ep_priv->vc);
ep_priv->vc = NULL;
err_unlock:
COND_RELEASE(ep_priv->requires_lock, &ep_priv->vc_lock);
return ret;
}
/* Destroy an unconnected VC. More Support is needed to shutdown and destroy
* an active VC. */
int _gnix_vc_destroy(struct gnix_vc *vc)
{
int ret = FI_SUCCESS;
struct gnix_nic *nic = NULL;
gni_return_t status;
GNIX_TRACE(FI_LOG_EP_CTRL, "\n");
if (vc->ep == NULL) {
GNIX_WARN(FI_LOG_EP_CTRL, "ep null\n");
return -FI_EINVAL;
}
nic = vc->ep->nic;
if (nic == NULL) {
GNIX_WARN(FI_LOG_EP_CTRL, "ep nic null for vc %p\n", vc);
return -FI_EINVAL;
}
/*
* move vc state to terminating
*/
vc->conn_state = GNIX_VC_CONN_TERMINATING;
/*
* try to unbind the gni_ep if non-NULL.
* If there are SMSG or PostFMA/RDMA outstanding
* wait here for them to complete
*/
if (vc->gni_ep != NULL) {
while (status == GNI_RC_NOT_DONE) {
fastlock_acquire(&nic->lock);
status = GNI_EpUnbind(vc->gni_ep);
fastlock_release(&nic->lock);
if ((status != GNI_RC_NOT_DONE) &&
(status != GNI_RC_SUCCESS)) {
GNIX_WARN(FI_LOG_EP_CTRL,
"GNI_EpUnBind returned %s\n",
gni_err_str[status]);
break;
}
if (status == GNI_RC_NOT_DONE)
_gnix_nic_progress(nic);
}
fastlock_acquire(&nic->lock);
status = GNI_EpDestroy(vc->gni_ep);
fastlock_release(&nic->lock);
if (status != GNI_RC_SUCCESS)
GNIX_WARN(FI_LOG_EP_CTRL,
"GNI_EpDestroy returned %s\n",
gni_err_str[status]);
}
/*
* if the vc is in a nic's work queue, remove it
*/
__gnix_vc_cancel(vc);
/*
* We may eventually want to check the state of the VC, if we
* implement true VC shutdown.
if ((vc->conn_state != GNIX_VC_CONN_NONE)
&& (vc->conn_state != GNIX_VC_CONN_TERMINATED)) {
GNIX_WARN(FI_LOG_EP_CTRL,
"vc conn state %d\n",
vc->conn_state);
GNIX_WARN(FI_LOG_EP_CTRL, "vc conn state error\n");
return -FI_EBUSY;
}
*/
/*
* if send_q not empty, return -FI_EBUSY
* Note for FI_EP_MSG type eps, this behavior
* may not be correct for handling fi_shutdown.
*/
if (!slist_empty(&vc->tx_queue)) {
GNIX_WARN(FI_LOG_EP_CTRL, "vc sendqueue not empty\n");
return -FI_EBUSY;
}
fastlock_destroy(&vc->tx_queue_lock);
if (vc->smsg_mbox != NULL) {
ret = _gnix_mbox_free(vc->smsg_mbox);
if (ret != FI_SUCCESS)
GNIX_WARN(FI_LOG_EP_CTRL,
"_gnix_mbox_free returned %s\n",
fi_strerror(-ret));
vc->smsg_mbox = NULL;
}
if (vc->dgram != NULL) {
ret = _gnix_dgram_free(vc->dgram);
if (ret != FI_SUCCESS)
GNIX_WARN(FI_LOG_EP_CTRL,
"_gnix_dgram_free returned %s\n",
fi_strerror(-ret));
vc->dgram = NULL;
}
ret = _gnix_nic_free_rem_id(nic, vc->vc_id);
if (ret != FI_SUCCESS)
GNIX_WARN(FI_LOG_EP_CTRL,
"__gnix_vc_free_id returned %s\n",
fi_strerror(-ret));
_gnix_free_bitmap(&vc->flags);
free(vc);
return ret;
}