/* * 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_ep_free * * DAPL Requirements Version xxx, 6.5.3 * * Destroy an instance of the Endpoint * * Input: * ep_handle * * Output: * none * * Returns: * DAT_SUCCESS * DAT_INVALID_PARAMETER * DAT_INVALID_STATE */ DAT_RETURN dapl_ep_free( IN DAT_EP_HANDLE ep_handle) { DAPL_EP *ep_ptr; DAPL_IA *ia_ptr; DAT_EP_PARAM *param; DAT_RETURN dat_status = DAT_SUCCESS; dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_ep_free (%p)\n", ep_handle); ep_ptr = (DAPL_EP *) ep_handle; param = &ep_ptr->param; /* * Verify parameter & state */ if (DAPL_BAD_HANDLE(ep_ptr, DAPL_MAGIC_EP) && !(ep_ptr->header.magic == DAPL_MAGIC_EP_EXIT && ep_ptr->param.ep_state == DAT_EP_STATE_DISCONNECTED)) { dat_status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP); goto bail; } if (ep_ptr->param.ep_state == DAT_EP_STATE_RESERVED || ep_ptr->param.ep_state == DAT_EP_STATE_PASSIVE_CONNECTION_PENDING || ep_ptr->param.ep_state == DAT_EP_STATE_TENTATIVE_CONNECTION_PENDING) { dapl_dbg_log(DAPL_DBG_TYPE_WARN, "--> dapl_ep_free: invalid state: %x, ep %p\n", ep_ptr->param.ep_state, ep_ptr); dat_status = DAT_ERROR(DAT_INVALID_STATE, dapls_ep_state_subtype(ep_ptr)); goto bail; } ia_ptr = ep_ptr->header.owner_ia; /* * If we are connected, issue a disconnect. If we are in the * disconnect_pending state, disconnect with the ABRUPT flag * set. */ /* * Do verification of parameters and the state change atomically. */ dapl_os_lock(&ep_ptr->header.lock); if (ep_ptr->param.ep_state == DAT_EP_STATE_CONNECTED || ep_ptr->param.ep_state == DAT_EP_STATE_ACTIVE_CONNECTION_PENDING || ep_ptr->param.ep_state == DAT_EP_STATE_COMPLETION_PENDING || ep_ptr->param.ep_state == DAT_EP_STATE_DISCONNECT_PENDING) { /* * Issue the disconnect and return. The DISCONNECT callback * will invoke this routine and finish the job */ ep_ptr->param.ep_state = DAT_EP_STATE_DISCONNECT_PENDING; dapl_os_unlock(&ep_ptr->header.lock); dapl_dbg_log(DAPL_DBG_TYPE_EP, "--> dapl_ep_free: disconnecting EP: %x, ep %p\n", ep_ptr->param.ep_state, ep_ptr); dat_status = dapls_ib_disconnect(ep_ptr, DAT_CLOSE_ABRUPT_FLAG); ep_ptr->param.ep_state = DAT_EP_STATE_DISCONNECT_PENDING; ep_ptr->header.magic = DAPL_MAGIC_EP_EXIT; } else { dapl_os_unlock(&ep_ptr->header.lock); } /* * Release all reference counts and unlink this structure. If we * got here from a callback, don't repeat this step */ if (!(ep_ptr->header.magic == DAPL_MAGIC_EP_EXIT && ep_ptr->param.ep_state == DAT_EP_STATE_DISCONNECTED)) { /* Remove link from the IA */ dapl_ia_unlink_ep(ia_ptr, ep_ptr); } /* * If the EP is disconnected tear everything down. Otherwise, * disconnect the EP but leave the QP and basic EP structure * intact; the callback code will finish the job. */ dapl_os_lock(&ep_ptr->header.lock); if (ep_ptr->param.ep_state == DAT_EP_STATE_DISCONNECTED || ep_ptr->param.ep_state == DAT_EP_STATE_UNCONNECTED) { /* * Update ref counts. Note the user may have used ep_modify * to set handles to NULL. */ if (param->pz_handle != NULL) { dapl_os_atomic_dec(&((DAPL_PZ *) param->pz_handle)->pz_ref_count); param->pz_handle = NULL; } if (param->recv_evd_handle != NULL) { dapl_os_atomic_dec(&((DAPL_EVD *) param->recv_evd_handle)->evd_ref_count); param->recv_evd_handle = NULL; } if (param->request_evd_handle != NULL) { dapl_os_atomic_dec(&((DAPL_EVD *) param->request_evd_handle)->evd_ref_count); param->request_evd_handle = NULL; } if (param->connect_evd_handle != NULL) { dapl_os_atomic_dec(&((DAPL_EVD *) param->connect_evd_handle)->evd_ref_count); param->connect_evd_handle = NULL; } if (param->srq_handle != NULL) { dapl_os_atomic_dec(&((DAPL_SRQ *) param->srq_handle)->srq_ref_count); param->srq_handle = NULL; } dapl_dbg_log(DAPL_DBG_TYPE_EP, "--> dapl_ep_free: Free EP: %x, ep %p\n", ep_ptr->param.ep_state, ep_ptr); /* * Free the QP. If the EP has never been used, * the QP is invalid */ if (ep_ptr->qp_handle != IB_INVALID_HANDLE) { dat_status = dapls_ib_qp_free(ia_ptr, ep_ptr); /* * This should always succeed, but report to the user if * there is a problem */ if (dat_status != DAT_SUCCESS) { goto bail; } ep_ptr->qp_handle = IB_INVALID_HANDLE; } dapl_os_unlock(&ep_ptr->header.lock); /* Free the resource */ dapl_ep_dealloc(ep_ptr); } else { dapl_os_unlock(&ep_ptr->header.lock); } bail: return (dat_status); }