/*
 * 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) 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <sys/types.h>
#include <sys/kmem.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/ksynch.h>

#include <sys/ib/clients/eoib/enx_impl.h>

/*
 * Acquire an SWQE
 */

/*ARGSUSED*/
eibnx_wqe_t *
eibnx_acquire_swqe(eibnx_thr_info_t *info, int flag)
{
        eibnx_wqe_t *wqe = NULL;
        eibnx_tx_t *snd_p = &info->ti_snd;
        int i;

        for (i = 0; i < ENX_NUM_SWQE; i++) {
                wqe = &(snd_p->tx_wqe[i]);

                mutex_enter(&wqe->qe_lock);
                if ((wqe->qe_flags & ENX_QEFL_INUSE) == 0) {
                        wqe->qe_flags |= ENX_QEFL_INUSE;
                        mutex_exit(&wqe->qe_lock);
                        break;
                }
                mutex_exit(&wqe->qe_lock);
        }

        /*
         * We probably have enough swqe entries for doing our solicitations.
         * If we find it not enough in practice, we need to implement some
         * sort of dynamic allocation.
         */
        if (i == ENX_NUM_SWQE)
                wqe = NULL;

        return (wqe);
}

/*
 * Return a SWQE from completion. We may have to release
 * it or keep it.
 */
void
eibnx_return_swqe(eibnx_wqe_t *wqe)
{
        ASSERT(wqe->qe_type == ENX_QETYP_SWQE);

        mutex_enter(&wqe->qe_lock);

        /*
         * This send wqe is from the completion queue.  We need to
         * clear the 'posted' flag first.
         */
        ASSERT((wqe->qe_flags & ENX_QEFL_POSTED) == ENX_QEFL_POSTED);
        wqe->qe_flags &= (~ENX_QEFL_POSTED);

        /*
         * See if we need to release this send wqe back to the pool
         * on completion. We may not need to do so if, for example,
         * this were a swqe acquired specifically for a particular gw.
         */
        if (wqe->qe_flags & ENX_QEFL_RELONCOMP) {
                wqe->qe_sgl.ds_len = wqe->qe_bufsz;
                wqe->qe_flags &= (~ENX_QEFL_INUSE);

                wqe->qe_flags &= (~ENX_QEFL_RELONCOMP);
        }

        mutex_exit(&wqe->qe_lock);
}

/*
 * Return a RWQE from completion. We probably have to repost it.
 */
void
eibnx_return_rwqe(eibnx_thr_info_t *info, eibnx_wqe_t *wqe)
{
        ibt_status_t ret;

        ASSERT(wqe->qe_type == ENX_QETYP_RWQE);

        mutex_enter(&wqe->qe_lock);

        /*
         * We should never need to free an rwqe on completion.
         */
        ASSERT((wqe->qe_flags & ENX_QEFL_RELONCOMP) == 0);

        /*
         * An rwqe is always in-use and posted, so we only need to make
         * sure the ds_len is adjusted back to the value it's supposed
         * to have.
         */
        wqe->qe_sgl.ds_len = wqe->qe_bufsz;

        /*
         * Repost the recv wqe
         */
        ret = ibt_post_recv(info->ti_chan, &(wqe->qe_wr.recv), 1, NULL);
        if (ret != IBT_SUCCESS) {
                ENX_DPRINTF_WARN("ibt_post_recv(chan_hdl=0x%llx) failed, "
                    "ret=%d", info->ti_chan, ret);
        }

        mutex_exit(&wqe->qe_lock);
}

/*
 * Release an SWQE that was acquired earlier.
 */
void
eibnx_release_swqe(eibnx_wqe_t *wqe)
{
        ASSERT(wqe->qe_type == ENX_QETYP_SWQE);

        mutex_enter(&wqe->qe_lock);

        /*
         * Make sure this swqe is in use. Since this routine may also be
         * called when we're trying to cleanup the eoib nodes, we
         * should clear all flag bits.
         */
        ASSERT((wqe->qe_flags & ENX_QEFL_INUSE) == ENX_QEFL_INUSE);
        wqe->qe_flags = 0;

        mutex_exit(&wqe->qe_lock);
}

/*
 * Insert the passed child to the head of the queue
 */
void
eibnx_enqueue_child(eibnx_thr_info_t *info, eibnx_gw_info_t *gwi,
    char *node_name, dev_info_t *dip)
{
        eibnx_child_t *ch;
        eibnx_child_t *new_ch;

        new_ch = kmem_zalloc(sizeof (eibnx_child_t), KM_SLEEP);
        new_ch->ch_dip = dip;
        new_ch->ch_node_name = node_name;
        new_ch->ch_gwi = gwi;

        mutex_enter(&info->ti_child_lock);

        /*
         * Search existing children to see if we already have this
         * child.  If so, simply update its dip and node_name
         */
        for (ch = info->ti_child; ch; ch = ch->ch_next) {
                if (ch->ch_gwi->gw_portid == gwi->gw_portid) {
                        ch->ch_dip = dip;
                        if (ch->ch_node_name) {
                                kmem_free(ch->ch_node_name, MAXNAMELEN);
                        }
                        ch->ch_node_name = node_name;
                        kmem_free(new_ch, sizeof (eibnx_child_t));
                        return;
                }
        }

        /*
         * If not, add the new child to the list of children
         */
        new_ch->ch_next = info->ti_child;
        info->ti_child = new_ch;

        mutex_exit(&info->ti_child_lock);
}

int
eibnx_update_child(eibnx_thr_info_t *info, eibnx_gw_info_t *gwi,
    dev_info_t *dip)
{
        eibnx_child_t *ch;

        mutex_enter(&info->ti_child_lock);
        for (ch = info->ti_child; ch; ch = ch->ch_next) {
                if (ch->ch_gwi->gw_portid == gwi->gw_portid) {
                        if (ch->ch_dip != dip) {
                                ENX_DPRINTF_DEBUG("updating child dip for "
                                    "gw portid 0x%x to 0x%llx",
                                    gwi->gw_portid, dip);
                                ch->ch_dip = dip;
                        }
                        mutex_exit(&info->ti_child_lock);

                        return (ENX_E_SUCCESS);
                }
        }
        mutex_exit(&info->ti_child_lock);

        return (ENX_E_FAILURE);
}

dev_info_t *
eibnx_find_child_dip_by_inst(eibnx_thr_info_t *info, int inst)
{
        eibnx_child_t *ch;
        dev_info_t *dip = NULL;

        mutex_enter(&info->ti_child_lock);
        for (ch = info->ti_child; ch != NULL; ch = ch->ch_next) {
                dip = ch->ch_dip;
                if (ddi_get_instance(dip) == inst)
                        break;
        }
        mutex_exit(&info->ti_child_lock);

        return (dip);
}

dev_info_t *
eibnx_find_child_dip_by_gw(eibnx_thr_info_t *info, uint16_t gw_portid)
{
        eibnx_child_t *ch;
        dev_info_t *dip = NULL;

        mutex_enter(&info->ti_child_lock);
        for (ch = info->ti_child; ch != NULL; ch = ch->ch_next) {
                dip = ch->ch_dip;
                if (ch->ch_gwi->gw_portid == gw_portid)
                        break;
        }
        mutex_exit(&info->ti_child_lock);

        return (dip);
}

/*
 * See if the passed gateway is already found in our list.  Note
 * that we assume that the gateway port id uniquely identifies each
 * gateway.
 */
eibnx_gw_info_t *
eibnx_find_gw_in_gwlist(eibnx_thr_info_t *info, eibnx_gw_info_t *gwi)
{
        eibnx_gw_info_t *lgw = NULL;

        mutex_enter(&info->ti_gw_lock);
        for (lgw = info->ti_gw; lgw; lgw = lgw->gw_next) {
                if (lgw->gw_portid == gwi->gw_portid)
                        break;
        }
        mutex_exit(&info->ti_gw_lock);

        return (lgw);
}

/*
 * Add a newly discovered gateway to the gateway list.  Since we'll
 * need to send unicast solicitations to this gateway soon, we'll
 * also grab a swqe entry, and initialize basic gw adress parameters
 * such as the gid, qpn, qkey and pkey of the GW.  When we eventually
 * get to sending the unicast to this gateway for the first time,
 * we'll discover the path to this gateway using these parameters
 * and modify the ud destination handle appropriately.
 */
eibnx_gw_info_t *
eibnx_add_gw_to_gwlist(eibnx_thr_info_t *info, eibnx_gw_info_t *gwi,
    ibt_wc_t *wc, uint8_t *recv_buf)
{
        eibnx_gw_info_t *new_gwi;
        eibnx_wqe_t *wqe;
        ib_grh_t *grh;
        ib_gid_t sgid;
        clock_t timeout_usecs;

        /*
         * For now, we'll simply do KM_NOSLEEP allocation, since this code
         * is called from within rx processing
         */
        new_gwi = kmem_zalloc(sizeof (eibnx_gw_info_t), KM_NOSLEEP);
        if (new_gwi == NULL) {
                ENX_DPRINTF_WARN("no memory, gw port_id 0x%x "
                    "will be ignored by hca_guid=0x%llx, port=0x%x",
                    gwi->gw_portid, info->ti_hca_guid,
                    info->ti_pi->p_port_num);
                return (NULL);
        }

        /*
         * We also need to acquire a send wqe to do unicast solicitations
         * to this gateway later on. We should've enough pre-allocated swqes
         * to do this without sleeping.
         */
        if ((wqe = eibnx_acquire_swqe(info, KM_NOSLEEP)) == NULL) {
                ENX_DPRINTF_WARN("no swqe available, gw port_id 0x%x "
                    "will be ignored by hca_guid=0x%llx, port=0x%x",
                    gwi->gw_portid, info->ti_hca_guid,
                    info->ti_pi->p_port_num);
                kmem_free(new_gwi, sizeof (eibnx_gw_info_t));
                return (NULL);
        }

        /*
         * Initialize gw state and wqe information.
         */
        new_gwi->gw_next = NULL;
        new_gwi->gw_swqe = wqe;
        new_gwi->gw_state = gwi->gw_state;

        /*
         * Set up gateway advertisement monitoring parameters. Since we
         * always need to check against a timeout value of 2.5 * gw_adv_period,
         * we'll keep this pre-calculated value as well.
         */
        mutex_init(&new_gwi->gw_adv_lock, NULL, MUTEX_DRIVER, NULL);
        new_gwi->gw_adv_flag = gwi->gw_adv_flag;
        new_gwi->gw_adv_last_lbolt = ddi_get_lbolt64();
        timeout_usecs = gwi->gw_adv_period * 1000;
        timeout_usecs = ((timeout_usecs << 2) + timeout_usecs) >> 1;
        new_gwi->gw_adv_timeout_ticks = drv_usectohz(timeout_usecs);

        /*
         * Initialize gateway address information. Note that if the message has
         * a GRH, we'll use the subnet prefix, otherwise we'll assume that the
         * gateway is in the same subnet as ourselves.
         */
        new_gwi->gw_addr.ga_vect = NULL;
        if (wc->wc_flags & IBT_WC_GRH_PRESENT) {
                grh = (ib_grh_t *)(uintptr_t)recv_buf;
                new_gwi->gw_addr.ga_gid.gid_prefix =
                    ntohll(grh->SGID.gid_prefix);
        } else {
                sgid = info->ti_pi->p_sgid_tbl[0];
                new_gwi->gw_addr.ga_gid.gid_prefix =
                    sgid.gid_prefix;
        }
        new_gwi->gw_addr.ga_gid.gid_guid = gwi->gw_guid;
        new_gwi->gw_addr.ga_qpn = gwi->gw_ctrl_qpn;
        new_gwi->gw_addr.ga_qkey = EIB_FIP_QKEY;
        new_gwi->gw_addr.ga_pkey = EIB_ADMIN_PKEY;

        /*
         * Initialize gateway parameters received via the advertisement
         */
        new_gwi->gw_system_guid = gwi->gw_system_guid;
        new_gwi->gw_guid = gwi->gw_guid;
        new_gwi->gw_adv_period = gwi->gw_adv_period;
        new_gwi->gw_ka_period = gwi->gw_ka_period;
        new_gwi->gw_vnic_ka_period = gwi->gw_vnic_ka_period;
        new_gwi->gw_ctrl_qpn = gwi->gw_ctrl_qpn;
        new_gwi->gw_lid = gwi->gw_lid;
        new_gwi->gw_portid = gwi->gw_portid;
        new_gwi->gw_num_net_vnics = gwi->gw_num_net_vnics;
        new_gwi->gw_is_host_adm_vnics = gwi->gw_is_host_adm_vnics;
        new_gwi->gw_sl = gwi->gw_sl;
        new_gwi->gw_n_rss_qpn = gwi->gw_n_rss_qpn;
        new_gwi->gw_flag_ucast_advt = gwi->gw_flag_ucast_advt;
        new_gwi->gw_flag_available = gwi->gw_flag_available;
        bcopy(gwi->gw_system_name, new_gwi->gw_system_name,
            sizeof (new_gwi->gw_system_name));
        bcopy(gwi->gw_port_name, new_gwi->gw_port_name,
            sizeof (new_gwi->gw_port_name));
        bcopy(gwi->gw_vendor_id, new_gwi->gw_vendor_id,
            sizeof (new_gwi->gw_vendor_id));

        /*
         * Queue up the new gwi and return it
         */
        mutex_enter(&info->ti_gw_lock);
        new_gwi->gw_next = info->ti_gw;
        info->ti_gw = new_gwi;
        mutex_exit(&info->ti_gw_lock);

        return (new_gwi);
}

/*
 * Update old data for the gateway in our list with the new data.
 */
void
eibnx_replace_gw_in_gwlist(eibnx_thr_info_t *info, eibnx_gw_info_t *orig_gwi,
    eibnx_gw_info_t *new_gwi, ibt_wc_t *wc, uint8_t *recv_buf,
    boolean_t *gwi_changed)
{
        ib_sn_prefix_t new_gw_sn_prefix;
        ib_grh_t *grh;
        ib_gid_t sgid;
        boolean_t changed = B_FALSE;
        boolean_t gw_addr_changed = B_TRUE;

        /*
         * We'll update all info received in the new advertisement in
         * the original gwi and also move the gw_state to that of the state
         * in the new gwi.
         */
        mutex_enter(&info->ti_gw_lock);

        orig_gwi->gw_state = new_gwi->gw_state;

        /*
         * The guids shouldn't really change for the "same" gateway
         */
        if (new_gwi->gw_system_guid != orig_gwi->gw_system_guid) {
                ENX_DPRINTF_WARN("gateway system guid changed for the "
                    "*same* gateway from 0x%llx to 0x%llx",
                    orig_gwi->gw_system_guid, new_gwi->gw_system_guid);

                orig_gwi->gw_system_guid = new_gwi->gw_system_guid;
                changed = B_TRUE;
        }
        if (new_gwi->gw_guid != orig_gwi->gw_guid) {
                ENX_DPRINTF_WARN("gateway guid changed for the "
                    "*same* gateway from 0x%llx to 0x%llx",
                    orig_gwi->gw_guid, new_gwi->gw_guid);

                orig_gwi->gw_guid = new_gwi->gw_guid;
                changed = B_TRUE;
                gw_addr_changed = B_TRUE;
        }

        if (new_gwi->gw_adv_period != orig_gwi->gw_adv_period) {
                ENX_DPRINTF_DEBUG("gateway adv period changed "
                    "from 0x%lx to 0x%lx", orig_gwi->gw_adv_period,
                    new_gwi->gw_adv_period);

                orig_gwi->gw_adv_period = new_gwi->gw_adv_period;
                changed = B_TRUE;
        }
        if (new_gwi->gw_ka_period != orig_gwi->gw_ka_period) {
                ENX_DPRINTF_DEBUG("gateway ka period changed "
                    "from 0x%lx to 0x%lx", orig_gwi->gw_ka_period,
                    new_gwi->gw_ka_period);

                orig_gwi->gw_ka_period = new_gwi->gw_ka_period;
                changed = B_TRUE;
        }
        if (new_gwi->gw_vnic_ka_period != orig_gwi->gw_vnic_ka_period) {
                ENX_DPRINTF_DEBUG("vnic ka period changed "
                    "from 0x%lx to 0x%lx", orig_gwi->gw_vnic_ka_period,
                    new_gwi->gw_vnic_ka_period);

                orig_gwi->gw_vnic_ka_period = new_gwi->gw_vnic_ka_period;
                changed = B_TRUE;
        }
        if (new_gwi->gw_ctrl_qpn != orig_gwi->gw_ctrl_qpn) {
                ENX_DPRINTF_DEBUG("gateway control qpn changed "
                    "from 0x%lx to 0x%lx", orig_gwi->gw_ctrl_qpn,
                    new_gwi->gw_ctrl_qpn);

                orig_gwi->gw_ctrl_qpn = new_gwi->gw_ctrl_qpn;
                changed = B_TRUE;
        }
        if (new_gwi->gw_lid != orig_gwi->gw_lid) {
                ENX_DPRINTF_DEBUG("gateway lid changed from 0x%x to 0x%x",
                    orig_gwi->gw_lid, new_gwi->gw_lid);

                orig_gwi->gw_lid = new_gwi->gw_lid;
                changed = B_TRUE;
                gw_addr_changed = B_TRUE;
        }

        /*
         * The identity of the gateway is currently defined by its portid,
         * so this cannot be different or eibnx_find_gw_in_gwlist() wouldn't
         * have thought it's the same.  For now though, we'll treat it
         * like any other parameter, and flag it if we find this different.
         */
        if (new_gwi->gw_portid != orig_gwi->gw_portid) {
                ENX_DPRINTF_WARN("gateway portid changed for the *same* "
                    "gateway from 0x%x to 0x%x", orig_gwi->gw_portid,
                    new_gwi->gw_portid);

                orig_gwi->gw_portid = new_gwi->gw_portid;
                changed = B_TRUE;
        }

        if (new_gwi->gw_is_host_adm_vnics != orig_gwi->gw_is_host_adm_vnics) {
                ENX_DPRINTF_DEBUG("host adm vnics changed from 0x%x to 0x%x",
                    orig_gwi->gw_is_host_adm_vnics,
                    new_gwi->gw_is_host_adm_vnics);

                orig_gwi->gw_is_host_adm_vnics = new_gwi->gw_is_host_adm_vnics;
                changed = B_TRUE;
        }
        if (new_gwi->gw_sl != orig_gwi->gw_sl) {
                ENX_DPRINTF_DEBUG("gateway sl changed from 0x%x to 0x%x",
                    orig_gwi->gw_sl, new_gwi->gw_sl);

                orig_gwi->gw_sl = new_gwi->gw_sl;
                changed = B_TRUE;
        }
        if (new_gwi->gw_n_rss_qpn != orig_gwi->gw_n_rss_qpn) {
                ENX_DPRINTF_DEBUG("gateway n_rss_qpn changed from 0x%x to 0x%x",
                    orig_gwi->gw_n_rss_qpn, new_gwi->gw_n_rss_qpn);

                orig_gwi->gw_n_rss_qpn = new_gwi->gw_n_rss_qpn;
                changed = B_TRUE;
        }

        /*
         * The gw_flag_ucast_advt and gw_flag_available are expected to
         * change over time (and even gw_num_net_vnics could change, but
         * it's of no use to us presently), and we shouldn't trigger any
         * flag for these
         */
        orig_gwi->gw_flag_ucast_advt = new_gwi->gw_flag_ucast_advt;
        orig_gwi->gw_flag_available = new_gwi->gw_flag_available;
        orig_gwi->gw_num_net_vnics = new_gwi->gw_num_net_vnics;

        if (strncmp((const char *)new_gwi->gw_system_name,
            (const char *)orig_gwi->gw_system_name, EIB_GW_SYSNAME_LEN) != 0) {
                ENX_DPRINTF_DEBUG("gateway system name changed from %s to %s",
                    orig_gwi->gw_system_name, new_gwi->gw_system_name);

                bcopy(new_gwi->gw_system_name, orig_gwi->gw_system_name,
                    EIB_GW_SYSNAME_LEN);
                changed = B_TRUE;
        }
        if (strncmp((const char *)new_gwi->gw_port_name,
            (const char *)orig_gwi->gw_port_name, EIB_GW_PORTNAME_LEN) != 0) {
                ENX_DPRINTF_DEBUG("gateway port name changed from %s to %s",
                    orig_gwi->gw_port_name, new_gwi->gw_port_name);

                bcopy(new_gwi->gw_port_name, orig_gwi->gw_port_name,
                    EIB_GW_PORTNAME_LEN);
                changed = B_TRUE;
        }
        if (strncmp((const char *)new_gwi->gw_vendor_id,
            (const char *)orig_gwi->gw_vendor_id, EIB_GW_VENDOR_LEN) != 0) {
                ENX_DPRINTF_DEBUG("vendor id changed from %s to %s",
                    orig_gwi->gw_vendor_id, new_gwi->gw_vendor_id);

                bcopy(new_gwi->gw_vendor_id, orig_gwi->gw_vendor_id,
                    EIB_GW_VENDOR_LEN);
                changed = B_TRUE;
        }

        /*
         * See if the subnet prefix for the gateway has changed
         */
        if (wc->wc_flags & IBT_WC_GRH_PRESENT) {
                grh = (ib_grh_t *)(uintptr_t)recv_buf;
                new_gw_sn_prefix = ntohll(grh->SGID.gid_prefix);
        } else {
                sgid = info->ti_pi->p_sgid_tbl[0];
                new_gw_sn_prefix = sgid.gid_prefix;
        }
        if (new_gw_sn_prefix != orig_gwi->gw_addr.ga_gid.gid_prefix) {
                ENX_DPRINTF_WARN("subnet prefix changed from 0x%llx to 0x%llx",
                    orig_gwi->gw_addr.ga_gid.gid_prefix, new_gw_sn_prefix);

                changed = B_TRUE;
                gw_addr_changed = B_TRUE;
        }

        /*
         * If the gateway address has changed in any way, clear the current
         * address vector and update the gateway guid and gateway qpn. The
         * address vector will be created the next time a unicast solicit
         * is attempted for this gateway.
         */
        if (gw_addr_changed) {
                if (orig_gwi->gw_addr.ga_vect != NULL) {
                        kmem_free(orig_gwi->gw_addr.ga_vect,
                            sizeof (ibt_adds_vect_t));
                        orig_gwi->gw_addr.ga_vect = NULL;
                }
                orig_gwi->gw_addr.ga_gid.gid_prefix = new_gw_sn_prefix;
                orig_gwi->gw_addr.ga_gid.gid_guid = new_gwi->gw_guid;
                orig_gwi->gw_addr.ga_qpn = new_gwi->gw_ctrl_qpn;
                orig_gwi->gw_addr.ga_qkey = EIB_FIP_QKEY;
                orig_gwi->gw_addr.ga_pkey = EIB_ADMIN_PKEY;
        }

        mutex_exit(&info->ti_gw_lock);

        if (gwi_changed) {
                *gwi_changed = changed;
        }
}

/*
 * Queue up a node for EoIB instantiation and wake up the thread
 * that creates eoib nodes.
 */
void
eibnx_queue_for_creation(eibnx_thr_info_t *info, eibnx_gw_info_t *gwi)
{
        eibnx_t *ss = enx_global_ss;
        eibnx_nodeq_t *new_node;

        /*
         * For now, we'll simply do KM_NOSLEEP allocation, since this
         * code is called from within rx processing
         */
        new_node = kmem_zalloc(sizeof (eibnx_nodeq_t), KM_NOSLEEP);
        if (new_node == NULL) {
                ENX_DPRINTF_WARN("no memory, eoib node will not be "
                    "created for hca_guid=0x%llx, hca_port=0x%x, "
                    "gw_port_id=0x%x", info->ti_hca_guid,
                    info->ti_pi->p_port_num, gwi->gw_portid);
                return;
        }
        new_node->nc_info = info;
        new_node->nc_gwi = gwi;

        /*
         * If the eoib node creation thread is dying (or dead), don't
         * queue up any more requests for creation
         */
        mutex_enter(&ss->nx_nodeq_lock);
        if (ss->nx_nodeq_thr_die) {
                kmem_free(new_node, sizeof (eibnx_nodeq_t));
        } else {
                new_node->nc_next = ss->nx_nodeq;
                ss->nx_nodeq = new_node;
                cv_signal(&ss->nx_nodeq_cv);
        }
        mutex_exit(&ss->nx_nodeq_lock);
}