예제 #1
0
/*
 * dapli_hca_cleanup
 *
 * Clean up partially allocated HCA stuff. Strictly to make cleanup
 * simple.
 */
void dapli_hca_cleanup(DAPL_HCA * hca_ptr, DAT_BOOLEAN dec_ref)
{
	dapls_ib_close_hca(hca_ptr);
	hca_ptr->ib_hca_handle = IB_INVALID_HANDLE;
	if (dec_ref == DAT_TRUE) {
		dapl_os_atomic_dec(&hca_ptr->handle_ref_count);
	}
}
예제 #2
0
/*
 * dapl_rmr_free
 *
 * DAPL Requirements Version xxx, 6.6.4.2
 *
 * Destroy an instance of the Remote Memory Region
 *
 * Input:
 * 	rmr_handle
 *
 * Output:
 * 	none
 *
 * Returns:
 * 	DAT_SUCCESS
 * 	DAT_INVALID_PARAMETER
 */
DAT_RETURN
dapl_rmr_free(IN DAT_RMR_HANDLE rmr_handle)
{
	DAPL_RMR *rmr;
	DAT_RETURN dat_status;

	dat_status = DAT_SUCCESS;

	if (DAPL_BAD_HANDLE(rmr_handle, DAPL_MAGIC_RMR)) {
		dat_status = DAT_ERROR(DAT_INVALID_HANDLE,
		    DAT_INVALID_HANDLE_RMR);
		goto bail;
	}

	rmr = (DAPL_RMR *)rmr_handle;

	/*
	 * If the user did not perform an unbind op, release
	 * counts here.
	 */
	if (rmr->param.lmr_triplet.virtual_address != 0) {
		(void) dapl_os_atomic_dec(&rmr->lmr->lmr_ref_count);
		rmr->param.lmr_triplet.virtual_address = 0;
	}

	dat_status = dapls_ib_mw_free(rmr);

	if (dat_status != DAT_SUCCESS) {
		goto bail;
	}

	dapl_os_atomic_dec(&rmr->pz->pz_ref_count);

	dapl_rmr_dealloc(rmr);

bail:
	return (dat_status);
}
예제 #3
0
/*
 * 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;
}
예제 #4
0
파일: dapl_osd.c 프로젝트: Cai900205/test
/*
 * 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) */
}
예제 #5
0
static DAT_RETURN
dapli_rmr_bind_fuse(
    IN  DAPL_RMR		*rmr,
    IN  const DAT_LMR_TRIPLET* 	lmr_triplet,
    IN  DAT_MEM_PRIV_FLAGS 	mem_priv,
    IN  DAPL_EP 		*ep_ptr,
    IN  DAT_RMR_COOKIE 		user_cookie,
    IN  DAT_COMPLETION_FLAGS	completion_flags,
    OUT DAT_RMR_CONTEXT 	*rmr_context)
{
	DAPL_LMR 			*lmr;
	DAPL_COOKIE			*cookie;
	DAT_RETURN 			dat_status;

	dat_status = dapls_hash_search(
	    rmr->header.owner_ia->hca_ptr->lmr_hash_table,
	    lmr_triplet->lmr_context,
	    (DAPL_HASH_DATA *) &lmr);
	if (DAT_SUCCESS != dat_status) {
		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2);
		goto bail;
	}

	/*
	 * if the ep in unconnected return an error. IB requires that the
	 * QP be connected to change a memory window binding since:
	 *
	 * - memory window bind operations are WQEs placed on a QP's
	 *   send queue
	 *
	 * - QP's only process WQEs on the send queue when the QP is in
	 *   the RTS state
	 */
	if (DAT_EP_STATE_CONNECTED != ep_ptr->param.ep_state) {
		dat_status = DAT_ERROR(DAT_INVALID_STATE,
		    dapls_ep_state_subtype(ep_ptr));
		goto bail;
	}

	if (DAT_FALSE == dapl_mr_bounds_check(
	    dapl_mr_get_address(lmr->param.region_desc, lmr->param.mem_type),
	    lmr->param.length,
	    lmr_triplet->virtual_address,
	    lmr_triplet->segment_length)) {
		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
		    DAT_INVALID_ARG2);
		goto bail;
	}

	/* If the LMR, RMR, and EP are not in the same PZ, there is an error */
	if ((ep_ptr->param.pz_handle != lmr->param.pz_handle) ||
	    (ep_ptr->param.pz_handle != rmr->param.pz_handle)) {
		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG4);
		goto bail;
	}

	if (!dapl_rmr_validate_completion_flag(DAT_COMPLETION_SUPPRESS_FLAG,
	    ep_ptr->param.ep_attr.request_completion_flags, completion_flags) ||
	    !dapl_rmr_validate_completion_flag(DAT_COMPLETION_UNSIGNALLED_FLAG,
	    ep_ptr->param.ep_attr.request_completion_flags, completion_flags) ||
	    !dapl_rmr_validate_completion_flag(
	    DAT_COMPLETION_BARRIER_FENCE_FLAG,
	    ep_ptr->param.ep_attr.request_completion_flags, completion_flags)) {
		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG4);
		goto bail;
	}

	dat_status = dapls_rmr_cookie_alloc(&ep_ptr->req_buffer,
	    rmr, user_cookie, &cookie);
	if (DAT_SUCCESS != dat_status) {
		goto bail;
	}

	dat_status = dapls_ib_mw_bind(rmr,
	    lmr_triplet->lmr_context,
	    ep_ptr,
	    cookie,
	    lmr_triplet->virtual_address,
	    lmr_triplet->segment_length,
	    mem_priv,
	    completion_flags);
	if (DAT_SUCCESS != dat_status) {
		dapls_cookie_dealloc(&ep_ptr->req_buffer, cookie);
		goto bail;
	}

	(void) dapl_os_atomic_inc(&lmr->lmr_ref_count);

	/* if the RMR was previously bound */
	if (NULL != rmr->lmr) {
		(void) dapl_os_atomic_dec(&rmr->lmr->lmr_ref_count);
	}

	rmr->param.mem_priv = mem_priv;
	rmr->param.lmr_triplet = *lmr_triplet;
	rmr->ep = ep_ptr;
	rmr->lmr = lmr;

	dapl_os_atomic_inc(&ep_ptr->req_count);

	if (NULL != rmr_context) { *rmr_context = rmr->param.rmr_context; }
bail:
	return (dat_status);
}
예제 #6
0
static DAT_RETURN
dapli_rmr_bind_unfuse(
    IN  DAPL_RMR		*rmr,
    IN  const DAT_LMR_TRIPLET 	*lmr_triplet,
    IN  DAPL_EP 		*ep_ptr,
    IN  DAT_RMR_COOKIE 		user_cookie,
    IN  DAT_COMPLETION_FLAGS 	completion_flags)
{
	DAPL_COOKIE			*cookie;
	DAT_RETURN 			dat_status;

	dat_status = DAT_SUCCESS;
	/*
	 * if the ep in unconnected return an error. IB requires that the
	 * QP be connected to change a memory window binding since:
	 *
	 * - memory window bind operations are WQEs placed on a QP's
	 *   send queue
	 *
	 * - QP's only process WQEs on the send queue when the QP is in
	 *   the RTS state
	 */
	if (DAT_EP_STATE_CONNECTED != ep_ptr->param.ep_state) {
		dat_status = DAT_ERROR(DAT_INVALID_STATE,
		    dapls_ep_state_subtype(ep_ptr));
		goto bail1;
	}

	/* If the RMR and EP are not in the same PZ, there is an error */
	if (ep_ptr->param.pz_handle != rmr->param.pz_handle) {
		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2);
		goto bail1;
	}

	if (!dapl_rmr_validate_completion_flag(DAT_COMPLETION_SUPPRESS_FLAG,
	    ep_ptr->param.ep_attr.request_completion_flags, completion_flags) ||
	    !dapl_rmr_validate_completion_flag(DAT_COMPLETION_UNSIGNALLED_FLAG,
	    ep_ptr->param.ep_attr.request_completion_flags, completion_flags) ||
	    !dapl_rmr_validate_completion_flag(
	    DAT_COMPLETION_BARRIER_FENCE_FLAG,
	    ep_ptr->param.ep_attr.request_completion_flags, completion_flags)) {
		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2);
		goto bail1;
	}

	dat_status = dapls_rmr_cookie_alloc(&ep_ptr->req_buffer, rmr,
	    user_cookie, &cookie);
	if (DAT_SUCCESS != dat_status) {
		goto bail1;
	}


	dat_status = dapls_ib_mw_unbind(rmr, lmr_triplet->lmr_context,
	    ep_ptr, cookie, completion_flags);

	if (DAT_SUCCESS != dat_status) {
		dapls_cookie_dealloc(&ep_ptr->req_buffer, cookie);
		goto bail1;
	}

	/* if the RMR was previously bound */
	if (NULL != rmr->lmr) {
		(void) dapl_os_atomic_dec(&rmr->lmr->lmr_ref_count);
	}

	rmr->param.mem_priv = DAT_MEM_PRIV_NONE_FLAG;
	rmr->param.lmr_triplet.lmr_context = 0;
	rmr->param.lmr_triplet.virtual_address = 0;
	rmr->param.lmr_triplet.segment_length = 0;
	rmr->ep = ep_ptr;
	rmr->lmr = NULL;

	dapl_os_atomic_inc(&ep_ptr->req_count);

bail1:
	return (dat_status);
}
예제 #7
0
/*
 * dapl_psp_create_any
 *
 * uDAPL: User Direct Access Program Library Version 1.1, 6.4.3.3
 *
 * Create a persistent Public Service Point that can receive multiple
 * requests for connections and generate multiple connection request
 * instances that will be delivered to the specified Event Dispatcher
 * in a notification event. Differs from dapl_psp_create() in that
 * the conn_qual is selected by the implementation and returned to
 * the user.
 *
 * Input:
 * 	ia_handle
 * 	evd_handle
 * 	psp_flags
 *
 * Output:
 * 	conn_qual
 * 	psp_handle
 *
 * Returns:
 * 	DAT_SUCCESS
 * 	DAT_INSUFFICIENT_RESOURCES
 * 	DAT_INVALID_HANDLE
 * 	DAT_INVALID_PARAMETER
 * 	DAT_CONN_QUAL_IN_USE
 * 	DAT_MODEL_NOT_SUPPORTED
 */
DAT_RETURN DAT_API
dapl_psp_create_any(IN DAT_IA_HANDLE ia_handle,
		    OUT DAT_CONN_QUAL * conn_qual,
		    IN DAT_EVD_HANDLE evd_handle,
		    IN DAT_PSP_FLAGS psp_flags, OUT DAT_PSP_HANDLE * psp_handle)
{
	DAPL_IA *ia_ptr;
	DAPL_SP *sp_ptr;
	DAPL_EVD *evd_ptr;
	DAT_RETURN dat_status;
	static DAT_CONN_QUAL hint_conn_qual = 1024;	/* seed value */
	DAT_CONN_QUAL lcl_conn_qual;
	DAT_CONN_QUAL limit_conn_qual;

	ia_ptr = (DAPL_IA *) ia_handle;
	dat_status = DAT_SUCCESS;

	if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
		dat_status =
		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
		goto bail;
	}
	if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
		dat_status =
		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_CR);
		goto bail;
	}

	if (psp_handle == NULL) {
		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG5);
		goto bail;
	}
	if (conn_qual == NULL) {
		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2);
		goto bail;
	}

	evd_ptr = (DAPL_EVD *) evd_handle;
	if (!(evd_ptr->evd_flags & DAT_EVD_CR_FLAG)) {
		dat_status =
		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_CR);
		goto bail;
	}

	if (psp_flags != DAT_PSP_CONSUMER_FLAG &&
	    psp_flags != DAT_PSP_PROVIDER_FLAG) {
		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG4);
		goto bail;
	}

	/* Allocate PSP */
	sp_ptr = dapls_sp_alloc(ia_ptr, DAT_TRUE);
	if (sp_ptr == NULL) {
		dat_status =
		    DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY);
		goto bail;
	}

	DAPL_CNTR(ia_ptr, DCNT_IA_PSP_CREATE_ANY);

	/*
	 * Fill out the args for a PSP
	 */
	sp_ptr->evd_handle = evd_handle;
	sp_ptr->psp_flags = psp_flags;
	sp_ptr->ep_handle = NULL;

	/*
	 * Take a reference on the EVD handle
	 */
	dapl_os_atomic_inc(&((DAPL_EVD *) evd_handle)->evd_ref_count);

	/* Link it onto the IA */
	dapl_ia_link_psp(ia_ptr, sp_ptr);

	/* 
	 * Set up a listener for a connection. Connections can arrive
	 * even before this call returns!
	 */
	sp_ptr->state = DAPL_SP_STATE_PSP_LISTENING;
	sp_ptr->listening = DAT_TRUE;

	limit_conn_qual = 0;
	lcl_conn_qual = hint_conn_qual;
	dat_status = ~DAT_SUCCESS;

	while (dat_status != DAT_SUCCESS) {
		dat_status = dapls_ib_setup_conn_listener(ia_ptr,
							  lcl_conn_qual,
							  sp_ptr);

		lcl_conn_qual++;

		if (dat_status == DAT_CONN_QUAL_IN_USE) {
			/*
			 * If we have a big number of tries and we still haven't
			 * found a service_ID we can use, bail out with an error,
			 * something is wrong!
			 */
			if (limit_conn_qual++ > 100000) {
				dat_status = DAT_CONN_QUAL_UNAVAILABLE;
				break;
			}
		}
	}
	hint_conn_qual = lcl_conn_qual;

	if (dat_status != DAT_SUCCESS) {
		/*
		 * Have a problem setting up the connection, something wrong!
		 */
		dapl_os_atomic_dec(&((DAPL_EVD *) evd_handle)->evd_ref_count);
		sp_ptr->evd_handle = NULL;
		dapls_ia_unlink_sp(ia_ptr, sp_ptr);
		dapls_sp_free_sp(sp_ptr);

		dapl_os_printf
		    ("--> dapl_psp_create cannot set up conn listener: %x\n",
		     dat_status);

		goto bail;
	}

	sp_ptr->conn_qual = lcl_conn_qual - 1;

	/*
	 * Return handle to the user
	 */
	*conn_qual = sp_ptr->conn_qual;
	*psp_handle = (DAT_PSP_HANDLE) sp_ptr;

      bail:
	return dat_status;
}
예제 #8
0
/*
 * 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);

}
예제 #9
0
/*
 * dapl_psp_create
 *
 * uDAPL: User Direct Access Program Library Version 1.1, 6.4.1.1
 *
 * Create a persistent Public Service Point that can receive multiple
 * requests for connections and generate multiple connection request
 * instances that will be delivered to the specified Event Dispatcher
 * in a notification event.
 *
 * Input:
 * 	ia_handle
 * 	conn_qual
 * 	evd_handle
 * 	psp_flags
 *
 * Output:
 * 	psp_handle
 *
 * Returns:
 * 	DAT_SUCCESS
 * 	DAT_INSUFFICIENT_RESOURCES
 * 	DAT_INVALID_PARAMETER
 * 	DAT_CONN_QUAL_IN_USE
 * 	DAT_MODEL_NOT_SUPPORTED
 */
DAT_RETURN DAT_API
dapl_psp_create(IN DAT_IA_HANDLE ia_handle,
		IN DAT_CONN_QUAL conn_qual,
		IN DAT_EVD_HANDLE evd_handle,
		IN DAT_PSP_FLAGS psp_flags, OUT DAT_PSP_HANDLE * psp_handle)
{
	DAPL_IA *ia_ptr;
	DAPL_SP *sp_ptr;
	DAPL_EVD *evd_ptr;
	DAT_BOOLEAN sp_found;
	DAT_RETURN dat_status;

	ia_ptr = (DAPL_IA *) ia_handle;
	dat_status = DAT_SUCCESS;

	if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
		dat_status =
		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
		goto bail;
	}
	if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
		dat_status =
		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_CR);
		goto bail;
	}

	if (psp_handle == NULL) {
		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG5);
		goto bail;
	}

	evd_ptr = (DAPL_EVD *) evd_handle;
	if (!(evd_ptr->evd_flags & DAT_EVD_CR_FLAG)) {
		dat_status =
		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_CR);
		goto bail;
	}

	if (psp_flags != DAT_PSP_CONSUMER_FLAG &&
	    psp_flags != DAT_PSP_PROVIDER_FLAG) {
		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG4);
		goto bail;
	}

	DAPL_CNTR(ia_ptr, DCNT_IA_PSP_CREATE);

	/*
	 * See if we have a quiescent listener to use for this PSP, else
	 * create one and set it listening
	 */
	sp_ptr = dapls_ia_sp_search(ia_ptr, conn_qual, DAT_TRUE);
	sp_found = DAT_TRUE;
	if (sp_ptr == NULL) {
		/* Allocate PSP */
		sp_found = DAT_FALSE;
		sp_ptr = dapls_sp_alloc(ia_ptr, DAT_TRUE);
		if (sp_ptr == NULL) {
			dat_status =
			    DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,
				      DAT_RESOURCE_MEMORY);
			goto bail;
		}
	} else if (sp_ptr->listening == DAT_TRUE) {
		dat_status = DAT_ERROR(DAT_CONN_QUAL_IN_USE, 0);
		goto bail;
	}

	/*
	 * Fill out the args for a PSP
	 */
	sp_ptr->conn_qual = conn_qual;
	sp_ptr->evd_handle = evd_handle;
	sp_ptr->psp_flags = psp_flags;
	sp_ptr->ep_handle = NULL;

	/*
	 * Take a reference on the EVD handle
	 */
	dapl_os_atomic_inc(&((DAPL_EVD *) evd_handle)->evd_ref_count);

	/* 
	 * Set up a listener for a connection. Connections can arrive
	 * even before this call returns!
	 */
	sp_ptr->state = DAPL_SP_STATE_PSP_LISTENING;
	sp_ptr->listening = DAT_TRUE;

	/*
	 * If this is a new sp we need to add it to the IA queue, and set up
	 * a conn_listener.
	 */
	if (sp_found == DAT_FALSE) {
		/* Link it onto the IA before enabling it to receive conn
		 * requests
		 */
		dapl_ia_link_psp(ia_ptr, sp_ptr);

		dat_status = dapls_ib_setup_conn_listener(ia_ptr,
							  conn_qual, sp_ptr);

		if (dat_status != DAT_SUCCESS) {
			/*
			 * Have a problem setting up the connection, something
			 * wrong!  Decrements the EVD refcount & release it.
			 */
			dapl_os_atomic_dec(&((DAPL_EVD *) evd_handle)->
					   evd_ref_count);
			sp_ptr->evd_handle = NULL;
			dapls_ia_unlink_sp(ia_ptr, sp_ptr);
			dapls_sp_free_sp(sp_ptr);

			dapl_dbg_log(DAPL_DBG_TYPE_CM,
				     "--> dapl_psp_create setup_conn_listener failed: %x\n",
				     dat_status);

			goto bail;
		}
	}

	/*
	 * Return handle to the user
	 */
	*psp_handle = (DAT_PSP_HANDLE) sp_ptr;

      bail:
	return dat_status;
}
예제 #10
0
/*
 * dapli_open_query_ext
 *
 *
 * Direct link to provider for quick provider query without full IA device open
 *
 * Input:
 *	provider name
 *	ia_attr
 *	provider_attr
 *
 * Output:
 * 	ia_attr
 *	provider_attr
 *
 * Return Values:
 * 	DAT_SUCCESS
 * 	DAT_INSUFFICIENT_RESOURCES
 * 	DAT_INVALID_PARAMETER
 * 	DAT_INVALID_HANDLE
 * 	DAT_PROVIDER_NOT_FOUND	(returned by dat registry if necessary)
 */
DAT_RETURN
dapli_open_query_ext(IN const DAT_NAME_PTR name,
		     OUT DAT_IA_HANDLE * ia_handle_ptr,
		     IN DAT_IA_ATTR_MASK ia_mask,
		     OUT DAT_IA_ATTR * ia_attr,
		     IN DAT_PROVIDER_ATTR_MASK pr_mask,
		     OUT DAT_PROVIDER_ATTR * pr_attr)
{
	DAT_RETURN dat_status = DAT_SUCCESS;
	DAT_PROVIDER *provider;
	DAPL_HCA *hca_ptr = NULL;
	DAT_IA_HANDLE ia_ptr = NULL;

	dapl_log(DAPL_DBG_TYPE_EXTENSION,
		 "dapli_open_query_ext (%s, 0x%llx, %p, 0x%x, %p)\n",
		     name, ia_mask, ia_attr, pr_mask, pr_attr);

	dat_status = dapl_provider_list_search(name, &provider);
	if (DAT_SUCCESS != dat_status) {
		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG1);
		goto bail;
	}

	/* ia_handle_ptr and async_evd_handle_ptr cannot be NULL */
	if ((ia_attr == NULL) && (pr_attr == NULL)) {
		return DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG5);
	}

	/* initialize the caller's OUT param */
	*ia_handle_ptr = DAT_HANDLE_NULL;

	/* get the hca_ptr */
	hca_ptr = (DAPL_HCA *) provider->extension;

	/* log levels could be reset and set between open_query calls  */
	if (dapl_os_get_env_val("DAPL_DBG_TYPE", 0))
		g_dapl_dbg_type =  dapl_os_get_env_val("DAPL_DBG_TYPE", 0);

	/*
	 * Open the HCA if it has not been done before.
	 */
	dapl_os_lock(&hca_ptr->lock);
	if (hca_ptr->ib_hca_handle == IB_INVALID_HANDLE) {
		/* open in query mode */
		dat_status = dapls_ib_open_hca(hca_ptr->name,
					       hca_ptr, DAPL_OPEN_QUERY);
		if (dat_status != DAT_SUCCESS) {
			dapl_dbg_log(DAPL_DBG_TYPE_ERR,
				     "dapls_ib_open_hca failed %x\n",
				     dat_status);
			dapl_os_unlock(&hca_ptr->lock);
			goto bail;
		}
	}
	/* Take a reference on the hca_handle */
	dapl_os_atomic_inc(&hca_ptr->handle_ref_count);
	dapl_os_unlock(&hca_ptr->lock);

	/* Allocate and initialize ia structure */
	ia_ptr = (DAT_IA_HANDLE) dapl_ia_alloc(provider, hca_ptr);
	if (!ia_ptr) {
		dat_status = DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY);
		goto cleanup;
	}

	dat_status = dapl_ia_query(ia_ptr, NULL, ia_mask, ia_attr, pr_mask, pr_attr);
	if (dat_status != DAT_SUCCESS) {
		dapl_dbg_log(DAPL_DBG_TYPE_ERR,
			     "dapls_ib_query_hca failed %x\n", dat_status);
		goto cleanup;
	}

	*ia_handle_ptr = ia_ptr;
	return DAT_SUCCESS;

cleanup:
	/* close device and release HCA reference */
	if (ia_ptr) {
		dapl_ia_close(ia_ptr, DAT_CLOSE_ABRUPT_FLAG);
	} else {
		dapl_os_lock(&hca_ptr->lock);
		dapls_ib_close_hca(hca_ptr);
		hca_ptr->ib_hca_handle = IB_INVALID_HANDLE;
		dapl_os_atomic_dec(&hca_ptr->handle_ref_count);
		dapl_os_unlock(&hca_ptr->lock);
	}
bail:
	return dat_status;
}
예제 #11
0
DAT_RETURN
dapli_post_ext(IN DAT_EP_HANDLE ep_handle,
	       IN DAT_UINT64 cmp_add,
	       IN DAT_UINT64 swap,
	       IN DAT_UINT32 immed_data,
	       IN DAT_COUNT segments,
	       IN DAT_LMR_TRIPLET * local_iov,
	       IN DAT_DTO_COOKIE user_cookie,
	       IN const DAT_RMR_TRIPLET * remote_iov,
	       IN int op_type,
	       IN DAT_COMPLETION_FLAGS flags, IN DAT_IB_ADDR_HANDLE * ah)
{
	DAPL_EP *ep_ptr;
	ib_qp_handle_t qp_ptr;
	DAPL_COOKIE *cookie = NULL;
	DAT_RETURN dat_status = DAT_SUCCESS;

	dapl_dbg_log(DAPL_DBG_TYPE_API,
		     " post_ext_op: ep %p cmp_val %d "
		     "swap_val %d cookie 0x%x, r_iov %p, flags 0x%x, ah %p\n",
		     ep_handle, (unsigned)cmp_add, (unsigned)swap,
		     (unsigned)user_cookie.as_64, remote_iov, flags, ah);

	if (DAPL_BAD_HANDLE(ep_handle, DAPL_MAGIC_EP))
		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));

	ep_ptr = (DAPL_EP *) ep_handle;
	qp_ptr = ep_ptr->qp_handle;

	/*
	 * Synchronization ok since this buffer is only used for send
	 * requests, which aren't allowed to race with each other.
	 */
	dat_status = dapls_dto_cookie_alloc(&ep_ptr->req_buffer,
					    DAPL_DTO_TYPE_EXTENSION,
					    user_cookie, &cookie);
	if (dat_status != DAT_SUCCESS)
		goto bail;

	/*
	 * Take reference before posting to avoid race conditions with
	 * completions
	 */
	dapl_os_atomic_inc(&ep_ptr->req_count);

	/*
	 * Invoke provider specific routine to post DTO
	 */
	dat_status = dapls_ib_post_ext_send(ep_ptr, op_type, cookie, segments,	/* data segments */
					    local_iov, remote_iov, immed_data,	/* immed data */
					    cmp_add,	/* compare or add */
					    swap,	/* swap */
					    flags, ah);

	if (dat_status != DAT_SUCCESS) {
		dapl_os_atomic_dec(&ep_ptr->req_count);
		dapls_cookie_dealloc(&ep_ptr->req_buffer, cookie);
	}

      bail:
	return dat_status;

}