/*
 * 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/callb.h>
#include <sys/mac_provider.h>

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

/*
 * Thread to handle EoIB events asynchronously
 */
void
eib_events_handler(eib_t *ss)
{
        eib_event_t *evi;
        eib_event_t *nxt;
        kmutex_t ci_lock;
        callb_cpr_t ci;

        mutex_init(&ci_lock, NULL, MUTEX_DRIVER, NULL);
        CALLB_CPR_INIT(&ci, &ci_lock, callb_generic_cpr, EIB_EVENTS_HDLR);

wait_for_event:
        mutex_enter(&ss->ei_ev_lock);
        while ((evi = ss->ei_event) == NULL) {
                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_BEGIN(&ci);
                mutex_exit(&ci_lock);

                cv_wait(&ss->ei_ev_cv, &ss->ei_ev_lock);

                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_END(&ci, &ci_lock);
                mutex_exit(&ci_lock);
        }

        /*
         * Are we being asked to die ?
         */
        if (evi->ev_code == EIB_EV_SHUTDOWN) {
                while (evi) {
                        nxt = evi->ev_next;
                        kmem_free(evi, sizeof (eib_event_t));
                        evi = nxt;
                }
                ss->ei_event = NULL;
                mutex_exit(&ss->ei_ev_lock);

                mutex_enter(&ci_lock);
                CALLB_CPR_EXIT(&ci);
                mutex_destroy(&ci_lock);

                return;
        }

        /*
         * Otherwise, pull out the first entry from our work queue
         */
        ss->ei_event = evi->ev_next;
        evi->ev_next = NULL;

        mutex_exit(&ss->ei_ev_lock);

        /*
         * Process this event
         *
         * Note that we don't want to race with plumb/unplumb in this
         * handler, since we may have to restart vnics or do stuff that
         * may get re-initialized or released if we allowed plumb/unplumb
         * to happen in parallel.
         */
        eib_mac_set_nic_state(ss, EIB_NIC_RESTARTING);

        switch (evi->ev_code) {
        case EIB_EV_PORT_DOWN:
                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: Begin EIB_EV_PORT_DOWN");

                eib_mac_link_down(ss, B_FALSE);

                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: End EIB_EV_PORT_DOWN");
                break;

        case EIB_EV_PORT_UP:
                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: Begin EIB_EV_PORT_UP");

                eib_ibt_link_mod(ss);

                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: End EIB_EV_PORT_UP");
                break;

        case EIB_EV_PKEY_CHANGE:
                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: Begin EIB_EV_PKEY_CHANGE");

                eib_ibt_link_mod(ss);

                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: End EIB_EV_PKEY_CHANGE");
                break;

        case EIB_EV_SGID_CHANGE:
                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: Begin EIB_EV_SGID_CHANGE");

                eib_ibt_link_mod(ss);

                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: End EIB_EV_SGID_CHANGE");
                break;

        case EIB_EV_CLNT_REREG:
                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: Begin EIB_EV_CLNT_REREG");

                eib_ibt_link_mod(ss);

                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: End EIB_EV_CLNT_REREG");
                break;

        case EIB_EV_GW_UP:
                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: Begin EIB_EV_GW_UP");

                /*
                 * EoIB nexus has notified us that our gateway is now
                 * reachable. Unless we already think it is reachable,
                 * mark it so in our records and try to resurrect dead
                 * vnics.
                 */
                mutex_enter(&ss->ei_vnic_lock);
                if (ss->ei_gw_unreachable == B_FALSE) {
                        EIB_DPRINTF_DEBUG(ss->ei_instance,
                            "eib_events_handler: gw reachable");
                        mutex_exit(&ss->ei_vnic_lock);

                        EIB_DPRINTF_DEBUG(ss->ei_instance,
                            "eib_events_handler: End EIB_EV_GW_UP");
                        break;
                }
                ss->ei_gw_unreachable = B_FALSE;
                mutex_exit(&ss->ei_vnic_lock);

                /*
                 * If we've not even started yet, we have nothing to do.
                 */
                if ((ss->ei_node_state->ns_nic_state & EIB_NIC_STARTED) == 0) {
                        EIB_DPRINTF_DEBUG(ss->ei_instance,
                            "eib_events_handler: End EIB_EV_GW_UP");
                        break;
                }

                if (eib_mac_hca_portstate(ss, NULL, NULL) != EIB_E_SUCCESS) {
                        EIB_DPRINTF_DEBUG(ss->ei_instance,
                            "eib_events_handler: "
                            "HCA portstate failed, marking link down");

                        eib_mac_link_down(ss, B_FALSE);
                } else {
                        uint8_t vn0_mac[ETHERADDRL];

                        EIB_DPRINTF_DEBUG(ss->ei_instance,
                            "eib_events_handler: "
                            "HCA portstate ok, resurrecting zombies");

                        bcopy(eib_zero_mac, vn0_mac, ETHERADDRL);
                        eib_vnic_resurrect_zombies(ss, vn0_mac);

                        /*
                         * If we've resurrected the zombies because the gateway
                         * went down and came back, it is possible our unicast
                         * mac address changed from what it was earlier. If
                         * so, we need to update our unicast address with the
                         * mac layer before marking the link up.
                         */
                        if (bcmp(vn0_mac, eib_zero_mac, ETHERADDRL) != 0) {
                                EIB_DPRINTF_DEBUG(ss->ei_instance,
                                    "eib_events_handler: updating unicast "
                                    "addr to %x:%x:%x:%x:%x:%x", vn0_mac[0],
                                    vn0_mac[1], vn0_mac[2], vn0_mac[3],
                                    vn0_mac[4], vn0_mac[5]);

                                mac_unicst_update(ss->ei_mac_hdl, vn0_mac);
                        }

                        EIB_DPRINTF_DEBUG(ss->ei_instance,
                            "eib_events_handler: eib_mac_link_up(B_FALSE)");

                        eib_mac_link_up(ss, B_FALSE);
                }

                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: End EIB_EV_GW_UP");
                break;

        case EIB_EV_GW_INFO_UPDATE:
                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: Begin EIB_EV_GW_INFO_UPDATE");

                if (evi->ev_arg) {
                        eib_update_props(ss, (eib_gw_info_t *)(evi->ev_arg));
                        kmem_free(evi->ev_arg, sizeof (eib_gw_info_t));
                }

                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: End EIB_EV_GW_INFO_UPDATE");
                break;

        case EIB_EV_MCG_DELETED:
                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: Begin-End EIB_EV_MCG_DELETED");
                break;

        case EIB_EV_MCG_CREATED:
                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: Begin-End EIB_EV_MCG_CREATED");
                break;

        case EIB_EV_GW_EPORT_DOWN:
                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: Begin-End EIB_EV_GW_EPORT_DOWN");
                break;

        case EIB_EV_GW_DOWN:
                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_events_handler: Begin-End EIB_EV_GW_DOWN");
                break;
        }

        eib_mac_clr_nic_state(ss, EIB_NIC_RESTARTING);

        kmem_free(evi, sizeof (eib_event_t));
        goto wait_for_event;

        /*NOTREACHED*/
}

void
eib_svc_enqueue_event(eib_t *ss, eib_event_t *evi)
{
        eib_event_t *elem = NULL;
        eib_event_t *tail = NULL;

        mutex_enter(&ss->ei_ev_lock);

        /*
         * Notice to shutdown has a higher priority than the
         * rest and goes to the head of the list. Everything
         * else goes at the end.
         */
        if (evi->ev_code == EIB_EV_SHUTDOWN) {
                evi->ev_next = ss->ei_event;
                ss->ei_event = evi;
        } else {
                for (elem = ss->ei_event; elem; elem = elem->ev_next)
                        tail = elem;

                if (tail)
                        tail->ev_next = evi;
                else
                        ss->ei_event = evi;
        }

        cv_signal(&ss->ei_ev_cv);
        mutex_exit(&ss->ei_ev_lock);
}

/*
 * Thread to refill channels with rwqes whenever they get low.
 */
void
eib_refill_rwqes(eib_t *ss)
{
        eib_chan_t *chan;
        kmutex_t ci_lock;
        callb_cpr_t ci;

        mutex_init(&ci_lock, NULL, MUTEX_DRIVER, NULL);
        CALLB_CPR_INIT(&ci, &ci_lock, callb_generic_cpr, EIB_RWQES_REFILLER);

wait_for_refill_work:
        mutex_enter(&ss->ei_rxpost_lock);

        while ((ss->ei_rxpost == NULL) && (ss->ei_rxpost_die == 0)) {
                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_BEGIN(&ci);
                mutex_exit(&ci_lock);

                cv_wait(&ss->ei_rxpost_cv, &ss->ei_rxpost_lock);

                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_END(&ci, &ci_lock);
                mutex_exit(&ci_lock);
        }

        /*
         * Discard all requests for refill if we're being asked to die
         */
        if (ss->ei_rxpost_die) {
                ss->ei_rxpost = NULL;
                mutex_exit(&ss->ei_rxpost_lock);

                mutex_enter(&ci_lock);
                CALLB_CPR_EXIT(&ci);
                mutex_destroy(&ci_lock);

                return;
        }
        ASSERT(ss->ei_rxpost != NULL);

        /*
         * Take the first element out of the queue
         */
        chan = ss->ei_rxpost;
        ss->ei_rxpost = chan->ch_rxpost_next;
        chan->ch_rxpost_next = NULL;

        mutex_exit(&ss->ei_rxpost_lock);

        /*
         * Try to post a bunch of recv wqes into this channel. If we
         * fail, it means that we haven't even been able to post a
         * single recv wqe.  This is alarming, but there's nothing
         * we can do. We just move on to the next channel needing
         * our service.
         */
        if (eib_chan_post_rx(ss, chan, NULL) != EIB_E_SUCCESS) {
                EIB_DPRINTF_ERR(ss->ei_instance,
                    "eib_refill_rwqes: eib_chan_post_rx() failed");
        }

        /*
         * Mark it to indicate that the refilling is done
         */
        mutex_enter(&chan->ch_rx_lock);
        chan->ch_rx_refilling = B_FALSE;
        mutex_exit(&chan->ch_rx_lock);

        goto wait_for_refill_work;

        /*NOTREACHED*/
}

/*
 * Thread to create or restart vnics when required
 */
void
eib_vnic_creator(eib_t *ss)
{
        eib_vnic_req_t *vrq;
        eib_vnic_req_t *elem;
        eib_vnic_req_t *nxt;
        kmutex_t ci_lock;
        callb_cpr_t ci;
        uint_t vr_req;
        uint8_t *vr_mac;
        int ret;
        int err;

        mutex_init(&ci_lock, NULL, MUTEX_DRIVER, NULL);
        CALLB_CPR_INIT(&ci, &ci_lock, callb_generic_cpr, EIB_VNIC_CREATOR);

wait_for_vnic_req:
        mutex_enter(&ss->ei_vnic_req_lock);

        while ((vrq = ss->ei_vnic_req) == NULL) {
                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_BEGIN(&ci);
                mutex_exit(&ci_lock);

                cv_wait(&ss->ei_vnic_req_cv, &ss->ei_vnic_req_lock);

                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_END(&ci, &ci_lock);
                mutex_exit(&ci_lock);
        }

        /*
         * Pull out the first request
         */
        ss->ei_vnic_req = vrq->vr_next;
        vrq->vr_next = NULL;

        vr_req = vrq->vr_req;
        vr_mac = vrq->vr_mac;

        switch (vr_req) {
        case EIB_CR_REQ_DIE:
        case EIB_CR_REQ_FLUSH:
                /*
                 * Cleanup all pending reqs and failed reqs
                 */
                for (elem = ss->ei_vnic_req; elem; elem = nxt) {
                        nxt = elem->vr_next;
                        kmem_free(elem, sizeof (eib_vnic_req_t));
                }
                for (elem = ss->ei_failed_vnic_req; elem; elem = nxt) {
                        nxt = elem->vr_next;
                        kmem_free(elem, sizeof (eib_vnic_req_t));
                }
                ss->ei_vnic_req = NULL;
                ss->ei_failed_vnic_req = NULL;
                ss->ei_pending_vnic_req = NULL;
                mutex_exit(&ss->ei_vnic_req_lock);

                break;

        case EIB_CR_REQ_NEW_VNIC:
                ss->ei_pending_vnic_req = vrq;
                mutex_exit(&ss->ei_vnic_req_lock);

                EIB_DPRINTF_DEBUG(ss->ei_instance, "eib_vnic_creator: "
                    "new vnic creation request for %x:%x:%x:%x:%x:%x, 0x%x",
                    vr_mac[0], vr_mac[1], vr_mac[2], vr_mac[3], vr_mac[4],
                    vr_mac[5], vrq->vr_vlan);

                /*
                 * Make sure we don't race with the plumb/unplumb code.  If
                 * the eoib instance has been unplumbed already, we ignore any
                 * creation requests that may have been pending.
                 */
                eib_mac_set_nic_state(ss, EIB_NIC_STARTING);

                if ((ss->ei_node_state->ns_nic_state & EIB_NIC_STARTED) !=
                    EIB_NIC_STARTED) {
                        mutex_enter(&ss->ei_vnic_req_lock);
                        ss->ei_pending_vnic_req = NULL;
                        mutex_exit(&ss->ei_vnic_req_lock);
                        eib_mac_clr_nic_state(ss, EIB_NIC_STARTING);
                        break;
                }

                /*
                 * Try to create a new vnic with the supplied parameters.
                 */
                err = 0;
                if ((ret = eib_vnic_create(ss, vrq->vr_mac, vrq->vr_vlan,
                    NULL, &err)) != EIB_E_SUCCESS) {
                        EIB_DPRINTF_WARN(ss->ei_instance, "eib_vnic_creator: "
                            "eib_vnic_create(mac=%x:%x:%x:%x:%x:%x, vlan=0x%x) "
                            "failed, ret=%d", vr_mac[0], vr_mac[1], vr_mac[2],
                            vr_mac[3], vr_mac[4], vr_mac[5], vrq->vr_vlan, err);
                }

                /*
                 * If we failed, add this vnic req to our failed list (unless
                 * it already exists there), so we won't try to create this
                 * vnic again.  Whether we fail or succeed, we're done with
                 * processing this req, so clear the pending req.
                 */
                mutex_enter(&ss->ei_vnic_req_lock);
                if ((ret != EIB_E_SUCCESS) && (err != EEXIST)) {
                        vrq->vr_next = ss->ei_failed_vnic_req;
                        ss->ei_failed_vnic_req = vrq;
                        vrq = NULL;
                }
                ss->ei_pending_vnic_req = NULL;
                mutex_exit(&ss->ei_vnic_req_lock);

                /*
                 * Notify the mac layer that it should retry its tx again. If we
                 * had created the vnic successfully, we'll be able to send the
                 * packets; if we had not been successful, we'll drop packets on
                 * this vnic.
                 */
                EIB_DPRINTF_DEBUG(ss->ei_instance,
                    "eib_vnic_creator: calling mac_tx_update()");
                mac_tx_update(ss->ei_mac_hdl);

                eib_mac_clr_nic_state(ss, EIB_NIC_STARTING);
                break;

        default:
                EIB_DPRINTF_DEBUG(ss->ei_instance, "eib_vnic_creator: "
                    "unknown request 0x%lx, ignoring", vrq->vr_req);
                break;
        }

        /*
         * Free the current req and quit if we have to
         */
        if (vrq) {
                kmem_free(vrq, sizeof (eib_vnic_req_t));
        }

        if (vr_req == EIB_CR_REQ_DIE) {
                mutex_enter(&ci_lock);
                CALLB_CPR_EXIT(&ci);
                mutex_destroy(&ci_lock);

                return;
        }

        goto wait_for_vnic_req;
        /*NOTREACHED*/
}

/*
 * Thread to monitor tx wqes and update the mac layer when needed.
 * Note that this thread can only be started after the tx wqe pool
 * has been allocated and initialized.
 */
void
eib_monitor_tx_wqes(eib_t *ss)
{
        eib_wqe_pool_t *wp = ss->ei_tx;
        kmutex_t ci_lock;
        callb_cpr_t ci;

        mutex_init(&ci_lock, NULL, MUTEX_DRIVER, NULL);
        CALLB_CPR_INIT(&ci, &ci_lock, callb_generic_cpr, EIB_TXWQES_MONITOR);

        ASSERT(wp != NULL);

monitor_wqe_status:
        mutex_enter(&wp->wp_lock);

        /*
         * Wait till someone falls short of wqes
         */
        while (wp->wp_status == 0) {
                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_BEGIN(&ci);
                mutex_exit(&ci_lock);

                cv_wait(&wp->wp_cv, &wp->wp_lock);

                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_END(&ci, &ci_lock);
                mutex_exit(&ci_lock);
        }

        /*
         * Have we been asked to die ?
         */
        if (wp->wp_status & EIB_TXWQE_MONITOR_DIE) {
                mutex_exit(&wp->wp_lock);

                mutex_enter(&ci_lock);
                CALLB_CPR_EXIT(&ci);
                mutex_destroy(&ci_lock);

                return;
        }

        ASSERT((wp->wp_status & EIB_TXWQE_SHORT) != 0);

        /*
         * Start monitoring free wqes till they cross min threshold
         */
        while ((wp->wp_nfree < EIB_NFREE_SWQES_HWM) &&
            ((wp->wp_status & EIB_TXWQE_MONITOR_DIE) == 0)) {

                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_BEGIN(&ci);
                mutex_exit(&ci_lock);

                cv_wait(&wp->wp_cv, &wp->wp_lock);

                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_END(&ci, &ci_lock);
                mutex_exit(&ci_lock);
        }

        /*
         * Have we been asked to die ?
         */
        if (wp->wp_status & EIB_TXWQE_MONITOR_DIE) {
                mutex_exit(&wp->wp_lock);

                mutex_enter(&ci_lock);
                CALLB_CPR_EXIT(&ci);
                mutex_destroy(&ci_lock);

                return;
        }

        ASSERT(wp->wp_nfree >= EIB_NFREE_SWQES_HWM);
        wp->wp_status &= (~EIB_TXWQE_SHORT);

        mutex_exit(&wp->wp_lock);

        /*
         * Inform the mac layer that tx resources are now available
         * and go back to monitoring
         */
        if (ss->ei_mac_hdl) {
                mac_tx_update(ss->ei_mac_hdl);
        }
        goto monitor_wqe_status;

        /*NOTREACHED*/
}

/*
 * Thread to monitor lso bufs and update the mac layer as needed.
 * Note that this thread can only be started after the lso buckets
 * have been allocated and initialized.
 */
void
eib_monitor_lso_bufs(eib_t *ss)
{
        eib_lsobkt_t *bkt = ss->ei_lso;
        kmutex_t ci_lock;
        callb_cpr_t ci;

        mutex_init(&ci_lock, NULL, MUTEX_DRIVER, NULL);
        CALLB_CPR_INIT(&ci, &ci_lock, callb_generic_cpr, EIB_LSOBUFS_MONITOR);

        ASSERT(bkt != NULL);

monitor_lso_status:
        mutex_enter(&bkt->bk_lock);

        /*
         * Wait till someone falls short of LSO buffers or we're asked
         * to die
         */
        while (bkt->bk_status == 0) {
                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_BEGIN(&ci);
                mutex_exit(&ci_lock);

                cv_wait(&bkt->bk_cv, &bkt->bk_lock);

                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_END(&ci, &ci_lock);
                mutex_exit(&ci_lock);
        }

        if (bkt->bk_status & EIB_LBUF_MONITOR_DIE) {
                mutex_exit(&bkt->bk_lock);

                mutex_enter(&ci_lock);
                CALLB_CPR_EXIT(&ci);
                mutex_destroy(&ci_lock);

                return;
        }

        ASSERT((bkt->bk_status & EIB_LBUF_SHORT) != 0);

        /*
         * Start monitoring free LSO buffers till there are enough
         * free buffers available
         */
        while ((bkt->bk_nfree < EIB_LSO_FREE_BUFS_THRESH) &&
            ((bkt->bk_status & EIB_LBUF_MONITOR_DIE) == 0)) {

                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_BEGIN(&ci);
                mutex_exit(&ci_lock);

                cv_wait(&bkt->bk_cv, &bkt->bk_lock);

                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_END(&ci, &ci_lock);
                mutex_exit(&ci_lock);
        }

        if (bkt->bk_status & EIB_LBUF_MONITOR_DIE) {
                mutex_exit(&bkt->bk_lock);

                mutex_enter(&ci_lock);
                CALLB_CPR_EXIT(&ci);
                mutex_destroy(&ci_lock);

                return;
        }

        /*
         * We have enough lso buffers available now
         */
        ASSERT(bkt->bk_nfree >= EIB_LSO_FREE_BUFS_THRESH);
        bkt->bk_status &= (~EIB_LBUF_SHORT);

        mutex_exit(&bkt->bk_lock);

        /*
         * Inform the mac layer that tx lso resources are now available
         * and go back to monitoring
         */
        if (ss->ei_mac_hdl) {
                mac_tx_update(ss->ei_mac_hdl);
        }
        goto monitor_lso_status;

        /*NOTREACHED*/
}

/*
 * Thread to manage the keepalive requirements for vnics and the gateway.
 */
void
eib_manage_keepalives(eib_t *ss)
{
        eib_ka_vnics_t *elem;
        eib_ka_vnics_t *nxt;
        clock_t deadline;
        int64_t lbolt64;
        int err;
        kmutex_t ci_lock;
        callb_cpr_t ci;

        mutex_init(&ci_lock, NULL, MUTEX_DRIVER, NULL);
        CALLB_CPR_INIT(&ci, &ci_lock, callb_generic_cpr, EIB_EVENTS_HDLR);

        mutex_enter(&ss->ei_ka_vnics_lock);

periodic_keepalive:
        deadline = ddi_get_lbolt() + ss->ei_gw_props->pp_vnic_ka_ticks;

        while ((ss->ei_ka_vnics_event &
            (EIB_KA_VNICS_DIE | EIB_KA_VNICS_TIMED_OUT)) == 0) {
                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_BEGIN(&ci);
                mutex_exit(&ci_lock);

                if (cv_timedwait(&ss->ei_ka_vnics_cv, &ss->ei_ka_vnics_lock,
                    deadline) == -1) {
                        ss->ei_ka_vnics_event |= EIB_KA_VNICS_TIMED_OUT;
                }

                mutex_enter(&ci_lock);
                CALLB_CPR_SAFE_END(&ci, &ci_lock);
                mutex_exit(&ci_lock);
        }

        if (ss->ei_ka_vnics_event & EIB_KA_VNICS_DIE) {
                for (elem = ss->ei_ka_vnics; elem; elem = nxt) {
                        nxt = elem->ka_next;
                        kmem_free(elem, sizeof (eib_ka_vnics_t));
                }
                ss->ei_ka_vnics = NULL;
                mutex_exit(&ss->ei_ka_vnics_lock);

                mutex_enter(&ci_lock);
                CALLB_CPR_EXIT(&ci);
                mutex_destroy(&ci_lock);

                return;
        }

        /*
         * Are there any vnics that need keepalive management ?
         */
        ss->ei_ka_vnics_event &= ~EIB_KA_VNICS_TIMED_OUT;
        if (ss->ei_ka_vnics == NULL)
                goto periodic_keepalive;

        /*
         * Ok, we need to send vnic keepalives to our gateway. But first
         * check if the gateway heartbeat is good as of this moment.  Note
         * that we need do get the lbolt value after acquiring ei_vnic_lock
         * to ensure that ei_gw_last_heartbeat does not change before the
         * comparison (to avoid a negative value in the comparison result
         * causing us to incorrectly assume that the gateway heartbeat has
         * stopped).
         */
        mutex_enter(&ss->ei_vnic_lock);

        lbolt64 = ddi_get_lbolt64();

        if (ss->ei_gw_last_heartbeat != 0) {
                if ((lbolt64 - ss->ei_gw_last_heartbeat) >
                    ss->ei_gw_props->pp_gw_ka_ticks) {

                        EIB_DPRINTF_WARN(ss->ei_instance,
                            "eib_manage_keepalives: no keepalives from gateway "
                            "0x%x for hca_guid=0x%llx, port=0x%x, "
                            "last_gw_ka=0x%llx", ss->ei_gw_props->pp_gw_portid,
                            ss->ei_props->ep_hca_guid,
                            ss->ei_props->ep_port_num,
                            ss->ei_gw_last_heartbeat);

                        for (elem = ss->ei_ka_vnics; elem; elem = nxt) {
                                nxt = elem->ka_next;
                                ss->ei_zombie_vnics |=
                                    ((uint64_t)1 << elem->ka_vnic->vn_instance);
                                kmem_free(elem, sizeof (eib_ka_vnics_t));
                        }
                        ss->ei_ka_vnics = NULL;
                        ss->ei_gw_unreachable = B_TRUE;
                        mutex_exit(&ss->ei_vnic_lock);

                        eib_mac_link_down(ss, B_FALSE);

                        goto periodic_keepalive;
                }
        }
        mutex_exit(&ss->ei_vnic_lock);

        for (elem = ss->ei_ka_vnics; elem; elem = elem->ka_next)
                (void) eib_fip_heartbeat(ss, elem->ka_vnic, &err);

        goto periodic_keepalive;
        /*NOTREACHED*/
}

void
eib_stop_events_handler(eib_t *ss)
{
        eib_event_t *evi;

        evi = kmem_zalloc(sizeof (eib_event_t), KM_SLEEP);
        evi->ev_code = EIB_EV_SHUTDOWN;
        evi->ev_arg = NULL;

        eib_svc_enqueue_event(ss, evi);

        thread_join(ss->ei_events_handler);
}

void
eib_stop_refill_rwqes(eib_t *ss)
{
        mutex_enter(&ss->ei_rxpost_lock);

        ss->ei_rxpost_die = 1;

        cv_signal(&ss->ei_rxpost_cv);
        mutex_exit(&ss->ei_rxpost_lock);

        thread_join(ss->ei_rwqes_refiller);
}

void
eib_stop_vnic_creator(eib_t *ss)
{
        eib_vnic_req_t *vrq;

        vrq = kmem_zalloc(sizeof (eib_vnic_req_t), KM_SLEEP);
        vrq->vr_req = EIB_CR_REQ_DIE;
        vrq->vr_next = NULL;

        eib_vnic_enqueue_req(ss, vrq);

        thread_join(ss->ei_vnic_creator);
}

void
eib_stop_monitor_tx_wqes(eib_t *ss)
{
        eib_wqe_pool_t *wp = ss->ei_tx;

        mutex_enter(&wp->wp_lock);

        wp->wp_status |= EIB_TXWQE_MONITOR_DIE;

        cv_signal(&wp->wp_cv);
        mutex_exit(&wp->wp_lock);

        thread_join(ss->ei_txwqe_monitor);
}

int
eib_stop_monitor_lso_bufs(eib_t *ss, boolean_t force)
{
        eib_lsobkt_t *bkt = ss->ei_lso;

        mutex_enter(&bkt->bk_lock);

        /*
         * If there are some buffers still not reaped and the force
         * flag is not set, return without doing anything. Otherwise,
         * stop the lso bufs monitor and wait for it to die.
         */
        if ((bkt->bk_nelem != bkt->bk_nfree) && (force == B_FALSE)) {
                mutex_exit(&bkt->bk_lock);
                return (EIB_E_FAILURE);
        }

        bkt->bk_status |= EIB_LBUF_MONITOR_DIE;

        cv_signal(&bkt->bk_cv);
        mutex_exit(&bkt->bk_lock);

        thread_join(ss->ei_lsobufs_monitor);
        return (EIB_E_SUCCESS);
}

void
eib_stop_manage_keepalives(eib_t *ss)
{
        mutex_enter(&ss->ei_ka_vnics_lock);

        ss->ei_ka_vnics_event |= EIB_KA_VNICS_DIE;

        cv_signal(&ss->ei_ka_vnics_cv);
        mutex_exit(&ss->ei_ka_vnics_lock);

        thread_join(ss->ei_keepalives_manager);
}

void
eib_flush_vnic_reqs(eib_t *ss)
{
        eib_vnic_req_t *vrq;

        vrq = kmem_zalloc(sizeof (eib_vnic_req_t), KM_SLEEP);
        vrq->vr_req = EIB_CR_REQ_FLUSH;
        vrq->vr_next = NULL;

        eib_vnic_enqueue_req(ss, vrq);
}

/*ARGSUSED*/
void
eib_gw_alive_cb(dev_info_t *dip, ddi_eventcookie_t cookie, void *arg,
    void *impl_data)
{
        eib_t *ss = (eib_t *)arg;
        eib_event_t *evi;

        evi = kmem_zalloc(sizeof (eib_event_t), KM_NOSLEEP);
        if (evi == NULL) {
                EIB_DPRINTF_WARN(ss->ei_instance, "eib_gw_alive_cb: "
                    "no memory, ignoring this gateway alive event");
        } else {
                evi->ev_code = EIB_EV_GW_UP;
                evi->ev_arg = NULL;
                eib_svc_enqueue_event(ss, evi);
        }
}

/*ARGSUSED*/
void
eib_login_ack_cb(dev_info_t *dip, ddi_eventcookie_t cookie, void *arg,
    void *impl_data)
{
        eib_t *ss = (eib_t *)arg;
        uint8_t *pkt = (uint8_t *)impl_data;
        eib_login_data_t ld;

        /*
         * We have received a login ack message from the gateway via the EoIB
         * nexus (solicitation qpn).  The packet is passed to us raw (unparsed)
         * and we have to figure out if this is a vnic login ack.
         */
        if (eib_fip_parse_login_ack(ss, pkt + EIB_GRH_SZ, &ld) == EIB_E_SUCCESS)
                eib_vnic_login_ack(ss, &ld);
}

/*ARGSUSED*/
void
eib_gw_info_cb(dev_info_t *dip, ddi_eventcookie_t cookie, void *arg,
    void *impl_data)
{
        eib_t *ss = (eib_t *)arg;
        eib_event_t *evi;

        evi = kmem_zalloc(sizeof (eib_event_t), KM_NOSLEEP);
        if (evi == NULL) {
                EIB_DPRINTF_WARN(ss->ei_instance, "eib_gw_info_cb: "
                    "no memory, ignoring this gateway props update event");
                return;
        }
        evi->ev_arg = kmem_zalloc(sizeof (eib_gw_info_t), KM_NOSLEEP);
        if (evi->ev_arg == NULL) {
                EIB_DPRINTF_WARN(ss->ei_instance, "eib_gw_info_cb: "
                    "no memory, ignoring this gateway props update event");
                kmem_free(evi, sizeof (eib_event_t));
                return;
        }
        bcopy(impl_data, evi->ev_arg, sizeof (eib_gw_info_t));
        evi->ev_code = EIB_EV_GW_INFO_UPDATE;

        eib_svc_enqueue_event(ss, evi);
}