/*
 * 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:
 */