/*
* dapl_hca_alloc
*
* alloc and initialize an HCA struct
*
* Input:
* name
* port
*
* Output:
* hca_ptr
*
* Returns:
* none
*
*/
DAPL_HCA *dapl_hca_alloc(char *name, char *port)
{
DAPL_HCA *hca_ptr;
hca_ptr = dapl_os_alloc(sizeof(DAPL_HCA));
if (NULL == hca_ptr) {
goto bail;
}
dapl_os_memzero(hca_ptr, sizeof(DAPL_HCA));
dapl_os_lock_init(&hca_ptr->lock);
dapl_llist_init_head(&hca_ptr->ia_list_head);
hca_ptr->name = dapl_os_strdup(name);
if (NULL == hca_ptr->name) {
goto bail;
}
hca_ptr->ib_hca_handle = IB_INVALID_HANDLE;
hca_ptr->port_num = dapl_os_strtol(port, NULL, 0);
return (hca_ptr);
bail:
if (NULL != hca_ptr)
dapl_os_free(hca_ptr, sizeof(DAPL_HCA));
return NULL;
}
void dapl_lmr_dealloc(IN DAPL_LMR * lmr)
{
lmr->header.magic = DAPL_MAGIC_INVALID; /* reset magic to prevent reuse */
dapl_ia_unlink_lmr(lmr->header.owner_ia, lmr);
dapl_os_lock_destroy(&lmr->header.lock);
dapl_os_free((void *)lmr, sizeof(DAPL_LMR));
}
/*
* dapl_ib_setup_conn_listener
*
* Have the CM set up a connection listener.
*
* Input:
* ibm_hca_handle HCA handle
* qp_handle QP handle
*
* Output:
* none
*
* Returns:
* DAT_SUCCESS
* DAT_INSUFFICIENT_RESOURCES
* DAT_INVALID_PARAMETER
*
*/
DAT_RETURN
dapls_ib_setup_conn_listener(IN DAPL_IA *ia_ptr,
IN DAT_UINT64 ServiceID, IN DAPL_SP *sp_ptr)
{
ib_hca_handle_t hca_hdl = ia_ptr->hca_ptr->ib_hca_handle;
struct dapls_ib_cm_srvc_handle *srvc_hdl;
dapl_service_register_t args;
struct sockaddr *s;
char addr_buf[64];
DAPL_EVD *evd_p = (DAPL_EVD *)sp_ptr->evd_handle;
int retval;
if (hca_hdl == NULL) {
dapl_dbg_log(DAPL_DBG_TYPE_ERR,
"setup_conn_listener: hca_handle == NULL\n");
return (DAT_INVALID_PARAMETER);
}
if (evd_p == NULL) {
dapl_dbg_log(DAPL_DBG_TYPE_ERR,
"setup_conn_listener: evd_p == NULL\n");
return (DAT_INVALID_PARAMETER);
}
srvc_hdl = (struct dapls_ib_cm_srvc_handle *)
dapl_os_alloc(sizeof (*srvc_hdl));
if (srvc_hdl == NULL) {
dapl_dbg_log(DAPL_DBG_TYPE_ERR,
"setup_conn_listener: srvc_handle == NULL\n");
return (DAT_INSUFFICIENT_RESOURCES);
}
args.sr_sid = ServiceID;
args.sr_evd_hkey = evd_p->ib_cq_handle->evd_hkey;
args.sr_sp_cookie = (uintptr_t)sp_ptr;
retval = ioctl(hca_hdl->ia_fd, DAPL_SERVICE_REGISTER, &args);
if (retval != 0) {
dapl_dbg_log(DAPL_DBG_TYPE_ERR,
"setup_conn_listener: register failed %s\n",
strerror(errno));
dapl_os_free(srvc_hdl, sizeof (*srvc_hdl));
return (dapls_convert_error(errno, retval));
}
srvc_hdl->sv_sp_hkey = args.sr_sp_hkey;
sp_ptr->cm_srvc_handle = srvc_hdl;
sp_ptr->conn_qual = args.sr_retsid;
s = (struct sockaddr *)&ia_ptr->hca_ptr->hca_address;
dapl_dbg_log(DAPL_DBG_TYPE_CM,
"setup_conn_listener: listening on ia_address %s, "
"conn_qual %016llu\n\n", dapls_inet_ntop(s, addr_buf, 64),
sp_ptr->conn_qual);
return (DAT_SUCCESS);
}
/*
* dapl_sp_free
*
* Free the passed in PSP structure.
*
* Input:
* entry point pointer
*
* Output:
* none
*
* Returns:
* none
*
*/
void
dapls_sp_free_sp(
IN DAPL_SP *sp_ptr)
{
dapl_os_assert(sp_ptr->header.magic == DAPL_MAGIC_PSP ||
sp_ptr->header.magic == DAPL_MAGIC_RSP);
dapl_os_assert(dapl_llist_is_empty(&sp_ptr->cr_list_head));
dapl_os_lock(&sp_ptr->header.lock);
/* reset magic to prevent reuse */
sp_ptr->header.magic = DAPL_MAGIC_INVALID;
dapl_os_unlock(&sp_ptr->header.lock);
dapl_os_free(sp_ptr, sizeof (DAPL_SP));
}
void dapli_thread_init(struct thread_draft *thread_draft)
{
sigset_t sigset;
void (*func) (void *);
void *data;
sigfillset(&sigset);
pthread_sigmask(SIG_BLOCK, &sigset, NULL);
func = thread_draft->func;
data = thread_draft->data;
dapl_os_free(thread_draft, sizeof(struct thread_draft));
(*func) (data);
}
/*
* dapl_cno_dealloc
*
* Free the passed in CNO structure.
*
* Input:
* cno_ptr
*
* Output:
* none
*
* Returns:
* none
*
*/
void
dapl_cno_dealloc(
IN DAPL_CNO *cno_ptr)
{
dapl_os_assert(cno_ptr->header.magic == DAPL_MAGIC_CNO);
dapl_os_assert(cno_ptr->cno_ref_count == 0);
/*
* deinitialize the header
*/
/* reset magic to prevent reuse */
cno_ptr->header.magic = DAPL_MAGIC_INVALID;
(void) dapl_os_wait_object_destroy(&cno_ptr->cno_wait_object);
dapl_os_free(cno_ptr, sizeof (DAPL_CNO));
}
/*
* dapl_ib_remove_conn_listener
*
* Have the CM remove a connection listener.
*
* Input:
* ia_handle IA handle
* ServiceID IB Channel Service ID
*
* Output:
* none
*
* Returns:
* DAT_SUCCESS
* DAT_INVALID_PARAMETER
*
*/
DAT_RETURN
dapls_ib_remove_conn_listener(IN DAPL_IA *ia_ptr, IN DAPL_SP *sp_ptr)
{
ib_hca_handle_t hca_hdl = ia_ptr->hca_ptr->ib_hca_handle;
struct dapls_ib_cm_srvc_handle *srvc_hdl;
dapl_service_deregister_t args;
struct sockaddr *s;
char addr_buf[64];
int retval;
if (hca_hdl == NULL) {
dapl_dbg_log(DAPL_DBG_TYPE_ERR,
"remove_conn_listener: hca_handle == NULL\n");
return (DAT_INVALID_PARAMETER);
}
srvc_hdl = (struct dapls_ib_cm_srvc_handle *)sp_ptr->
cm_srvc_handle;
args.sdr_sp_hkey = srvc_hdl->sv_sp_hkey;
retval = ioctl(hca_hdl->ia_fd, DAPL_SERVICE_DEREGISTER, &args);
if (retval != 0) {
dapl_dbg_log(DAPL_DBG_TYPE_ERR,
"remove_conn_listener: deregister failed %s\n",
strerror(errno));
return (dapls_convert_error(errno, retval));
}
dapl_os_free(srvc_hdl, sizeof (*srvc_hdl));
sp_ptr->cm_srvc_handle = NULL;
s = (struct sockaddr *)&ia_ptr->hca_ptr->hca_address;
dapl_dbg_log(DAPL_DBG_TYPE_CM,
"remove_conn_listener: successful, ia_address %s, "
"conn_qual %016llu\n\n", dapls_inet_ntop(s, addr_buf, 64),
sp_ptr->conn_qual);
return (DAT_SUCCESS);
}
DAT_RETURN dapl_evd_resize(
IN DAT_EVD_HANDLE evd_handle,
IN DAT_COUNT req_evd_qlen)
{
int i;
DAPL_EVD *evd_ptr;
DAT_EVENT *event_ptr;
DAT_EVENT *eventp;
DAT_EVENT *event;
DAT_EVENT *new_event;
DAPL_RING_BUFFER free_event_queue;
DAPL_RING_BUFFER pending_event_queue;
DAT_RETURN dat_status;
DAT_COUNT max_evd_qlen;
DAT_COUNT evd_qlen;
evd_ptr = (DAPL_EVD *)evd_handle;
dat_status = DAT_SUCCESS;
if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, 0));
}
if (req_evd_qlen < evd_ptr->qlen) {
return (DAT_ERROR(DAT_INVALID_STATE, 0));
}
if (req_evd_qlen == evd_ptr->qlen) {
return (DAT_SUCCESS);
}
max_evd_qlen = evd_ptr->header.owner_ia->hca_ptr->ia_attr.max_evd_qlen;
if (req_evd_qlen > max_evd_qlen) {
return (DAT_ERROR(DAT_INVALID_STATE, 0));
}
evd_qlen = DAPL_MIN_RESZ_QLEN;
while (req_evd_qlen > evd_qlen) {
evd_qlen <<= 1;
if (evd_qlen > max_evd_qlen)
evd_qlen = max_evd_qlen;
}
/* Allocate EVENTs */
event_ptr = (DAT_EVENT *) dapl_os_alloc(evd_qlen * sizeof (DAT_EVENT));
if (!event_ptr) {
return (DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,
DAT_RESOURCE_MEMORY));
}
/* allocate free event queue */
dat_status = dapls_rbuf_alloc(&free_event_queue, evd_qlen);
if (dat_status != DAT_SUCCESS) {
goto bail;
}
/* allocate pending event queue */
dat_status = dapls_rbuf_alloc(&pending_event_queue, evd_qlen);
if (dat_status != DAT_SUCCESS) {
goto bail;
}
/* need to resize the cq only for DTO/BIND evds */
if (0 != (evd_ptr->evd_flags & ~ (DAT_EVD_SOFTWARE_FLAG |
DAT_EVD_CONNECTION_FLAG | DAT_EVD_CR_FLAG))) {
dat_status = dapls_ib_cq_resize(evd_ptr, evd_qlen);
if (dat_status != DAT_SUCCESS)
goto bail;
}
/* add events to free event queue */
for (i = 0, eventp = event_ptr; i < evd_qlen; i++) {
(void) dapls_rbuf_add(&free_event_queue, (void *)eventp);
eventp++;
}
/*
* copy pending events from evd to the new pending event queue
*/
while (event = (DAT_EVENT *)
dapls_rbuf_remove(&evd_ptr->pending_event_queue)) {
new_event = (DAT_EVENT *) dapls_rbuf_remove(&free_event_queue);
dapl_os_assert(new_event);
(void) dapl_os_memcpy(new_event, event, sizeof (DAT_EVENT));
dat_status = dapls_rbuf_add(&pending_event_queue, new_event);
dapl_os_assert(dat_status == DAT_SUCCESS);
dat_status = dapls_rbuf_add(&evd_ptr->free_event_queue, event);
dapl_os_assert(dat_status == DAT_SUCCESS);
}
dapls_rbuf_destroy(&evd_ptr->free_event_queue);
dapls_rbuf_destroy(&evd_ptr->pending_event_queue);
if (evd_ptr->events) {
dapl_os_free(evd_ptr->events,
evd_ptr->qlen * sizeof (DAT_EVENT));
}
evd_ptr->events = event_ptr;
evd_ptr->free_event_queue = free_event_queue;
evd_ptr->pending_event_queue = pending_event_queue;
evd_ptr->qlen = evd_qlen;
return (DAT_SUCCESS);
bail:
/*
* If we are here means event_ptr was allocd but something else
* failed
*/
dapl_os_free(event_ptr, evd_qlen * sizeof (DAT_EVENT));
dapls_rbuf_destroy(&free_event_queue);
dapls_rbuf_destroy(&pending_event_queue);
return (dat_status);
}
/*
* dapls_osd_fork_cleanup
*
* Update val to value of passed in environment variable if present
*
* Input:
* env_str
* val Updated if environment variable exists
*
* Returns:
* TRUE or FALSE
*/
void dapls_osd_fork_cleanup(void)
{
DAPL_PROVIDER_LIST_NODE *cur_node;
DAPL_HCA *hca_ptr;
DAPL_IA *ia_ptr;
DAPL_LMR *lmr_ptr;
DAPL_RMR *rmr_ptr;
DAPL_PZ *pz_ptr;
DAPL_CR *cr_ptr;
DAPL_EP *ep_ptr;
DAPL_EVD *evd_ptr;
DAT_EP_PARAM *param;
DAPL_SP *sp_ptr;
while (NULL != g_dapl_provider_list.head) {
cur_node = g_dapl_provider_list.head;
g_dapl_provider_list.head = cur_node->next;
hca_ptr = (DAPL_HCA *) cur_node->data.extension;
/*
* Walk the list of IA ptrs & clean up. This is purposely
* a destructive list walk, we really don't want to preserve
* any of it.
*/
while (!dapl_llist_is_empty(&hca_ptr->ia_list_head)) {
ia_ptr = (DAPL_IA *)
dapl_llist_peek_head(&hca_ptr->ia_list_head);
/*
* The rest of the cleanup code is similar to dapl_ia_close,
* the big difference is that we don't release IB resources,
* only memory; the underlying IB subsystem doesn't deal
* with fork at all, so leave IB handles alone.
*/
while (!dapl_llist_is_empty(&ia_ptr->rmr_list_head)) {
rmr_ptr = (DAPL_RMR *)
dapl_llist_peek_head(&ia_ptr->
rmr_list_head);
if (rmr_ptr->param.lmr_triplet.
virtual_address != 0) {
dapl_os_atomic_dec(&rmr_ptr->lmr->
lmr_ref_count);
rmr_ptr->param.lmr_triplet.
virtual_address = 0;
}
dapl_os_atomic_dec(&rmr_ptr->pz->pz_ref_count);
dapl_ia_unlink_rmr(rmr_ptr->header.owner_ia,
rmr_ptr);
dapl_rmr_dealloc(rmr_ptr);
}
while (!dapl_llist_is_empty(&ia_ptr->rsp_list_head)) {
sp_ptr = (DAPL_SP *)
dapl_llist_peek_head(&ia_ptr->
rsp_list_head);
dapl_os_atomic_dec(&
((DAPL_EVD *) sp_ptr->
evd_handle)->evd_ref_count);
dapls_ia_unlink_sp(ia_ptr, sp_ptr);
dapls_sp_free_sp(sp_ptr);
}
while (!dapl_llist_is_empty(&ia_ptr->ep_list_head)) {
ep_ptr = (DAPL_EP *)
dapl_llist_peek_head(&ia_ptr->ep_list_head);
param = &ep_ptr->param;
if (param->pz_handle != NULL) {
dapl_os_atomic_dec(&
((DAPL_PZ *) param->
pz_handle)->
pz_ref_count);
}
if (param->recv_evd_handle != NULL) {
dapl_os_atomic_dec(&
((DAPL_EVD *) param->
recv_evd_handle)->
evd_ref_count);
}
if (param->request_evd_handle) {
dapl_os_atomic_dec(&
((DAPL_EVD *) param->
request_evd_handle)->
evd_ref_count);
}
if (param->connect_evd_handle != NULL) {
dapl_os_atomic_dec(&
((DAPL_EVD *) param->
connect_evd_handle)->
evd_ref_count);
}
/* ...and free the resource */
dapl_ia_unlink_ep(ia_ptr, ep_ptr);
dapl_ep_dealloc(ep_ptr);
}
while (!dapl_llist_is_empty(&ia_ptr->lmr_list_head)) {
lmr_ptr = (DAPL_LMR *)
dapl_llist_peek_head(&ia_ptr->
lmr_list_head);
(void)dapls_hash_remove(lmr_ptr->header.
owner_ia->hca_ptr->
lmr_hash_table,
lmr_ptr->param.
lmr_context, NULL);
pz_ptr = (DAPL_PZ *) lmr_ptr->param.pz_handle;
dapl_os_atomic_dec(&pz_ptr->pz_ref_count);
dapl_ia_unlink_lmr(lmr_ptr->header.owner_ia,
lmr_ptr);
dapl_lmr_dealloc(lmr_ptr);
}
while (!dapl_llist_is_empty(&ia_ptr->psp_list_head)) {
sp_ptr = (DAPL_SP *)
dapl_llist_peek_head(&ia_ptr->
psp_list_head);
while (!dapl_llist_is_empty
(&sp_ptr->cr_list_head)) {
cr_ptr = (DAPL_CR *)
dapl_llist_peek_head(&sp_ptr->
cr_list_head);
dapl_sp_remove_cr(sp_ptr, cr_ptr);
dapls_cr_free(cr_ptr);
}
dapls_ia_unlink_sp(ia_ptr, sp_ptr);
dapl_os_atomic_dec(&
((DAPL_EVD *) sp_ptr->
evd_handle)->evd_ref_count);
dapls_sp_free_sp(sp_ptr);
}
while (!dapl_llist_is_empty(&ia_ptr->pz_list_head)) {
pz_ptr = (DAPL_PZ *)
dapl_llist_peek_head(&ia_ptr->pz_list_head);
dapl_ia_unlink_pz(pz_ptr->header.owner_ia,
pz_ptr);
dapl_pz_dealloc(pz_ptr);
}
while (!dapl_llist_is_empty(&ia_ptr->evd_list_head)) {
evd_ptr = (DAPL_EVD *)
dapl_llist_peek_head(&ia_ptr->
evd_list_head);
dapl_ia_unlink_evd(evd_ptr->header.owner_ia,
evd_ptr);
/* reset the cq_handle to avoid having it removed */
evd_ptr->ib_cq_handle = IB_INVALID_HANDLE;
dapls_evd_dealloc(evd_ptr);
}
dapl_hca_unlink_ia(ia_ptr->hca_ptr, ia_ptr);
/* asycn error evd was taken care of above, reset the pointer */
ia_ptr->async_error_evd = NULL;
dapls_ia_free(ia_ptr);
} /* end while ( ia_ptr != NULL ) */
dapl_os_free(cur_node, sizeof(DAPL_PROVIDER_LIST_NODE));
} /* end while (NULL != g_dapl_provider_list.head) */
}
/*
* dapl_hca_free
*
* free an IA INFO struct
*
* Input:
* hca_ptr
*
* Output:
* none
*
* Returns:
* none
*
*/
void dapl_hca_free(DAPL_HCA * hca_ptr)
{
dapl_os_free(hca_ptr->name, dapl_os_strlen(hca_ptr->name) + 1);
dapl_os_free(hca_ptr, sizeof(DAPL_HCA));
}
