DAT_RETURN
dapl_cr_handoff(
IN DAT_CR_HANDLE cr_handle,
IN DAT_CONN_QUAL cr_handoff) /* handoff */
{
DAPL_CR *cr_ptr;
DAT_RETURN dat_status;
if (DAPL_BAD_HANDLE(cr_handle, DAPL_MAGIC_CR)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CR));
}
cr_ptr = (DAPL_CR *)cr_handle;
dat_status = dapls_ib_handoff_connection(cr_ptr, cr_handoff);
/* Remove the CR from the queue, then free it */
dapl_sp_remove_cr(cr_ptr->sp_ptr, cr_ptr);
dapls_cr_free(cr_ptr);
return (dat_status);
}
/*
* dapli_get_sp_ep
*
* Passive side of a connection is now fully established. Clean
* up resources and obtain the EP pointer associated with a CR in
* the SP
*
* Input:
* ib_cm_handle,
* sp_ptr
* connection_event
*
* Output:
* none
*
* Returns
* ep_ptr
*
*/
DAPL_EP *dapli_get_sp_ep(IN dp_ib_cm_handle_t ib_cm_handle,
IN DAPL_SP * sp_ptr, IN DAT_EVENT_NUMBER dat_event_num)
{
DAPL_CR *cr_ptr;
DAPL_EP *ep_ptr;
/*
* acquire the lock, we may be racing with other threads here
*/
dapl_os_lock(&sp_ptr->header.lock);
/* Verify under lock that the SP is still valid */
if (sp_ptr->header.magic == DAPL_MAGIC_INVALID) {
dapl_os_unlock(&sp_ptr->header.lock);
return NULL;
}
/*
* There are potentially multiple connections in progress. Need to
* go through the list and find the one we are interested
* in. There is no guarantee of order. dapl_sp_search_cr
* leaves the CR on the SP queue.
*/
cr_ptr = dapl_sp_search_cr(sp_ptr, ib_cm_handle);
if (cr_ptr == NULL) {
dapl_os_unlock(&sp_ptr->header.lock);
return NULL;
}
ep_ptr = (DAPL_EP *) cr_ptr->param.local_ep_handle;
/* Quick check to ensure our EP is still valid */
if ((DAPL_BAD_HANDLE(ep_ptr, DAPL_MAGIC_EP))) {
ep_ptr = NULL;
}
/* The CR record is discarded in all except for the CONNECTED case,
* as it will have no further relevance.
*/
if (dat_event_num != DAT_CONNECTION_EVENT_ESTABLISHED) {
/* Remove the CR from the queue */
dapl_sp_remove_cr(sp_ptr, cr_ptr);
if (ep_ptr != NULL) {
ep_ptr->cr_ptr = NULL;
}
/*
* If this SP has been removed from service, free it
* up after the last CR is removed
*/
if (sp_ptr->listening != DAT_TRUE && sp_ptr->cr_list_count == 0
&& sp_ptr->state != DAPL_SP_STATE_FREE
&& sp_ptr->state != DAPL_SP_STATE_RSP_LISTENING) {
dapl_dbg_log(DAPL_DBG_TYPE_CM,
"--> dapli_get_sp_ep! disconnect dump sp: %p \n",
sp_ptr);
/* Decrement the ref count on the EVD */
if (sp_ptr->evd_handle) {
dapl_os_atomic_dec(&
((DAPL_EVD *) sp_ptr->
evd_handle)->evd_ref_count);
sp_ptr->evd_handle = NULL;
}
sp_ptr->state = DAPL_SP_STATE_FREE;
dapl_os_unlock(&sp_ptr->header.lock);
(void)dapls_ib_remove_conn_listener(sp_ptr->header.
owner_ia, sp_ptr);
dapls_ia_unlink_sp((DAPL_IA *) sp_ptr->header.owner_ia,
sp_ptr);
dapls_sp_free_sp(sp_ptr);
dapls_cr_free(cr_ptr);
goto skip_unlock;
}
dapl_os_unlock(&sp_ptr->header.lock);
/* free memory outside of the lock */
dapls_cr_free(cr_ptr);
} else {
dapl_os_unlock(&sp_ptr->header.lock);
}
skip_unlock:
return ep_ptr;
}
/*
* dapli_connection_request
*
* Process a connection request on the Passive side of a connection.
* Create a CR record and link it on to the SP so we can update it
* and free it later. Create an EP if specified by the PSP flags.
*
* Input:
* ib_cm_handle,
* sp_ptr
* event_ptr
* prd_ptr
*
* Output:
* None
*
* Returns
* DAT_INSUFFICIENT_RESOURCES
* DAT_SUCCESS
*
*/
DAT_RETURN
dapli_connection_request(IN dp_ib_cm_handle_t ib_cm_handle,
IN DAPL_SP * sp_ptr,
IN DAPL_PRIVATE * prd_ptr, IN int private_data_size,
IN DAPL_EVD * evd_ptr)
{
DAT_RETURN dat_status;
DAPL_CR *cr_ptr;
DAPL_EP *ep_ptr;
DAPL_IA *ia_ptr;
DAT_SP_HANDLE sp_handle;
cr_ptr = dapls_cr_alloc(sp_ptr->header.owner_ia);
if (cr_ptr == NULL) {
/* Invoking function will call dapls_ib_cm_reject() */
return DAT_INSUFFICIENT_RESOURCES;
}
/*
* Set up the CR
*/
cr_ptr->sp_ptr = sp_ptr; /* maintain sp_ptr in case of reject */
cr_ptr->param.remote_port_qual = 0;
cr_ptr->ib_cm_handle = ib_cm_handle;
#ifdef IBHOSTS_NAMING
/*
* Special case: pull the remote HCA address from the private data
* prefix. This is a spec violation as it introduces a protocol, but
* some implementations may find it necessary for a time.
*/
cr_ptr->remote_ia_address = prd_ptr->hca_address;
#endif /* IBHOSTS_NAMING */
cr_ptr->param.remote_ia_address_ptr =
(DAT_IA_ADDRESS_PTR) & cr_ptr->remote_ia_address;
/*
* Copy the remote address and private data out of the private_data
* payload and put them in a local structure
*/
/* Private data size will be determined by the provider layer */
cr_ptr->param.private_data = cr_ptr->private_data;
cr_ptr->param.private_data_size = private_data_size;
if (cr_ptr->param.private_data_size > 0) {
dapl_os_memcpy(cr_ptr->private_data,
prd_ptr->private_data,
DAPL_MIN(cr_ptr->param.private_data_size,
DAPL_MAX_PRIVATE_DATA_SIZE));
}
/* EP will be NULL unless RSP service point */
ep_ptr = (DAPL_EP *) sp_ptr->ep_handle;
if (sp_ptr->psp_flags == DAT_PSP_PROVIDER_FLAG) {
/*
* Never true for RSP connections
*
* Create an EP for the user. If we can't allocate an
* EP we are out of resources and need to tell the
* requestor that we cant help them.
*/
ia_ptr = sp_ptr->header.owner_ia;
ep_ptr = dapl_ep_alloc(ia_ptr, NULL);
if (ep_ptr == NULL) {
dapls_cr_free(cr_ptr);
/* Invoking function will call dapls_ib_cm_reject() */
return DAT_INSUFFICIENT_RESOURCES;
}
ep_ptr->param.ia_handle = ia_ptr;
ep_ptr->param.local_ia_address_ptr =
(DAT_IA_ADDRESS_PTR) & ia_ptr->hca_ptr->hca_address;
/* Link the EP onto the IA */
dapl_ia_link_ep(ia_ptr, ep_ptr);
}
cr_ptr->param.local_ep_handle = ep_ptr;
if (ep_ptr != NULL) {
/* Assign valid EP fields: RSP and PSP_PROVIDER_FLAG only */
if (sp_ptr->psp_flags == DAT_PSP_PROVIDER_FLAG) {
ep_ptr->param.ep_state =
DAT_EP_STATE_TENTATIVE_CONNECTION_PENDING;
} else {
/* RSP */
dapl_os_assert(sp_ptr->header.handle_type ==
DAT_HANDLE_TYPE_RSP);
ep_ptr->param.ep_state =
DAT_EP_STATE_PASSIVE_CONNECTION_PENDING;
}
dapl_ep_link_cm(ep_ptr, ib_cm_handle);
}
/* link the CR onto the SP so we can pick it up later */
dapl_sp_link_cr(sp_ptr, cr_ptr);
/* Post the event. */
/* assign sp_ptr to union to avoid typecast errors from some compilers */
sp_handle.psp_handle = (DAT_PSP_HANDLE) sp_ptr;
dat_status = dapls_evd_post_cr_arrival_event(evd_ptr,
DAT_CONNECTION_REQUEST_EVENT,
sp_handle,
(DAT_IA_ADDRESS_PTR)
& sp_ptr->header.owner_ia->
hca_ptr->hca_address,
sp_ptr->conn_qual,
(DAT_CR_HANDLE) cr_ptr);
if (dat_status != DAT_SUCCESS) {
(void)dapls_ib_reject_connection(ib_cm_handle,
DAT_CONNECTION_EVENT_BROKEN,
0, NULL);
/* Take the CR off the list, we can't use it */
dapl_os_lock(&sp_ptr->header.lock);
dapl_sp_remove_cr(sp_ptr, cr_ptr);
dapl_os_unlock(&sp_ptr->header.lock);
dapls_cr_free(cr_ptr);
return DAT_INSUFFICIENT_RESOURCES;
}
return DAT_SUCCESS;
}
/*
* 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) */
}
