static int rxm_ep_close(struct fid *fid)
{
struct rxm_ep *rxm_ep;
int ret;
rxm_ep = container_of(fid, struct rxm_ep, util_ep.ep_fid.fid);
if (rxm_ep->util_ep.av) {
ofi_cmap_free(rxm_ep->cmap);
atomic_dec(&rxm_ep->util_ep.av->ref);
}
rxm_ep_txrx_res_close(rxm_ep);
ret = rxm_ep_msg_res_close(rxm_ep);
if (rxm_ep->util_ep.tx_cq) {
fid_list_remove(&rxm_ep->util_ep.tx_cq->ep_list,
&rxm_ep->util_ep.tx_cq->ep_list_lock,
&rxm_ep->util_ep.ep_fid.fid);
atomic_dec(&rxm_ep->util_ep.tx_cq->ref);
}
if (rxm_ep->util_ep.rx_cq) {
fid_list_remove(&rxm_ep->util_ep.rx_cq->ep_list,
&rxm_ep->util_ep.rx_cq->ep_list_lock,
&rxm_ep->util_ep.ep_fid.fid);
atomic_dec(&rxm_ep->util_ep.rx_cq->ref);
}
ofi_endpoint_close(&rxm_ep->util_ep);
free(rxm_ep);
return ret;
}
static int udpx_ep_close(struct fid *fid)
{
struct udpx_ep *ep;
struct util_wait_fd *wait;
ep = container_of(fid, struct udpx_ep, util_ep.ep_fid.fid);
if (ep->util_ep.rx_cq) {
if (ep->util_ep.rx_cq->wait) {
wait = container_of(ep->util_ep.rx_cq->wait,
struct util_wait_fd, util_wait);
fi_epoll_del(wait->epoll_fd, ep->sock);
}
fid_list_remove(&ep->util_ep.rx_cq->ep_list,
&ep->util_ep.rx_cq->ep_list_lock,
&ep->util_ep.ep_fid.fid);
atomic_dec(&ep->util_ep.rx_cq->ref);
}
static int sock_ep_close(struct fid *fid)
{
struct sock_ep *sock_ep;
char c = 0;
switch (fid->fclass) {
case FI_CLASS_EP:
sock_ep = container_of(fid, struct sock_ep, ep.fid);
break;
case FI_CLASS_SEP:
sock_ep = container_of(fid, struct sock_ep, ep.fid);
break;
default:
return -FI_EINVAL;
}
if (sock_ep->is_alias) {
ofi_atomic_dec32(&sock_ep->attr->ref);
return 0;
}
if (ofi_atomic_get32(&sock_ep->attr->ref) ||
ofi_atomic_get32(&sock_ep->attr->num_rx_ctx) ||
ofi_atomic_get32(&sock_ep->attr->num_tx_ctx))
return -FI_EBUSY;
if (sock_ep->attr->ep_type == FI_EP_MSG) {
sock_ep->attr->cm.do_listen = 0;
if (ofi_write_socket(sock_ep->attr->cm.signal_fds[0], &c, 1) != 1)
SOCK_LOG_DBG("Failed to signal\n");
if (sock_ep->attr->cm.listener_thread &&
pthread_join(sock_ep->attr->cm.listener_thread, NULL)) {
SOCK_LOG_ERROR("pthread join failed (%d)\n",
ofi_syserr());
}
ofi_close_socket(sock_ep->attr->cm.signal_fds[0]);
ofi_close_socket(sock_ep->attr->cm.signal_fds[1]);
} else {
if (sock_ep->attr->av)
ofi_atomic_dec32(&sock_ep->attr->av->ref);
}
if (sock_ep->attr->av) {
fastlock_acquire(&sock_ep->attr->av->list_lock);
fid_list_remove(&sock_ep->attr->av->ep_list,
&sock_ep->attr->lock, &sock_ep->ep.fid);
fastlock_release(&sock_ep->attr->av->list_lock);
}
pthread_mutex_lock(&sock_ep->attr->domain->pe->list_lock);
if (sock_ep->attr->tx_shared) {
fastlock_acquire(&sock_ep->attr->tx_ctx->lock);
dlist_remove(&sock_ep->attr->tx_ctx_entry);
fastlock_release(&sock_ep->attr->tx_ctx->lock);
}
if (sock_ep->attr->rx_shared) {
fastlock_acquire(&sock_ep->attr->rx_ctx->lock);
dlist_remove(&sock_ep->attr->rx_ctx_entry);
fastlock_release(&sock_ep->attr->rx_ctx->lock);
}
pthread_mutex_unlock(&sock_ep->attr->domain->pe->list_lock);
if (sock_ep->attr->conn_handle.do_listen) {
fastlock_acquire(&sock_ep->attr->domain->conn_listener.signal_lock);
fi_epoll_del(sock_ep->attr->domain->conn_listener.emap,
sock_ep->attr->conn_handle.sock);
fastlock_release(&sock_ep->attr->domain->conn_listener.signal_lock);
ofi_close_socket(sock_ep->attr->conn_handle.sock);
sock_ep->attr->conn_handle.do_listen = 0;
}
fastlock_destroy(&sock_ep->attr->cm.lock);
if (sock_ep->attr->eq) {
fastlock_acquire(&sock_ep->attr->eq->lock);
sock_ep_clear_eq_list(&sock_ep->attr->eq->list,
&sock_ep->ep);
/* Any err_data if present would be freed by
* sock_eq_clean_err_data_list when EQ is closed */
sock_ep_clear_eq_list(&sock_ep->attr->eq->err_list,
&sock_ep->ep);
fastlock_release(&sock_ep->attr->eq->lock);
}
if (sock_ep->attr->fclass != FI_CLASS_SEP) {
if (!sock_ep->attr->tx_shared)
sock_pe_remove_tx_ctx(sock_ep->attr->tx_array[0]);
sock_tx_ctx_close(sock_ep->attr->tx_array[0]);
sock_tx_ctx_free(sock_ep->attr->tx_array[0]);
}
if (sock_ep->attr->fclass != FI_CLASS_SEP) {
if (!sock_ep->attr->rx_shared)
sock_pe_remove_rx_ctx(sock_ep->attr->rx_array[0]);
sock_rx_ctx_close(sock_ep->attr->rx_array[0]);
sock_rx_ctx_free(sock_ep->attr->rx_array[0]);
}
free(sock_ep->attr->tx_array);
free(sock_ep->attr->rx_array);
if (sock_ep->attr->src_addr)
free(sock_ep->attr->src_addr);
if (sock_ep->attr->dest_addr)
free(sock_ep->attr->dest_addr);
fastlock_acquire(&sock_ep->attr->domain->pe->lock);
ofi_idm_reset(&sock_ep->attr->av_idm);
sock_conn_map_destroy(sock_ep->attr);
fastlock_release(&sock_ep->attr->domain->pe->lock);
ofi_atomic_dec32(&sock_ep->attr->domain->ref);
fastlock_destroy(&sock_ep->attr->lock);
free(sock_ep->attr);
free(sock_ep);
return 0;
}
int ofi_endpoint_close(struct util_ep *util_ep)
{
if (util_ep->tx_cq) {
fid_list_remove(&util_ep->tx_cq->ep_list,
&util_ep->tx_cq->ep_list_lock,
&util_ep->ep_fid.fid);
ofi_atomic_dec32(&util_ep->tx_cq->ref);
}
if (util_ep->rx_cq) {
fid_list_remove(&util_ep->rx_cq->ep_list,
&util_ep->rx_cq->ep_list_lock,
&util_ep->ep_fid.fid);
ofi_atomic_dec32(&util_ep->rx_cq->ref);
}
if (util_ep->rx_cntr) {
fid_list_remove(&util_ep->rx_cntr->ep_list,
&util_ep->rx_cntr->ep_list_lock,
&util_ep->ep_fid.fid);
ofi_atomic_dec32(&util_ep->rx_cntr->ref);
}
if (util_ep->tx_cntr) {
fid_list_remove(&util_ep->tx_cntr->ep_list,
&util_ep->tx_cntr->ep_list_lock,
&util_ep->ep_fid.fid);
ofi_atomic_dec32(&util_ep->tx_cntr->ref);
}
if (util_ep->rd_cntr) {
fid_list_remove(&util_ep->rd_cntr->ep_list,
&util_ep->rd_cntr->ep_list_lock,
&util_ep->ep_fid.fid);
ofi_atomic_dec32(&util_ep->rd_cntr->ref);
}
if (util_ep->wr_cntr) {
fid_list_remove(&util_ep->wr_cntr->ep_list,
&util_ep->wr_cntr->ep_list_lock,
&util_ep->ep_fid.fid);
ofi_atomic_dec32(&util_ep->wr_cntr->ref);
}
if (util_ep->rem_rd_cntr) {
fid_list_remove(&util_ep->rem_rd_cntr->ep_list,
&util_ep->rem_rd_cntr->ep_list_lock,
&util_ep->ep_fid.fid);
ofi_atomic_dec32(&util_ep->rem_rd_cntr->ref);
}
if (util_ep->rem_wr_cntr) {
fid_list_remove(&util_ep->rem_wr_cntr->ep_list,
&util_ep->rem_wr_cntr->ep_list_lock,
&util_ep->ep_fid.fid);
ofi_atomic_dec32(&util_ep->rem_wr_cntr->ref);
}
if (util_ep->av) {
fastlock_acquire(&util_ep->av->ep_list_lock);
dlist_remove(&util_ep->av_entry);
fastlock_release(&util_ep->av->ep_list_lock);
ofi_atomic_dec32(&util_ep->av->ref);
}
if (util_ep->eq)
ofi_atomic_dec32(&util_ep->eq->ref);
ofi_atomic_dec32(&util_ep->domain->ref);
fastlock_destroy(&util_ep->lock);
return 0;
}
static int rxd_ep_close(struct fid *fid)
{
int ret;
struct rxd_ep *ep;
struct rxd_pkt_entry *pkt_entry;
struct slist_entry *entry;
struct rxd_peer *peer;
ep = container_of(fid, struct rxd_ep, util_ep.ep_fid.fid);
dlist_foreach_container(&ep->active_peers, struct rxd_peer, peer, entry)
rxd_close_peer(ep, peer);
ret = fi_close(&ep->dg_ep->fid);
if (ret)
return ret;
if (ep->dg_cq) {
ret = fi_close(&ep->dg_cq->fid);
if (ret)
return ret;
}
while (!slist_empty(&ep->rx_pkt_list)) {
entry = slist_remove_head(&ep->rx_pkt_list);
pkt_entry = container_of(entry, struct rxd_pkt_entry, s_entry);
ofi_buf_free(pkt_entry);
}
while (!dlist_empty(&ep->unexp_list)) {
dlist_pop_front(&ep->unexp_list, struct rxd_pkt_entry,
pkt_entry, d_entry);
ofi_buf_free(pkt_entry);
}
while (!dlist_empty(&ep->unexp_tag_list)) {
dlist_pop_front(&ep->unexp_tag_list, struct rxd_pkt_entry,
pkt_entry, d_entry);
ofi_buf_free(pkt_entry);
}
while (!dlist_empty(&ep->ctrl_pkts)) {
dlist_pop_front(&ep->ctrl_pkts, struct rxd_pkt_entry,
pkt_entry, d_entry);
ofi_buf_free(pkt_entry);
}
if (ep->util_ep.tx_cq) {
/* TODO: wait handling */
fid_list_remove(&ep->util_ep.tx_cq->ep_list,
&ep->util_ep.tx_cq->ep_list_lock,
&ep->util_ep.ep_fid.fid);
}
if (ep->util_ep.rx_cq) {
if (ep->util_ep.rx_cq != ep->util_ep.tx_cq) {
/* TODO: wait handling */
fid_list_remove(&ep->util_ep.rx_cq->ep_list,
&ep->util_ep.rx_cq->ep_list_lock,
&ep->util_ep.ep_fid.fid);
}
}
rxd_ep_free_res(ep);
ofi_endpoint_close(&ep->util_ep);
free(ep);
return 0;
}
void sock_cntr_remove_rx_ctx(struct sock_cntr *cntr, struct sock_rx_ctx *rx_ctx)
{
struct fid *fid = &rx_ctx->ctx.fid;
fid_list_remove(&cntr->rx_list, &cntr->list_lock, fid);
atomic_dec(&cntr->ref);
}
void sock_cntr_remove_tx_ctx(struct sock_cntr *cntr, struct sock_tx_ctx *tx_ctx)
{
struct fid *fid = &tx_ctx->fid.ctx.fid;
fid_list_remove(&cntr->tx_list, &cntr->list_lock, fid);
atomic_dec(&cntr->ref);
}