/*
 * 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_modify.c
 *
 * PURPOSE: Endpoint management
 * Description: Interfaces in this file are completely described in
 *              the DAPL 1.0 API, Chapter 6, section 5
 *
 * $Id: dapl_ep_modify.c,v 1.23 2003/07/11 18:42:17 hobie16 Exp $
 */

#include "dapl.h"
#include "dapl_cookie.h"
#include "dapl_ep_util.h"
#include "dapl_adapter_util.h"

/*
 * Internal prototypes
 */

static _INLINE_ DAT_RETURN
dapli_ep_modify_validate_parameters(
        IN DAT_EP_HANDLE ep_handle,
        IN DAT_EP_PARAM_MASK ep_param_mask,
        IN const DAT_EP_PARAM *ep_param,
        OUT DAPL_IA **ia_ptr,
        OUT DAPL_EP **ep_ptr,
        OUT DAT_EP_ATTR *ep_attr_ptr);

/*
 * dapl_ep_modify
 *
 * DAPL Requirements Version xxx, 6.5.6
 *
 * Provide the consumer parameters, including attributes and status of
 * the Endpoint.
 *
 * Input:
 *      ep_handle
 *      ep_args_mask
 *
 * Output:
 *      ep_args
 *
 * Returns:
 *      DAT_SUCCESS
 *      DAT_INVALID_PARAMETER
 *      DAT_INVALID_ATTRIBUTE
 *      DAT_INVALID_STATE
 */
DAT_RETURN
dapl_ep_modify(
        IN DAT_EP_HANDLE ep_handle,
        IN DAT_EP_PARAM_MASK ep_param_mask,
        IN const DAT_EP_PARAM *ep_param)
{
        DAPL_IA *ia;
        DAPL_EP *ep1, *ep2;
        DAT_EP_ATTR ep_attr1, ep_attr2;
        DAPL_EP new_ep, copy_of_old_ep;
        DAPL_EP alloc_ep; /* Holder for resources.  */
        DAPL_PZ *tmp_pz;
        DAPL_EVD *tmp_evd;
        DAT_RETURN dat_status;

/* Flag indicating we've allocated a new one of these.  */
        DAT_BOOLEAN qp_allocated = DAT_FALSE;
        DAT_BOOLEAN rqst_cb_allocated = DAT_FALSE;
        DAT_BOOLEAN recv_cb_allocated = DAT_FALSE;

/* Flag indicating we've used (assigned to QP) a new one of these.  */
        DAT_BOOLEAN qp_used = DAT_FALSE;
        DAT_BOOLEAN rqst_cb_used = DAT_FALSE;
        DAT_BOOLEAN recv_cb_used = DAT_FALSE;

        dat_status = dapli_ep_modify_validate_parameters(ep_handle,
            ep_param_mask, ep_param, &ia, &ep1, &ep_attr1);
        if (DAT_SUCCESS != dat_status) {
                goto bail;
        }

        /*
         * Setup the alloc_ep with the appropriate parameters (primarily
         * for allocating the QP.
         */
        alloc_ep = *ep1;
        alloc_ep.param.ep_attr = ep_attr1;
        if (ep_param_mask & DAT_EP_FIELD_PZ_HANDLE) {
                alloc_ep.param.pz_handle = ep_param->pz_handle;
        }

        if (ep_param_mask & DAT_EP_FIELD_RECV_EVD_HANDLE) {
                alloc_ep.param.recv_evd_handle = ep_param->recv_evd_handle;
        }

        if (ep_param_mask & DAT_EP_FIELD_REQUEST_EVD_HANDLE) {
                alloc_ep.param.request_evd_handle =
                    ep_param->request_evd_handle;
        }

        if (ep_param_mask & DAT_EP_FIELD_CONNECT_EVD_HANDLE) {
                alloc_ep.param.connect_evd_handle =
                    ep_param->connect_evd_handle;
        }

        /*
         * Allocate everything that might be needed.
         * We allocate separately, and into a different "holding"
         * ep, since we a) want the copy of the old ep into the new ep to
         * be atomic with the assignment back (under lock), b) want the
         * assignment of the allocated materials to be after the copy of the
         * old ep into the new ep, and c) don't want the allocation done
         * under lock.
         */
        dat_status = dapls_cb_create(
            &alloc_ep.req_buffer, ep1, DAPL_COOKIE_QUEUE_EP,
            ep_attr1.max_request_dtos);
        if (DAT_SUCCESS != dat_status) {
                goto bail;
        }
        rqst_cb_allocated = DAT_TRUE;

        if (!ep1->srq_attached) {
                dat_status = dapls_cb_create(&alloc_ep.recv_buffer, ep1,
                    DAPL_COOKIE_QUEUE_EP, ep_attr1.max_recv_dtos);
                if (DAT_SUCCESS != dat_status) {
                        goto bail;
                }
                recv_cb_allocated = DAT_TRUE;
        }

        dat_status = dapls_ib_qp_alloc(ia, &alloc_ep, ep1);
        if (dat_status != DAT_SUCCESS) {
                goto bail;
        }
        qp_allocated = DAT_TRUE;

        /*
         * Now we atomically modify the EP, under lock
         * There's a lot of work done here, but there should be no
         * allocation or blocking.
         */
        dapl_os_lock(&ep1->header.lock);

        /*
         * Revalidate parameters; make sure that races haven't
         * changed anything important.
         */
        dat_status = dapli_ep_modify_validate_parameters(ep_handle,
            ep_param_mask, ep_param, &ia, &ep2, &ep_attr2);
        if (DAT_SUCCESS != dat_status) {
                dapl_os_unlock(&ep2->header.lock);
                goto bail;
        }

        /*
         * All of the following should be impossible, if validation
         * occurred.  But they're important to the logic of this routine,
         * so we check.
         */
        dapl_os_assert(ep1 == ep2);
        dapl_os_assert(ep_attr2.max_recv_dtos == ep_attr1.max_recv_dtos);
        dapl_os_assert(ep_attr2.max_request_dtos == ep_attr1.max_request_dtos);

        copy_of_old_ep = *ep2;

        /*
         * Setup new ep.
         */
        new_ep = *ep2;
        new_ep.param.ep_attr = ep_attr2;

        /*
         * We can initialize the PZ and EVD handles from the alloc_ep because
         * the only thing that could have changed since we setup the alloc_ep
         * is stuff changed by dapl_cr_accept, and neither PZ nor EVD is in that
         * list.
         */
        new_ep.param.pz_handle = alloc_ep.param.pz_handle;
        new_ep.param.recv_evd_handle = alloc_ep.param.recv_evd_handle;
        new_ep.param.request_evd_handle = alloc_ep.param.request_evd_handle;
        new_ep.param.connect_evd_handle = alloc_ep.param.connect_evd_handle;

        /* Deal with each of the allocation fields.  */
        if (ep_param_mask & DAT_EP_FIELD_EP_ATTR_MAX_RECV_DTOS &&
            (ep_param->ep_attr.max_recv_dtos !=
            ep2->param.ep_attr.max_recv_dtos)) {
                new_ep.recv_buffer = alloc_ep.recv_buffer;
                recv_cb_used = DAT_TRUE;
        }

        if (ep_param_mask & DAT_EP_FIELD_EP_ATTR_MAX_REQUEST_DTOS &&
            (ep_param->ep_attr.max_request_dtos !=
            ep2->param.ep_attr.max_request_dtos)) {
                new_ep.req_buffer = alloc_ep.req_buffer;
                rqst_cb_used = DAT_TRUE;
        }

        /*
         * We need to change the QP only if there already was a QP
         * (leave things the way you found them!) and one of the
         * following has changed: send/recv EVD, send/recv reqs/IOV max.
         */
        if (DAPL_QP_STATE_UNATTACHED != new_ep.qp_state && (ep_param_mask
            & (DAT_EP_FIELD_EP_ATTR_MAX_REQUEST_IOV |
            DAT_EP_FIELD_EP_ATTR_MAX_RECV_IOV |
            DAT_EP_FIELD_EP_ATTR_MAX_REQUEST_DTOS |
            DAT_EP_FIELD_EP_ATTR_MAX_RECV_DTOS |
            DAT_EP_FIELD_RECV_EVD_HANDLE |
            DAT_EP_FIELD_REQUEST_EVD_HANDLE))) {
                /*
                 * We shouldn't be racing with connection establishment
                 * because the parameter validate routine should protect us,
                 * but it's an important enough point that we assert it.
                 */
                dapl_os_assert((ep2->param.ep_state !=
                    DAT_EP_STATE_PASSIVE_CONNECTION_PENDING) &&
                    (ep2->param.ep_state !=
                    DAT_EP_STATE_ACTIVE_CONNECTION_PENDING));

                new_ep.qp_handle = alloc_ep.qp_handle;
                new_ep.qpn = alloc_ep.qpn;
                qp_used = DAT_TRUE;
        }

        /*
         * The actual assignment, including modifying QP parameters.
         * Modifying QP parameters needs to come first, as if it fails
         * we need to exit.
         */
        if (DAPL_QP_STATE_UNATTACHED != new_ep.qp_state) {
                dat_status = dapls_ib_qp_modify(ia, ep2, &ep_attr2);
                if (dat_status != DAT_SUCCESS) {
                        dapl_os_unlock(& ep2->header.lock);
                        goto bail;
                }
        }
        *ep2 = new_ep;

        dapl_os_unlock(&ep2->header.lock);

        /*
         * Modify reference counts, incrementing new ones
         * and then decrementing old ones (so if they're the same
         * the refcount never drops to zero).
         */
        tmp_pz = (DAPL_PZ *) new_ep.param.pz_handle;
        if (NULL != tmp_pz) {
                dapl_os_atomic_inc(&tmp_pz->pz_ref_count);
        }

        tmp_evd = (DAPL_EVD *) new_ep.param.recv_evd_handle;
        if (NULL != tmp_evd) {
                dapl_os_atomic_inc(&tmp_evd->evd_ref_count);
        }

        tmp_evd = (DAPL_EVD *) new_ep.param.request_evd_handle;
        if (NULL != tmp_evd) {
                dapl_os_atomic_inc(&tmp_evd->evd_ref_count);
                }

        tmp_evd = (DAPL_EVD *) new_ep.param.connect_evd_handle;
        if (NULL != tmp_evd) {
                dapl_os_atomic_inc(&tmp_evd->evd_ref_count);
        }

        /* decreament the old reference counts */
        tmp_pz = (DAPL_PZ *) copy_of_old_ep.param.pz_handle;
        if (NULL != tmp_pz) {
                dapl_os_atomic_dec(&tmp_pz->pz_ref_count);
        }

        tmp_evd = (DAPL_EVD *) copy_of_old_ep.param.recv_evd_handle;
        if (NULL != tmp_evd) {
                dapl_os_atomic_dec(&tmp_evd->evd_ref_count);
        }

        tmp_evd = (DAPL_EVD *) copy_of_old_ep.param.request_evd_handle;
        if (NULL != tmp_evd) {
                dapl_os_atomic_dec(&tmp_evd->evd_ref_count);
        }

        tmp_evd = (DAPL_EVD *) copy_of_old_ep.param.connect_evd_handle;
        if (NULL != tmp_evd) {
                dapl_os_atomic_dec(&tmp_evd->evd_ref_count);
        }

bail:
        if (qp_allocated) {
                DAT_RETURN local_dat_status;
                if (dat_status != DAT_SUCCESS || !qp_used) {
                        local_dat_status = dapls_ib_qp_free(ia, &alloc_ep);
                } else {
                        local_dat_status = dapls_ib_qp_free(ia,
                            &copy_of_old_ep);
                }
                if (local_dat_status != DAT_SUCCESS) {
                        dapl_dbg_log(DAPL_DBG_TYPE_WARN,
                            "ep_modify: Failed to free QP; status %x\n",
                            local_dat_status);
                }
        }

        if (rqst_cb_allocated) {
                if (dat_status != DAT_SUCCESS || !rqst_cb_used) {
                        dapls_cb_free(&alloc_ep.req_buffer);
                } else {
                        dapls_cb_free(&copy_of_old_ep.req_buffer);
                }
        }

        if (recv_cb_allocated) {
                if (dat_status != DAT_SUCCESS || !recv_cb_used) {
                        dapls_cb_free(&alloc_ep.recv_buffer);
                } else {
                        dapls_cb_free(&copy_of_old_ep.recv_buffer);
                }
        }

        return (dat_status);
}


/*
 * dapli_ep_modify_validate_parameters
 *
 * Validate parameters
 *
 * The space for the ep_attr_ptr parameter should be allocated by the
 * consumer. Upon success, this parameter will contain the current ep
 * attribute values with the requested modifications made.
 *
 */

static DAT_RETURN
dapli_ep_modify_validate_parameters(
        IN DAT_EP_HANDLE ep_handle,
        IN DAT_EP_PARAM_MASK ep_param_mask,
        IN const DAT_EP_PARAM *ep_param,
        OUT DAPL_IA **ia_ptr,
        OUT DAPL_EP **ep_ptr,
        OUT DAT_EP_ATTR *ep_attr_ptr)
{
        DAPL_IA *ia;
        DAPL_EP *ep;
        DAT_EP_ATTR ep_attr;
        DAT_EP_ATTR ep_attr_limit;
        DAT_EP_ATTR ep_attr_request;
        DAT_RETURN dat_status;

        *ia_ptr = NULL;
        *ep_ptr = NULL;
        dat_status = DAT_SUCCESS;

        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;
        ia = ep->header.owner_ia;

        /*
         * Verify parameters valid in current EP state
         */
        if (ep_param_mask & (DAT_EP_FIELD_IA_HANDLE |
            DAT_EP_FIELD_EP_STATE |
            DAT_EP_FIELD_LOCAL_IA_ADDRESS_PTR |
            DAT_EP_FIELD_LOCAL_PORT_QUAL |
            DAT_EP_FIELD_REMOTE_IA_ADDRESS_PTR |
            DAT_EP_FIELD_REMOTE_PORT_QUAL |
            DAT_EP_FIELD_SRQ_HANDLE |
            DAT_EP_FIELD_EP_ATTR_SRQ_SOFT_HW)) {
                dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2);
                goto bail;
        }

        /*
         * Can only change the PZ handle if we are UNCONNECTED or
         * TENTATIVE_CONNECTION_PENDING(psp PROVIDER allocated EP)
         */
        if ((ep_param_mask & DAT_EP_FIELD_PZ_HANDLE) &&
            (ep->param.ep_state != DAT_EP_STATE_UNCONNECTED &&
            ep->param.ep_state !=
            DAT_EP_STATE_TENTATIVE_CONNECTION_PENDING)) {
                dat_status = DAT_ERROR(DAT_INVALID_STATE,
                    dapls_ep_state_subtype(ep));
                goto bail;
        }

        if ((ep_param_mask & (DAT_EP_FIELD_RECV_EVD_HANDLE |
            DAT_EP_FIELD_REQUEST_EVD_HANDLE |
            DAT_EP_FIELD_CONNECT_EVD_HANDLE |
            DAT_EP_FIELD_EP_ATTR_SERVICE_TYPE |
            DAT_EP_FIELD_EP_ATTR_MAX_MESSAGE_SIZE |
            DAT_EP_FIELD_EP_ATTR_MAX_RDMA_SIZE |
            DAT_EP_FIELD_EP_ATTR_QOS |
            DAT_EP_FIELD_EP_ATTR_REQUEST_COMPLETION_FLAGS |
            DAT_EP_FIELD_EP_ATTR_RECV_COMPLETION_FLAGS |
            DAT_EP_FIELD_EP_ATTR_MAX_RECV_DTOS |
            DAT_EP_FIELD_EP_ATTR_MAX_REQUEST_DTOS |
            DAT_EP_FIELD_EP_ATTR_MAX_RECV_IOV |
            DAT_EP_FIELD_EP_ATTR_MAX_REQUEST_IOV)) &&
            (ep->param.ep_state != DAT_EP_STATE_UNCONNECTED &&
            ep->param.ep_state != DAT_EP_STATE_RESERVED &&
            ep->param.ep_state !=
            DAT_EP_STATE_TENTATIVE_CONNECTION_PENDING)) {
                dat_status = DAT_ERROR(DAT_INVALID_STATE,
                    dapls_ep_state_subtype(ep));
                goto bail;
        }

        /*
         * Validate handles being modified
         */
        if (ep_param_mask & DAT_EP_FIELD_PZ_HANDLE) {
                if (ep_param->pz_handle != NULL &&
                    DAPL_BAD_HANDLE(ep_param->pz_handle, DAPL_MAGIC_PZ)) {
                        dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
                            DAT_INVALID_ARG3);
                        goto bail;
                }
        }

        if (ep_param_mask & DAT_EP_FIELD_RECV_EVD_HANDLE) {
                if (ep_param->recv_evd_handle != NULL &&
                    (DAPL_BAD_HANDLE(ep_param->recv_evd_handle,
                    DAPL_MAGIC_EVD) ||
                    !((DAPL_EVD *)ep_param->recv_evd_handle)->evd_flags &
                    DAT_EVD_DTO_FLAG)) {
                        dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
                            DAT_INVALID_ARG3);
                        goto bail;
                }
        }

        if (ep_param_mask & DAT_EP_FIELD_REQUEST_EVD_HANDLE) {
                if (ep_param->request_evd_handle != NULL &&
                    DAPL_BAD_HANDLE(ep_param->request_evd_handle,
                    DAPL_MAGIC_EVD)) {
                        dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
                            DAT_INVALID_ARG3);
                        goto bail;
                }
        }

        if (ep_param_mask & DAT_EP_FIELD_CONNECT_EVD_HANDLE) {
                if (ep_param->connect_evd_handle != NULL &&
                    DAPL_BAD_HANDLE(ep_param->connect_evd_handle,
                    DAPL_MAGIC_EVD) &&
                    !(((DAPL_EVD *)ep_param->connect_evd_handle)->evd_flags &
                    DAT_EVD_CONNECTION_FLAG)) {
                        dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
                            DAT_INVALID_ARG3);
                        goto bail;
                }
        }

        /*
         * Validate the attributes against the HCA limits
         */
        ep_attr = ep->param.ep_attr;

        (void) dapl_os_memzero(&ep_attr_limit, sizeof (DAT_EP_ATTR));
        dat_status = dapls_ib_query_hca(ia->hca_ptr, NULL,
            &ep_attr_limit, NULL, NULL);
        if (dat_status != DAT_SUCCESS) {
                goto bail;
        }

        ep_attr_request = ep_param->ep_attr;

        if (ep_param_mask & DAT_EP_FIELD_EP_ATTR_SERVICE_TYPE) {
                if (ep_attr_request.service_type != DAT_SERVICE_TYPE_RC) {
                        dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
                            DAT_INVALID_ARG3);
                        goto bail;
                }
        }

        if (ep_param_mask & DAT_EP_FIELD_EP_ATTR_MAX_MESSAGE_SIZE) {
                if (ep_attr_request.max_mtu_size > ep_attr_limit.max_mtu_size) {
                        dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
                            DAT_INVALID_ARG3);
                        goto bail;
                } else {
                        ep_attr.max_mtu_size = ep_attr_request.max_mtu_size;
                }
        }

        /*
         * Do nothing if the DAT_EP_FIELD_EP_ATTR_MAX_RDMA_SIZE flag is
         * set. Each RDMA transport/provider may or may not have a limit
         * on the size of an RDMA DTO. For InfiniBand, this parameter is
         * validated in the implementation of the dapls_ib_qp_modify()
         * function.
         */
        /* LINTED: E_NOP_IF_STMT */
        if (ep_param_mask & DAT_EP_FIELD_EP_ATTR_QOS) {
                /* Do nothing, not defined in the spec yet */
        }

        if (ep_param_mask & DAT_EP_FIELD_EP_ATTR_RECV_COMPLETION_FLAGS) {
                dat_status = dapl_ep_check_recv_completion_flags(
                    ep_attr_request.recv_completion_flags);
                if (dat_status != DAT_SUCCESS) {
                        goto bail;
                } else {
                        ep_attr.recv_completion_flags =
                            ep_attr_request.recv_completion_flags;
                }
        }

        if (ep_param_mask & DAT_EP_FIELD_EP_ATTR_REQUEST_COMPLETION_FLAGS) {
                dat_status = dapl_ep_check_request_completion_flags(
                    ep_attr_request.request_completion_flags);
                if (dat_status != DAT_SUCCESS) {
                        goto bail;
                } else {
                        ep_attr.request_completion_flags =
                            ep_attr_request.request_completion_flags;
                }
        }

        if (ep_param_mask & DAT_EP_FIELD_EP_ATTR_MAX_RECV_DTOS) {
                if ((ep->param.srq_handle != NULL) ||
                    (ep_attr_request.max_recv_dtos >
                    ep_attr_limit.max_recv_dtos) ||
                    (ep_param->recv_evd_handle  == DAT_HANDLE_NULL &&
                    (ep_attr_request.max_recv_dtos > 0))) {
                        dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
                            DAT_INVALID_ARG3);
                        goto bail;
                } else {
                        ep_attr.max_recv_dtos = ep_attr_request.max_recv_dtos;
                }
        }

        if (ep_param_mask & DAT_EP_FIELD_EP_ATTR_MAX_REQUEST_DTOS) {
                if (ep_attr_request.max_request_dtos >
                    ep_attr_limit.max_request_dtos ||
                    (ep_param->request_evd_handle  == DAT_HANDLE_NULL &&
                    (ep_attr_request.max_request_dtos > 0))) {
                        dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
                            DAT_INVALID_ARG3);
                        goto bail;
                } else {
                        ep_attr.max_request_dtos =
                            ep_attr_request.max_request_dtos;
                }
        }

        if (ep_param_mask & DAT_EP_FIELD_EP_ATTR_MAX_RECV_IOV) {
                if ((ep->param.srq_handle != NULL) ||
                    (ep_attr_request.max_recv_iov >
                    ep_attr_limit.max_recv_iov)) {
                        dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
                            DAT_INVALID_ARG3);
                        goto bail;
                } else {
                        ep_attr.max_recv_iov = ep_attr_request.max_recv_iov;
                }
        }

        if (ep_param_mask & DAT_EP_FIELD_EP_ATTR_MAX_REQUEST_IOV) {
                if (ep_attr_request.max_request_iov >
                    ep_attr_limit.max_request_iov) {
                        dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
                            DAT_INVALID_ARG3);
                        goto bail;
                } else {
                        ep_attr.max_request_iov =
                            ep_attr_request.max_request_iov;
                }
        }

        *ia_ptr = ia;
        *ep_ptr = ep;
        *ep_attr_ptr = ep_attr;

bail:
        return (dat_status);
}