/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*
 *
 * MODULE: dapl_ia_util.c
 *
 * PURPOSE: Manage IA Info structure
 *
 * $Id: dapl_ia_util.c,v 1.29 2003/07/25 19:24:11 sjs2 Exp $
 */

#include "dapl.h"
#include "dapl_hca_util.h"
#include "dapl_ia_util.h"
#include "dapl_evd_util.h"
#include "dapl_adapter_util.h"

/* Internal prototype */
void dapli_ia_release_hca(
        DAPL_HCA                *hca_ptr);


/*
 * dapl_ia_alloc
 *
 * alloc and initialize an IA INFO struct
 *
 * Input:
 *      none
 *
 * Output:
 *      ia_ptr
 *
 * Returns:
 *      none
 *
 */
DAPL_IA *
dapl_ia_alloc(DAT_PROVIDER * provider, DAPL_HCA * hca_ptr)
{
        DAPL_IA * ia_ptr;

        /* Allocate IA */
        ia_ptr = (DAPL_IA *) dapl_os_alloc(sizeof (DAPL_IA));
        if (ia_ptr == NULL) {
                return (NULL);
        }

        /* zero the structure */
        (void) dapl_os_memzero(ia_ptr, sizeof (DAPL_IA));

        /*
         * initialize the header
         */
        ia_ptr->header.provider         = provider;
        ia_ptr->header.magic            = DAPL_MAGIC_IA;
        ia_ptr->header.handle_type      = DAT_HANDLE_TYPE_IA;
        ia_ptr->header.owner_ia         = ia_ptr;
        ia_ptr->header.user_context.as_64 = 0;
        ia_ptr->header.user_context.as_ptr = NULL;
        dapl_llist_init_entry(&ia_ptr->header.ia_list_entry);
        dapl_os_lock_init(&ia_ptr->header.lock);

        /*
         * initialize the body
         */
        ia_ptr->hca_ptr = hca_ptr;
        ia_ptr->async_error_evd = NULL;
        ia_ptr->cleanup_async_error_evd = DAT_FALSE;
        dapl_llist_init_entry(&ia_ptr->hca_ia_list_entry);
        dapl_llist_init_head(&ia_ptr->ep_list_head);
        dapl_llist_init_head(&ia_ptr->lmr_list_head);
        dapl_llist_init_head(&ia_ptr->rmr_list_head);
        dapl_llist_init_head(&ia_ptr->pz_list_head);
        dapl_llist_init_head(&ia_ptr->evd_list_head);
        dapl_llist_init_head(&ia_ptr->cno_list_head);
        dapl_llist_init_head(&ia_ptr->rsp_list_head);
        dapl_llist_init_head(&ia_ptr->psp_list_head);

        /*
         * initialize the flags
         */
        ia_ptr->dapl_flags = 0;

        dapl_hca_link_ia(hca_ptr, ia_ptr);

        return (ia_ptr);
}


/*
 * dapl_ia_abrupt_close
 *
 * Performs an abrupt close of the IA
 *
 * Input:
 *      ia_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      status
 *
 */

DAT_RETURN
dapl_ia_abrupt_close(IN DAPL_IA *ia_ptr)
{
        DAT_RETURN      dat_status;
        DAPL_EP         *ep_ptr, *next_ep_ptr;
        DAPL_LMR        *lmr_ptr, *next_lmr_ptr;
        DAPL_RMR        *rmr_ptr, *next_rmr_ptr;
        DAPL_PZ         *pz_ptr, *next_pz_ptr;
        DAPL_EVD        *evd_ptr, *next_evd_ptr;
        DAPL_CNO        *cno_ptr, *next_cno_ptr;
        DAPL_SP         *sp_ptr, *next_sp_ptr; /* for PSP and RSP queues */
        DAPL_HCA        *hca_ptr;

        dat_status = DAT_SUCCESS;

        /*
         * clear all the data structures associated with the IA.
         * this must be done in order (rmr,rsp) before (ep lmr psp) before
         * (pz evd)
         *
         * Note that in all the following we can leave the loop either
         * when we run out of entries, or when we get back to the head
         * if we end up skipping an entry.
         */

        rmr_ptr = (dapl_llist_is_empty(&ia_ptr->rmr_list_head)
            ? NULL : dapl_llist_peek_head(&ia_ptr->rmr_list_head));
        while (rmr_ptr != NULL) {
                next_rmr_ptr = dapl_llist_next_entry(&ia_ptr->rmr_list_head,
                    &rmr_ptr->header.ia_list_entry);
                dat_status = dapl_rmr_free(rmr_ptr);
                if (dat_status != DAT_SUCCESS) {
                        dapl_dbg_log(DAPL_DBG_TYPE_WARN,
                            "ia_close(ABRUPT): rmr_free(%p) returns %x\n",
                            rmr_ptr,
                            dat_status);
                }
                rmr_ptr = next_rmr_ptr;
        }

        sp_ptr = (dapl_llist_is_empty(&ia_ptr->rsp_list_head)
            ? NULL : dapl_llist_peek_head(&ia_ptr->rsp_list_head));
        while (sp_ptr != NULL) {
                next_sp_ptr = dapl_llist_next_entry(&ia_ptr->rsp_list_head,
                    &sp_ptr->header.ia_list_entry);
                dat_status = dapl_rsp_free(sp_ptr);
                if (dat_status != DAT_SUCCESS) {
                        dapl_dbg_log(DAPL_DBG_TYPE_WARN,
                            "ia_close(ABRUPT): rsp_free(%p) returns %x\n",
                            sp_ptr,
                            dat_status);
                }
                sp_ptr = next_sp_ptr;
        }

        ep_ptr = (dapl_llist_is_empty(&ia_ptr->ep_list_head)
            ? NULL : dapl_llist_peek_head(&ia_ptr->ep_list_head));
        while (ep_ptr != NULL) {
                next_ep_ptr = dapl_llist_next_entry(&ia_ptr->ep_list_head,
                    &ep_ptr->header.ia_list_entry);
                dat_status = dapl_ep_disconnect(ep_ptr, DAT_CLOSE_ABRUPT_FLAG);
                if (dat_status != DAT_SUCCESS) {
                        dapl_dbg_log(DAPL_DBG_TYPE_WARN,
                            "ia_close(ABRUPT): ep_disconnect(%p) returns %x\n",
                            ep_ptr,
                            dat_status);
                }
                dat_status = dapl_ep_free(ep_ptr);
                if (dat_status != DAT_SUCCESS) {
                        dapl_dbg_log(DAPL_DBG_TYPE_WARN,
                            "ia_close(ABRUPT): ep_free(%p) returns %x\n",
                            ep_ptr,
                            dat_status);
                }
                ep_ptr = next_ep_ptr;
        }

        lmr_ptr = (dapl_llist_is_empty(&ia_ptr->lmr_list_head)
            ? NULL : dapl_llist_peek_head(&ia_ptr->lmr_list_head));
        while (lmr_ptr != NULL) {
                next_lmr_ptr = dapl_llist_next_entry(&ia_ptr->lmr_list_head,
                    &lmr_ptr->header.ia_list_entry);
                dat_status = dapl_lmr_free(lmr_ptr);
                if (dat_status != DAT_SUCCESS) {
                        dapl_dbg_log(DAPL_DBG_TYPE_WARN,
                            "ia_close(ABRUPT): lmr_free(%p) returns %x\n",
                            lmr_ptr,
                            dat_status);
                }
                lmr_ptr = next_lmr_ptr;
        }

        sp_ptr = (dapl_llist_is_empty(&ia_ptr->psp_list_head)
            ? NULL : dapl_llist_peek_head(&ia_ptr->psp_list_head));
        while (sp_ptr != NULL) {
                next_sp_ptr = dapl_llist_next_entry(&ia_ptr->psp_list_head,
                    &sp_ptr->header.ia_list_entry);
                dat_status = dapl_psp_free(sp_ptr);
                if (dat_status != DAT_SUCCESS) {
                        dapl_dbg_log(DAPL_DBG_TYPE_WARN,
                            "ia_close(ABRUPT): psp_free(%p) returns %x\n",
                            sp_ptr,
                            dat_status);
                }
                sp_ptr = next_sp_ptr;
        }

        pz_ptr = (dapl_llist_is_empty(&ia_ptr->pz_list_head)
            ? NULL : dapl_llist_peek_head(&ia_ptr->pz_list_head));
        while (pz_ptr != NULL) {
                next_pz_ptr = dapl_llist_next_entry(&ia_ptr->pz_list_head,
                    &pz_ptr->header.ia_list_entry);
                dat_status = dapl_pz_free(pz_ptr);
                if (dat_status != DAT_SUCCESS) {
                        dapl_dbg_log(DAPL_DBG_TYPE_WARN,
                            "ia_close(ABRUPT): pz_free(%p) returns %x\n",
                            pz_ptr,
                            dat_status);
                }
                pz_ptr = next_pz_ptr;
        }

        /*
         * EVDs are tricky; we want to release all except for the async
         * EVD.  That EVD needs to stick around until after we close the
         * HCA, to accept any async events that occur.  So we cycle through
         * the list with dapl_llist_next_entry instead of dapl_llist_is_empty.
         */
        evd_ptr = (dapl_llist_is_empty(&ia_ptr->evd_list_head)
            ? NULL : dapl_llist_peek_head(&ia_ptr->evd_list_head));
        while (evd_ptr != NULL) {
                next_evd_ptr = dapl_llist_next_entry(&ia_ptr->evd_list_head,
                    &evd_ptr->header.ia_list_entry);
                if (evd_ptr == ia_ptr->async_error_evd) {
                                /*
                                 * Don't delete the EVD, but break any CNO
                                 * connections.
                                 */
                                (void) dapl_evd_disable(evd_ptr);
                                (void) dapl_evd_modify_cno(evd_ptr,
                                    DAT_HANDLE_NULL);
                } else {
                        /* it isn't the async EVD; delete it.  */
                        dat_status = dapl_evd_free(evd_ptr);
                        if (dat_status != DAT_SUCCESS) {
                                dapl_dbg_log(DAPL_DBG_TYPE_WARN,
                                    "ia_close(ABRUPT): evd_free(%p) "
                                    "returns %x\n",
                                    evd_ptr,
                                    dat_status);
                        }
                }
                evd_ptr = next_evd_ptr;
        }

        cno_ptr = (dapl_llist_is_empty(&ia_ptr->cno_list_head)
            ? NULL : dapl_llist_peek_head(&ia_ptr->cno_list_head));
        while (cno_ptr != NULL) {
                next_cno_ptr = dapl_llist_next_entry(&ia_ptr->cno_list_head,
                    &cno_ptr->header.ia_list_entry);
                dat_status = dapl_cno_free(cno_ptr);
                if (dat_status != DAT_SUCCESS) {
                        dapl_dbg_log(DAPL_DBG_TYPE_WARN,
                            "ia_close(ABRUPT): cno_free(%p) returns %x\n",
                            cno_ptr,
                            dat_status);
                }
                cno_ptr = next_cno_ptr;
                }

        hca_ptr = ia_ptr->hca_ptr;

        /*
         * Free the async EVD, shutting down callbacks from the HCA.
         */
        if (ia_ptr->async_error_evd &&
            (DAT_TRUE == ia_ptr->cleanup_async_error_evd)) {
                dat_status = dapls_ia_teardown_callbacks(ia_ptr);

                hca_ptr->async_evd = NULL; /* It was our async EVD; nuke it.  */

                dapl_os_atomic_dec(& ia_ptr->async_error_evd->evd_ref_count);
                dat_status = dapl_evd_free(ia_ptr->async_error_evd);

                if (DAT_SUCCESS != dat_status) {
                        dapl_dbg_log(DAPL_DBG_TYPE_WARN,
                            "ia_close(ABRUPT): evd_free(%p) returns %x\n",
                            ia_ptr->async_error_evd,
                            dat_status);
                }

                ia_ptr->async_error_evd = NULL;
        }

        /*
         * Release our reference on the hca_handle. If we are the last
         * one, close it
         */
        dapli_ia_release_hca(hca_ptr);

        dapls_ia_free(ia_ptr);

        return (DAT_SUCCESS);           /* Abrupt close can't fail.  */
}


/*
 * dapl_ia_graceful_close
 *
 * Performs an graceful close of the IA
 *
 * Input:
 *      ia_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      status
 *
 */

DAT_RETURN
dapl_ia_graceful_close(IN DAPL_IA *ia_ptr)
{
        DAT_RETURN              dat_status;
        DAT_RETURN              cur_dat_status;
        DAPL_EVD                *evd_ptr;
        DAPL_LLIST_ENTRY        *entry;
        DAPL_HCA                *hca_ptr;

        dat_status = DAT_SUCCESS;

        if (!dapl_llist_is_empty(&ia_ptr->rmr_list_head) ||
            !dapl_llist_is_empty(&ia_ptr->rsp_list_head) ||
            !dapl_llist_is_empty(&ia_ptr->ep_list_head) ||
            !dapl_llist_is_empty(&ia_ptr->lmr_list_head) ||
            !dapl_llist_is_empty(&ia_ptr->psp_list_head) ||
            !dapl_llist_is_empty(&ia_ptr->pz_list_head)) {
                dat_status = DAT_ERROR(DAT_INVALID_STATE,
                    DAT_INVALID_STATE_IA_IN_USE);
                goto bail;
        }

        /* if the async evd does not need to be cleaned up      */
        /* (ie. it was not created by dapl_ia_open)             */
        /*  then the evd list should be empty                   */
        if (DAT_FALSE == ia_ptr->cleanup_async_error_evd) {
                if (!dapl_llist_is_empty(&ia_ptr->evd_list_head)) {
                        dat_status = DAT_ERROR(DAT_INVALID_STATE,
                            DAT_INVALID_STATE_IA_IN_USE);
                        goto bail;
                }
        } else {
        /* else the async evd should be the only evd in */
        /* the list.                                    */
                evd_ptr = (DAPL_EVD *)
                    dapl_llist_peek_head(&ia_ptr->evd_list_head);

                if (!(evd_ptr->evd_flags & DAT_EVD_ASYNC_FLAG)) {
                        dat_status = DAT_ERROR(DAT_INVALID_STATE,
                            DAT_INVALID_STATE_IA_IN_USE);
                        goto bail;
                }

                entry = ia_ptr->evd_list_head;

                /* if the async evd is not the only element in the list */
                if (entry->blink != entry->flink) {
                        dat_status = DAT_ERROR(DAT_INVALID_STATE,
                            DAT_INVALID_STATE_IA_IN_USE);
                        goto bail;
                }

                /*
                 * If the async evd has a non-unary ref count (i.e. it's in
                 * use by someone besides us.
                 */
                if (evd_ptr->evd_ref_count != 1) {
                        dat_status = DAT_ERROR(DAT_INVALID_STATE,
                            DAT_INVALID_STATE_IA_IN_USE);
                        goto bail;
                }
        }

        /*
         * We've validated the call; now we can start the teardown.
         * Because we're in the IA close routine, we're safe from races with
         * DAPL consumers on this IA (operate/destroy races are disallowed in
         * DAPL).
         */
        hca_ptr = ia_ptr->hca_ptr;

        /* Tear down the async EVD if needed, first shutting down callbacks.  */
        if (ia_ptr->async_error_evd &&
            (DAT_TRUE == ia_ptr->cleanup_async_error_evd)) {
                cur_dat_status = dapls_ia_teardown_callbacks(ia_ptr);
                if (DAT_SUCCESS != cur_dat_status) {
                        dat_status = cur_dat_status;
                }
                hca_ptr->async_evd = NULL;
                dapl_os_atomic_dec(& ia_ptr->async_error_evd->evd_ref_count);
                cur_dat_status = dapl_evd_free(ia_ptr->async_error_evd);
                if (DAT_SUCCESS != cur_dat_status) {
                        dat_status = cur_dat_status;
                }

                ia_ptr->async_error_evd = NULL;
        }

        dapli_ia_release_hca(hca_ptr);

        dapls_ia_free(ia_ptr);

bail:
        return (dat_status);
}

/*
 * Release a reference on the HCA handle. If it is 0, close the
 * handle. Manipulate under lock to prevent races with threads trying to
 * open the HCA.
 */
void
dapli_ia_release_hca(
    DAPL_HCA            *hca_ptr)
{
        dapl_os_lock(&hca_ptr->lock);
        dapl_os_atomic_dec(& hca_ptr->handle_ref_count);
        if (hca_ptr->handle_ref_count == 0) {
                DAT_RETURN dat_status;

                /*
                 * Get rid of the cqd associated with the hca.
                 * Print out instead of status return as this routine
                 * shouldn't fail.
                 */
                dat_status = dapls_ib_cqd_destroy(hca_ptr);
                if (dat_status != DAT_SUCCESS) {
                        dapl_dbg_log(DAPL_DBG_TYPE_ERR,
                            "ERR: Cannot free CQD: err %x\n", dat_status);
                }

                (void) dapls_ib_close_hca(hca_ptr->ib_hca_handle);
                hca_ptr->ib_hca_handle = IB_INVALID_HANDLE;
        }
        dapl_os_unlock(&hca_ptr->lock);
}


/*
 * dapls_ia_free
 *
 * free an IA INFO struct
 *
 * Input:
 *      ia_ptr
 *
 * Output:
 *      one
 *
 * Returns:
 *      none
 *
 */
void
dapls_ia_free(DAPL_IA *ia_ptr)
{
        dapl_os_assert(ia_ptr->header.magic == DAPL_MAGIC_IA);

        dapl_os_assert(ia_ptr->async_error_evd == NULL);
        dapl_os_assert(dapl_llist_is_empty(&ia_ptr->lmr_list_head));
        dapl_os_assert(dapl_llist_is_empty(&ia_ptr->rmr_list_head));
        dapl_os_assert(dapl_llist_is_empty(&ia_ptr->ep_list_head));
        dapl_os_assert(dapl_llist_is_empty(&ia_ptr->evd_list_head));
        dapl_os_assert(dapl_llist_is_empty(&ia_ptr->cno_list_head));
        dapl_os_assert(dapl_llist_is_empty(&ia_ptr->psp_list_head));
        dapl_os_assert(dapl_llist_is_empty(&ia_ptr->rsp_list_head));

        /*
         * deinitialize the header
         */
        dapl_hca_unlink_ia(ia_ptr->hca_ptr, ia_ptr);
        /* reset magic to prevent reuse */
        ia_ptr->header.magic = DAPL_MAGIC_INVALID;
        dapl_os_lock_destroy(&ia_ptr->header.lock);

        dapl_os_free(ia_ptr, sizeof (DAPL_IA));
}

/*
 * dapl_ia_link_ep
 *
 * Add an ep to the IA structure
 *
 * Input:
 *      ia_ptr
 *      ep_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_link_ep(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_EP    *ep_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        dapl_llist_add_head(&ia_ptr->ep_list_head,
            &ep_ptr->header.ia_list_entry,
            ep_ptr);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * dapl_ia_unlink_ep
 *
 * Remove an ep from the ia info structure
 *
 * Input:
 *      ia_ptr
 *      ep_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_unlink_ep(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_EP    *ep_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        (void) dapl_llist_remove_entry(&ia_ptr->ep_list_head,
            &ep_ptr->header.ia_list_entry);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * dapl_ia_link_lmr
 *
 * Add an lmr to the IA structure
 *
 * Input:
 *      ia_ptr
 *      lmr_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_link_lmr(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_LMR   *lmr_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        dapl_llist_add_head(&ia_ptr->lmr_list_head,
            &lmr_ptr->header.ia_list_entry,
            lmr_ptr);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * dapl_ia_unlink_lmr
 *
 * Remove an lmr from the ia info structure
 *
 * Input:
 *      ia_ptr
 *      lmr_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_unlink_lmr(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_LMR   *lmr_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        (void) dapl_llist_remove_entry(&ia_ptr->lmr_list_head,
            &lmr_ptr->header.ia_list_entry);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * dapl_ia_link_rmr
 *
 * Add an rmr to the IA structure
 *
 * Input:
 *      ia_ptr
 *      rmr_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_link_rmr(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_RMR   *rmr_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        dapl_llist_add_head(&ia_ptr->rmr_list_head,
            &rmr_ptr->header.ia_list_entry,
            rmr_ptr);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * dapl_ia_unlink_rmr
 *
 * Remove an rmr from the ia info structure
 *
 * Input:
 *      ia_ptr
 *      rmr_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_unlink_rmr(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_RMR   *rmr_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        (void) dapl_llist_remove_entry(&ia_ptr->rmr_list_head,
            &rmr_ptr->header.ia_list_entry);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * dapl_ia_link_pz
 *
 * Add an pz to the IA structure
 *
 * Input:
 *      ia_ptr
 *      pz_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_link_pz(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_PZ    *pz_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        dapl_llist_add_head(&ia_ptr->pz_list_head,
            &pz_ptr->header.ia_list_entry,
            pz_ptr);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * dapl_ia_unlink_pz
 *
 * Remove an pz from the ia info structure
 *
 * Input:
 *      ia_ptr
 *      pz_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_unlink_pz(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_PZ    *pz_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        (void) dapl_llist_remove_entry(&ia_ptr->pz_list_head,
            &pz_ptr->header.ia_list_entry);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * dapl_ia_link_evd
 *
 * Add an evd to the IA structure
 *
 * Input:
 *      ia_ptr
 *      evd_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_link_evd(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_EVD   *evd_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        dapl_llist_add_head(&ia_ptr->evd_list_head,
            &evd_ptr->header.ia_list_entry,
            evd_ptr);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * dapl_ia_unlink_evd
 *
 * Remove an evd from the ia info structure
 *
 * Input:
 *      ia_ptr
 *      evd_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_unlink_evd(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_EVD   *evd_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        (void) dapl_llist_remove_entry(&ia_ptr->evd_list_head,
            &evd_ptr->header.ia_list_entry);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * dapl_ia_link_cno
 *
 * Add an cno to the IA structure
 *
 * Input:
 *      ia_ptr
 *      cno_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_link_cno(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_CNO   *cno_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        dapl_llist_add_head(&ia_ptr->cno_list_head,
            &cno_ptr->header.ia_list_entry,
            cno_ptr);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * dapl_ia_unlink_cno
 *
 * Remove an cno from the ia info structure
 *
 * Input:
 *      ia_ptr
 *      cno_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_unlink_cno(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_CNO   *cno_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        (void) dapl_llist_remove_entry(&ia_ptr->cno_list_head,
            &cno_ptr->header.ia_list_entry);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * dapl_ia_link_psp
 *
 * Add an psp to the IA structure
 *
 * Input:
 *      ia_ptr
 *      sp_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_link_psp(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_SP    *sp_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        dapl_llist_add_head(&ia_ptr->psp_list_head,
            &sp_ptr->header.ia_list_entry,
            sp_ptr);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * daps_ia_unlink_sp
 *
 * Remove an sp from the appropriate ia rsp or psp queue
 *
 * Input:
 *      ia_ptr
 *      sp_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapls_ia_unlink_sp(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_SP    *sp_ptr)
{
        DAPL_LLIST_HEAD *list_head;

        if (sp_ptr->header.handle_type == DAT_HANDLE_TYPE_PSP) {
                list_head = &ia_ptr->psp_list_head;
        } else {
                dapl_os_assert(sp_ptr->header.handle_type ==
                    DAT_HANDLE_TYPE_RSP);
                list_head = &ia_ptr->rsp_list_head;
        }

        dapl_os_lock(&ia_ptr->header.lock);
        (void) dapl_llist_remove_entry(list_head,
            &sp_ptr->header.ia_list_entry);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * dapls_ia_sp_search
 *
 * Find an RSP or PSP on the IA list with a matching conn_qual value
 *
 * Input:
 *      ia_ptr
 *      sp_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
DAPL_SP *
dapls_ia_sp_search(
        IN      DAPL_IA            *ia_ptr,
        IN      DAT_CONN_QUAL      conn_qual,
        IN      DAT_BOOLEAN        is_psp)
{
        DAPL_SP         *sp_ptr;
        DAPL_LLIST_HEAD *list_head;

        if (is_psp) {
                list_head = &ia_ptr->psp_list_head;
        } else {
                list_head = &ia_ptr->rsp_list_head;
        }

        dapl_os_lock(&ia_ptr->header.lock);

        sp_ptr = (dapl_llist_is_empty(list_head) ? NULL :
            dapl_llist_peek_head(list_head));

        while (sp_ptr != NULL) {
                if (sp_ptr->conn_qual == conn_qual) {
                        break;
                }
                sp_ptr = dapl_llist_next_entry(list_head,
                    &sp_ptr->header.ia_list_entry);
        }

        dapl_os_unlock(&ia_ptr->header.lock);

        return (sp_ptr);
}


/*
 * dapl_ia_link_rsp
 *
 * Add an rsp to the IA structure
 *
 * Input:
 *      ia_ptr
 *      sp_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_link_rsp(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_SP    *sp_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        dapl_llist_add_head(&ia_ptr->rsp_list_head,
            &sp_ptr->header.ia_list_entry,
            sp_ptr);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * dapl_ia_link_srq
 *
 * Add an srq to the IA structure
 *
 * Input:
 *      ia_ptr
 *      srq_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_link_srq(
        IN      DAPL_IA         *ia_ptr,
        IN      DAPL_SRQ        *srq_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        dapl_llist_add_head(&ia_ptr->srq_list_head,
            &srq_ptr->header.ia_list_entry,
            srq_ptr);
        dapl_os_unlock(&ia_ptr->header.lock);
}

/*
 * dapl_ia_unlink_srq
 *
 * Remove an srq from the ia info structure
 *
 * Input:
 *      ia_ptr
 *      srq_ptr
 *
 * Output:
 *      none
 *
 * Returns:
 *      none
 *
 */
void
dapl_ia_unlink_srq(
        IN      DAPL_IA    *ia_ptr,
        IN      DAPL_SRQ           *srq_ptr)
{
        dapl_os_lock(&ia_ptr->header.lock);
        (void) dapl_llist_remove_entry(&ia_ptr->srq_list_head,
            &srq_ptr->header.ia_list_entry);
        dapl_os_unlock(&ia_ptr->header.lock);
}

DAT_RETURN
dapls_ia_setup_callbacks(
    IN  DAPL_IA         *ia_ptr,
    IN  DAPL_EVD        *async_evd_ptr)
{
        DAT_RETURN dat_status = DAT_SUCCESS;

#if 0
        /*
         * Current implementation of dapls_ib_setup_async_callback() does
         * nothing and returns DAT_SUCCESS. However, it is declared to expect
         * function pointers with different signatures. We do leave the code
         * block out till dapls_ib_setup_async_callback() is implemented.
         */
        /* unaffiliated handler */
        dat_status =
            dapls_ib_setup_async_callback(
            ia_ptr,
            DAPL_ASYNC_UNAFILIATED,
            NULL,
            (ib_async_handler_t)dapl_evd_un_async_error_callback,
            async_evd_ptr);

        if (dat_status != DAT_SUCCESS) {
                dapl_dbg_log(DAPL_DBG_TYPE_ERR,
                    "ib_set_un_async_error_eh failed %d\n",
                    dat_status);
                goto bail;
        }

        /* affiliated cq handler */
        dat_status = dapls_ib_setup_async_callback(
            ia_ptr,
            DAPL_ASYNC_CQ_ERROR,
            NULL,
            (ib_async_handler_t)dapl_evd_cq_async_error_callback,
            async_evd_ptr);

        if (dat_status != DAT_SUCCESS) {
                dapl_dbg_log(DAPL_DBG_TYPE_ERR,
                    "ib_set_cq_async_error_eh failed %d\n",
                    dat_status);
                goto bail;
        }

        /* affiliated qp handler */
        dat_status = dapls_ib_setup_async_callback(
            ia_ptr,
            DAPL_ASYNC_QP_ERROR,
            NULL,
            (ib_async_handler_t)dapl_evd_qp_async_error_callback,
            ia_ptr);
        if (dat_status != DAT_SUCCESS) {
                dapl_dbg_log(DAPL_DBG_TYPE_ERR,
                    "ib_set_qp_async_error_eh failed %d\n",
                    dat_status);
                goto bail;
        }
bail:
#endif
        return (dat_status);
}

DAT_RETURN
dapls_ia_teardown_callbacks(
    IN  DAPL_IA         *ia_ptr)
{
        DAT_RETURN dat_status = DAT_SUCCESS;

        /* unaffiliated handler */
        dat_status =
            dapls_ib_setup_async_callback(
            ia_ptr,
            DAPL_ASYNC_UNAFILIATED,
            NULL,
            (ib_async_handler_t)0,
            NULL);

        if (dat_status != DAT_SUCCESS) {
                dapl_dbg_log(DAPL_DBG_TYPE_ERR,
                    "ib_set_un_async_error_eh failed %d\n",
                    dat_status);
                goto bail;
        }

        /* affiliated cq handler */
        dat_status = dapls_ib_setup_async_callback(
            ia_ptr,
            DAPL_ASYNC_CQ_ERROR,
            NULL,
            (ib_async_handler_t)0,
            NULL);

        if (dat_status != DAT_SUCCESS) {
                dapl_dbg_log(DAPL_DBG_TYPE_ERR,
                    "ib_set_cq_async_error_eh failed %d\n",
                    dat_status);
                goto bail;
        }

        /* affiliated qp handler */
        dat_status = dapls_ib_setup_async_callback(
            ia_ptr,
            DAPL_ASYNC_QP_ERROR,
            NULL,
            (ib_async_handler_t)0,
            NULL);
        if (dat_status != DAT_SUCCESS) {
                dapl_dbg_log(DAPL_DBG_TYPE_ERR,
                    "ib_set_qp_async_error_eh failed %d\n",
                    dat_status);
                goto bail;
        }

bail:
        return (dat_status);
}