OpenSolaris_b135/lib/udapl/udapl_tavor/common/dapl_ep_util.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (c) 2002-2003, Network Appliance, Inc. All rights reserved.
*/
/*
* Copyright 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
*
* MODULE: dapl_ep_util.c
*
* PURPOSE: Manage EP Info structure
*
* $Id: dapl_ep_util.c,v 1.36 2003/08/04 16:50:27 sjs2 Exp $
*/
#include "dapl_ep_util.h"
#include "dapl_ring_buffer_util.h"
#include "dapl_cookie.h"
#include "dapl_adapter_util.h"
#include "dapl_evd_util.h"
#include "dapl_ia_util.h"
/*
* Local definitions
*/
/*
* Default number of I/O operations on an end point
*/
#define IB_IO_DEFAULT 16
/*
* Default number of scatter/gather entries available to a single
* post send/recv
*/
#define IB_IOV_DEFAULT 4
/*
* Default number of RDMA operations in progress at a time
*/
#define IB_RDMA_DEFAULT 4
extern void dapli_ep_default_attrs(
IN DAPL_EP *ep_ptr);
/*
* dapl_ep_alloc
*
* alloc and initialize an EP INFO struct
*
* Input:
* IA INFO struct ptr
*
* Output:
* ep_ptr
*
* Returns:
* none
*
*/
DAPL_EP *
dapl_ep_alloc(
IN DAPL_IA *ia_ptr,
IN const DAT_EP_ATTR *ep_attr,
IN DAT_BOOLEAN srq_attached)
{
DAPL_EP *ep_ptr;
/* Allocate EP */
ep_ptr = (DAPL_EP *)dapl_os_alloc(sizeof (DAPL_EP));
if (ep_ptr == NULL) {
goto bail;
}
/* zero the structure */
(void) dapl_os_memzero(ep_ptr, sizeof (DAPL_EP));
/*
* initialize the header
*/
ep_ptr->header.provider = ia_ptr->header.provider;
ep_ptr->header.magic = DAPL_MAGIC_EP;
ep_ptr->header.handle_type = DAT_HANDLE_TYPE_EP;
ep_ptr->header.owner_ia = ia_ptr;
ep_ptr->header.user_context.as_64 = 0;
ep_ptr->header.user_context.as_ptr = NULL;
dapl_llist_init_entry(&ep_ptr->header.ia_list_entry);
dapl_os_lock_init(&ep_ptr->header.lock);
/*
* Initialize the body
*/
(void) dapl_os_memzero(&ep_ptr->param, sizeof (DAT_EP_PARAM));
ep_ptr->param.ep_state = DAT_EP_STATE_UNCONNECTED;
ep_ptr->param.local_ia_address_ptr =
(DAT_IA_ADDRESS_PTR)&ia_ptr->hca_ptr->hca_address;
/* Set the remote address pointer */
ep_ptr->param.remote_ia_address_ptr =
(DAT_IA_ADDRESS_PTR) &ep_ptr->remote_ia_address;
/*
* Set up default parameters if the user passed in a NULL
*/
if (ep_attr == NULL) {
dapli_ep_default_attrs(ep_ptr);
} else {
ep_ptr->param.ep_attr = *ep_attr;
}
/*
* IBM OS API specific fields
*/
ep_ptr->qp_handle = IB_INVALID_HANDLE;
ep_ptr->qpn = 0;
ep_ptr->qp_state = DAPL_QP_STATE_UNATTACHED;
ep_ptr->cm_handle = IB_INVALID_HANDLE;
ep_ptr->req_count = 0;
ep_ptr->recv_count = 0;
ep_ptr->srq_attached = srq_attached;
if (DAT_SUCCESS != dapls_cb_create(&ep_ptr->req_buffer, ep_ptr,
DAPL_COOKIE_QUEUE_EP, ep_ptr->param.ep_attr.max_request_dtos)) {
dapl_ep_dealloc(ep_ptr);
ep_ptr = NULL;
goto bail;
}
if (!srq_attached) {
if (DAT_SUCCESS != dapls_cb_create(&ep_ptr->recv_buffer, ep_ptr,
DAPL_COOKIE_QUEUE_EP,
ep_ptr->param.ep_attr.max_recv_dtos)) {
dapl_ep_dealloc(ep_ptr);
ep_ptr = NULL;
goto bail;
}
}
bail:
return (ep_ptr);
}
/*
* dapl_ep_dealloc
*
* Free the passed in EP structure.
*
* Input:
* entry point pointer
*
* Output:
* none
*
* Returns:
* none
*
*/
void
dapl_ep_dealloc(
IN DAPL_EP *ep_ptr)
{
dapl_os_assert(ep_ptr->header.magic == DAPL_MAGIC_EP ||
ep_ptr->header.magic == DAPL_MAGIC_EP_EXIT);
/* reset magic to prevent reuse */
ep_ptr->header.magic = DAPL_MAGIC_INVALID;
dapls_cb_free(&ep_ptr->req_buffer);
dapls_cb_free(&ep_ptr->recv_buffer);
dapl_os_free(ep_ptr, sizeof (DAPL_EP));
}
/*
* dapl_ep_default_attrs
*
* Set default values in the parameter fields
*
* Input:
* entry point pointer
*
* Output:
* none
*
* Returns:
* none
*
*/
void
dapli_ep_default_attrs(
IN DAPL_EP *ep_ptr)
{
DAT_EP_ATTR *ep_attr;
ep_attr = &ep_ptr->param.ep_attr;
/* Set up defaults */
(void) dapl_os_memzero(ep_attr, sizeof (DAT_EP_ATTR));
/*
* mtu and rdma sizes fixed in IB as per IBTA 1.1, 9.4.3, 9.4.4,
* 9.7.7.
*/
ep_attr->max_mtu_size = 0x80000000;
ep_attr->max_rdma_size = 0x80000000;
ep_attr->qos = DAT_QOS_BEST_EFFORT;
ep_attr->service_type = DAT_SERVICE_TYPE_RC;
ep_attr->max_recv_dtos = IB_IO_DEFAULT;
ep_attr->max_request_dtos = IB_IO_DEFAULT;
ep_attr->max_recv_iov = IB_IOV_DEFAULT;
ep_attr->max_request_iov = IB_IOV_DEFAULT;
ep_attr->max_rdma_read_in = IB_RDMA_DEFAULT;
ep_attr->max_rdma_read_out = IB_RDMA_DEFAULT;
ep_attr->request_completion_flags = DAT_COMPLETION_EVD_THRESHOLD_FLAG;
ep_attr->recv_completion_flags = DAT_COMPLETION_EVD_THRESHOLD_FLAG;
/*
* Unspecified defaults:
* - ep_privileges: No RDMA capabilities
* - num_transport_specific_params: none
* - transport_specific_params: none
* - num_provider_specific_params: 0
* - provider_specific_params: 0
*/
}
DAT_RETURN
dapl_ep_check_recv_completion_flags(
DAT_COMPLETION_FLAGS flags)
{
/*
* InfiniBand will not allow unsignaled/suppressed RECV completions,
* see the 1.0.1 spec section 10.7.3.1, 10.8.6
*/
if ((flags & DAT_COMPLETION_UNSIGNALLED_FLAG) ||
(flags & DAT_COMPLETION_SUPPRESS_FLAG)) {
return (DAT_INVALID_PARAMETER);
}
return (DAT_SUCCESS);
}
/* ARGSUSED */
DAT_RETURN
dapl_ep_check_request_completion_flags(
DAT_COMPLETION_FLAGS flags)
{
return (DAT_SUCCESS);
}
DAT_RETURN
dapl_ep_check_qos(
DAT_QOS qos)
{
if (qos & ~(DAT_QOS_BEST_EFFORT | DAT_QOS_HIGH_THROUGHPUT |
DAT_QOS_LOW_LATENCY | DAT_QOS_ECONOMY | DAT_QOS_PREMIUM)) {
return (DAT_INVALID_PARAMETER);
}
return (DAT_SUCCESS);
}
DAT_RETURN
dapl_ep_post_send_req(
IN DAT_EP_HANDLE ep_handle,
IN DAT_COUNT num_segments,
IN DAT_LMR_TRIPLET *local_iov,
IN DAT_DTO_COOKIE user_cookie,
IN const DAT_RMR_TRIPLET *remote_iov,
IN DAT_COMPLETION_FLAGS completion_flags,
IN DAPL_DTO_TYPE dto_type,
IN ib_send_op_type_t op_type)
{
DAPL_EP *ep;
DAPL_COOKIE *cookie;
DAT_RETURN dat_status;
if (DAPL_BAD_HANDLE(ep_handle, DAPL_MAGIC_EP)) {
dat_status = DAT_ERROR(DAT_INVALID_HANDLE,
DAT_INVALID_HANDLE_EP);
goto bail;
}
ep = (DAPL_EP *)ep_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->req_buffer,
dto_type,
user_cookie,
&cookie);
if (dat_status != DAT_SUCCESS) {
goto bail;
}
/*
* Invoke provider specific routine to post DTO
*/
if (num_segments != 1 ||
completion_flags != DAT_COMPLETION_DEFAULT_FLAG)
dat_status = dapls_ib_post_send(ep,
op_type,
cookie,
num_segments,
local_iov,
remote_iov,
completion_flags);
else
dat_status = dapls_ib_post_send_one(ep,
op_type,
cookie,
local_iov,
remote_iov);
if (dat_status != DAT_SUCCESS) {
dapls_cookie_dealloc(&ep->req_buffer, cookie);
} else {
dapl_os_atomic_inc(&ep->req_count);
}
bail:
return (dat_status);
}
/*
* dapli_ep_timeout
*
* If this routine is invoked before a connection occurs, generate an
* event
*/
void
dapls_ep_timeout(
unsigned long arg)
{
DAPL_EP *ep_ptr;
dapl_dbg_log(DAPL_DBG_TYPE_CM, "--> dapls_ep_timeout! ep %lx\n", arg);
ep_ptr = (DAPL_EP *)arg;
/* reset the EP state */
ep_ptr->param.ep_state = DAT_EP_STATE_DISCONNECTED;
(void) dapls_evd_post_connection_event(
(DAPL_EVD *)ep_ptr->param.connect_evd_handle,
DAT_CONNECTION_EVENT_TIMED_OUT,
(DAT_HANDLE) ep_ptr,
0,
0);
}
/*
* dapls_ep_state_subtype
*
* Return the INVALID_STATE connection subtype associated with an
* INVALID_STATE on an EP. Strictly for error reporting.
*/
DAT_RETURN_SUBTYPE
dapls_ep_state_subtype(
IN DAPL_EP *ep_ptr)
{
DAT_RETURN_SUBTYPE dat_status;
switch (ep_ptr->param.ep_state) {
case DAT_EP_STATE_RESERVED:
{
dat_status = DAT_INVALID_STATE_EP_RESERVED;
break;
}
case DAT_EP_STATE_PASSIVE_CONNECTION_PENDING:
{
dat_status = DAT_INVALID_STATE_EP_PASSCONNPENDING;
break;
}
case DAT_EP_STATE_ACTIVE_CONNECTION_PENDING:
{
dat_status = DAT_INVALID_STATE_EP_ACTCONNPENDING;
break;
}
case DAT_EP_STATE_TENTATIVE_CONNECTION_PENDING:
{
dat_status = DAT_INVALID_STATE_EP_TENTCONNPENDING;
break;
}
case DAT_EP_STATE_CONNECTED:
{
dat_status = DAT_INVALID_STATE_EP_CONNECTED;
break;
}
case DAT_EP_STATE_DISCONNECT_PENDING:
{
dat_status = DAT_INVALID_STATE_EP_DISCPENDING;
break;
}
case DAT_EP_STATE_DISCONNECTED:
{
dat_status = DAT_INVALID_STATE_EP_DISCONNECTED;
break;
}
case DAT_EP_STATE_COMPLETION_PENDING:
{
dat_status = DAT_INVALID_STATE_EP_COMPLPENDING;
break;
}
default:
{
dat_status = 0;
break;
}
}
return (dat_status);
}
/*
* dapl_ep_create_common
*
* Common code used by dapl_ep_create and dapl_ep_create_srq
*
* Input:
* ia_handle
* pz_handle
* recv_evd_handle (recv DTOs)
* request_evd_handle (xmit DTOs)
* connect_evd_handle
* srq_handle
* ep_attrs
*
* Output:
* ep_handle
*
* Returns:
* DAT_SUCCESS
* DAT_INSUFFICIENT_RESOURCES
* DAT_INVALID_PARAMETER
* DAT_INVALID_ATTRIBUTE
* DAT_MODEL_NOT_SUPPORTED
*/
DAT_RETURN
dapl_ep_create_common(
IN DAT_IA_HANDLE ia_handle,
IN DAT_PZ_HANDLE pz_handle,
IN DAT_EVD_HANDLE recv_evd_handle,
IN DAT_EVD_HANDLE request_evd_handle,
IN DAT_EVD_HANDLE connect_evd_handle,
IN DAT_SRQ_HANDLE srq_handle,
IN const DAT_EP_ATTR *ep_attr_arg,
OUT DAT_EP_HANDLE *ep_handle)
{
DAPL_IA *ia_ptr;
DAPL_EP *ep_ptr;
DAT_EP_ATTR ep_attr_limit;
DAPL_EVD *evd_ptr;
DAT_RETURN dat_status;
DAT_BOOLEAN srq_attached;
DAT_EP_ATTR *ep_attr, epa;
if (ep_attr_arg) {
epa = *ep_attr_arg;
ep_attr = &epa;
} else
ep_attr = NULL;
ia_ptr = (DAPL_IA *)ia_handle;
dat_status = DAT_SUCCESS;
/*
* Verify parameters
*/
if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
dat_status = DAT_ERROR(DAT_INVALID_HANDLE,
DAT_INVALID_HANDLE_IA);
goto bail;
}
/*
* Verify non-required parameters.
* N.B. Assumption: any parameter that can be
* modified by dat_ep_modify() is not strictly
* required when the EP is created
*/
if (pz_handle != NULL &&
DAPL_BAD_HANDLE(pz_handle, DAPL_MAGIC_PZ)) {
dat_status = DAT_ERROR(DAT_INVALID_HANDLE,
DAT_INVALID_HANDLE_PZ);
goto bail;
}
/* If connect handle is !NULL verify handle is good */
if (connect_evd_handle != DAT_HANDLE_NULL &&
(DAPL_BAD_HANDLE(connect_evd_handle, DAPL_MAGIC_EVD) ||
!(((DAPL_EVD *)connect_evd_handle)->evd_flags &
DAT_EVD_CONNECTION_FLAG))) {
dat_status = DAT_ERROR(DAT_INVALID_HANDLE,
DAT_INVALID_HANDLE_EVD_CONN);
goto bail;
}
/* If recv_evd is !NULL, verify handle is good and flags are valid */
if ((recv_evd_handle != DAT_HANDLE_NULL) &&
(DAPL_BAD_HANDLE(recv_evd_handle, DAPL_MAGIC_EVD) ||
!(((DAPL_EVD *)recv_evd_handle)->evd_flags & DAT_EVD_DTO_FLAG))) {
dat_status = DAT_ERROR(DAT_INVALID_HANDLE,
DAT_INVALID_HANDLE_EVD_RECV);
goto bail;
}
/* If req_evd is !NULL, verify handle is good and flags are valid */
if ((request_evd_handle != DAT_HANDLE_NULL) &&
(DAPL_BAD_HANDLE(request_evd_handle, DAPL_MAGIC_EVD) ||
!(((DAPL_EVD *)request_evd_handle)->evd_flags &
DAT_EVD_DTO_FLAG))) {
dat_status = DAT_ERROR(DAT_INVALID_HANDLE,
DAT_INVALID_HANDLE_EVD_REQUEST);
goto bail;
}
srq_attached = DAT_FALSE;
/* if srq_handle is not null validate it */
if (srq_handle != DAT_HANDLE_NULL) {
if (DAPL_BAD_HANDLE(srq_handle, DAPL_MAGIC_SRQ)) {
dat_status = DAT_ERROR(DAT_INVALID_HANDLE,
DAT_INVALID_HANDLE_SRQ);
goto bail;
} else if (pz_handle !=
((DAPL_SRQ *)srq_handle)->param.pz_handle) {
dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
DAT_INVALID_ARG2);
goto bail;
}
srq_attached = DAT_TRUE;
}
if (ep_handle == NULL) {
dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
(srq_attached ? DAT_INVALID_ARG8 : DAT_INVALID_ARG7));
goto bail;
}
/* For EPs with SRQ ep_attr is required */
if ((srq_attached && (ep_attr == NULL)) || (uintptr_t)ep_attr & 3) {
dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
(srq_attached ? DAT_INVALID_ARG7 : DAT_INVALID_ARG6));
goto bail;
}
/*
* Qualify EP Attributes are legal and make sense. Note that if one
* or both of the DTO handles are NULL, then the corresponding
* max_*_dtos must 0 as the user will not be able to post dto ops on
* the respective queue.
*/
if (ep_attr != NULL) {
if (ep_attr->service_type != DAT_SERVICE_TYPE_RC ||
(request_evd_handle == DAT_HANDLE_NULL &&
ep_attr->max_request_dtos != 0) ||
(request_evd_handle != DAT_HANDLE_NULL &&
ep_attr->max_request_dtos == 0) ||
ep_attr->max_request_iov == 0 ||
(DAT_SUCCESS != dapl_ep_check_qos(ep_attr->qos)) ||
(DAT_SUCCESS != dapl_ep_check_recv_completion_flags(
ep_attr->recv_completion_flags))) {
dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
(srq_attached ? DAT_INVALID_ARG7 :
DAT_INVALID_ARG6));
goto bail;
}
if (srq_attached) {
if ((ep_attr->max_recv_dtos != DAT_HW_DEFAULT) ||
(ep_attr->srq_soft_hw != DAT_HW_DEFAULT)) {
dat_status = DAT_ERROR(DAT_MODEL_NOT_SUPPORTED,
0);
goto bail;
}
} else {
/* These checks are needed only for EPs without SRQ */
if ((recv_evd_handle == DAT_HANDLE_NULL &&
ep_attr->max_recv_dtos != 0) ||
(recv_evd_handle != DAT_HANDLE_NULL &&
ep_attr->max_recv_dtos == 0) ||
ep_attr->max_recv_iov == 0) {
dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
DAT_INVALID_ARG6);
goto bail;
}
}
}
/* Verify the attributes against the transport */
if (ep_attr != NULL) {
(void) dapl_os_memzero(&ep_attr_limit, sizeof (DAT_EP_ATTR));
dat_status = dapls_ib_query_hca(ia_ptr->hca_ptr,
NULL, &ep_attr_limit, NULL, NULL);
if (dat_status != DAT_SUCCESS) {
goto bail;
}
if (ep_attr->max_mtu_size > ep_attr_limit.max_mtu_size ||
ep_attr->max_rdma_size > ep_attr_limit.max_rdma_size ||
(ep_attr->max_request_dtos >
ep_attr_limit.max_request_dtos) ||
ep_attr->max_request_iov > ep_attr_limit.max_request_iov) {
dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
(srq_attached ? DAT_INVALID_ARG7 :
DAT_INVALID_ARG6));
goto bail;
}
/* if inlining enabled, recompute max_request_iov */
if (ia_ptr->hca_ptr->max_inline_send)
ep_attr->max_request_iov = dapls_ib_max_request_iov(
ep_attr->max_request_iov,
ep_attr->max_request_dtos,
ep_attr_limit.max_request_iov,
ia_ptr->hca_ptr->max_inline_send);
/* Only EPs without SRQ need the following check */
if ((!srq_attached) &&
(ep_attr->max_recv_dtos > ep_attr_limit.max_recv_dtos) ||
(ep_attr->max_recv_iov > ep_attr_limit.max_recv_iov)) {
dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
DAT_INVALID_ARG6);
goto bail;
}
}
/*
* Verify the completion flags for the EVD and the EP
*/
evd_ptr = (DAPL_EVD *)recv_evd_handle;
if (evd_ptr->completion_type == DAPL_EVD_STATE_INIT) {
if (ep_attr != NULL &&
(ep_attr->recv_completion_flags ==
DAT_COMPLETION_DEFAULT_FLAG)) {
evd_ptr->completion_type = DAPL_EVD_STATE_THRESHOLD;
} else {
/*
* Currently we support only thresholds -
* eventually it'll depend on
* ep_attr->recv_completion_flags;
*/
evd_ptr->completion_type = DAPL_EVD_STATE_THRESHOLD;
}
}
evd_ptr = (DAPL_EVD *)request_evd_handle;
if (evd_ptr->completion_type == DAPL_EVD_STATE_INIT) {
if (ep_attr != NULL &&
(ep_attr->recv_completion_flags ==
DAT_COMPLETION_DEFAULT_FLAG)) {
evd_ptr->completion_type = DAPL_EVD_STATE_THRESHOLD;
} else {
/*
* Currently we support only thresholds -
* eventually it'll depend on
* ep_attr->recv_completion_flags;
*/
evd_ptr->completion_type = DAPL_EVD_STATE_THRESHOLD;
}
}
/* Allocate EP */
ep_ptr = dapl_ep_alloc(ia_ptr, ep_attr, srq_attached);
if (ep_ptr == NULL) {
dat_status = DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,
DAT_RESOURCE_MEMORY);
goto bail;
}
/*
* Fill in the EP
*/
ep_ptr->param.ia_handle = ia_handle;
ep_ptr->param.pz_handle = pz_handle;
ep_ptr->param.recv_evd_handle = recv_evd_handle;
ep_ptr->param.request_evd_handle = request_evd_handle;
ep_ptr->param.connect_evd_handle = connect_evd_handle;
ep_ptr->param.srq_handle = srq_handle;
ep_ptr->srq_attached = srq_attached;
/*
* Make sure we handle the NULL DTO EVDs
*/
if (recv_evd_handle == DAT_HANDLE_NULL && ep_attr == NULL) {
ep_ptr->param.ep_attr.max_recv_dtos = 0;
}
if (request_evd_handle == DAT_HANDLE_NULL && ep_attr == NULL) {
ep_ptr->param.ep_attr.max_request_dtos = 0;
}
/*
* If the user has specified a PZ handle we allocate a QP for
* this EP; else we defer until it is assigned via ep_modify().
* As much as possible we try to keep QP creation out of the
* connect path to avoid resource errors in strange places.
*/
if (pz_handle != DAT_HANDLE_NULL) {
/* Take a reference on the PZ handle */
dapl_os_atomic_inc(&((DAPL_PZ *)pz_handle)->pz_ref_count);
/*
* Get a QP from the IB provider
*/
dat_status = dapls_ib_qp_alloc(ia_ptr, ep_ptr, ep_ptr);
if (dat_status != DAT_SUCCESS) {
dapl_os_atomic_dec(&((DAPL_PZ *)pz_handle)->
pz_ref_count);
dapl_ep_dealloc(ep_ptr);
goto bail;
}
} else {
ep_ptr->qp_state = DAPL_QP_STATE_UNATTACHED;
}
/*
* Update ref counts. See the spec where the endpoint marks
* a data object as 'in use'
* pz_handle: dat_pz_free, uDAPL Document, 6.6.1.2
* evd_handles:
*
* N.B. This should really be done by a util routine.
*/
dapl_os_atomic_inc(&((DAPL_EVD *)connect_evd_handle)->evd_ref_count);
/* Optional handles */
if (recv_evd_handle != NULL) {
dapl_os_atomic_inc(&((DAPL_EVD *)recv_evd_handle)->
evd_ref_count);
}
if (request_evd_handle != NULL) {
dapl_os_atomic_inc(&((DAPL_EVD *)request_evd_handle)->
evd_ref_count);
}
if (srq_handle != NULL) {
dapl_os_atomic_inc(&((DAPL_SRQ *)srq_handle)->srq_ref_count);
}
/* Link it onto the IA */
dapl_ia_link_ep(ia_ptr, ep_ptr);
*ep_handle = ep_ptr;
bail:
return (dat_status);
}
/*
* Local variables:
* c-indent-level: 4
* c-basic-offset: 4
* tab-width: 8
* End:
*/