sun4u/io/sbd_cpu.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * CPU support routines for DR
 */

#include <sys/debug.h>
#include <sys/types.h>
#include <sys/errno.h>
#include <sys/cred.h>
#include <sys/dditypes.h>
#include <sys/devops.h>
#include <sys/modctl.h>
#include <sys/poll.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/ddi_impldefs.h>
#include <sys/ndi_impldefs.h>
#include <sys/stat.h>
#include <sys/kmem.h>
#include <sys/processor.h>
#include <sys/cpuvar.h>
#include <sys/mem_config.h>
#include <sys/promif.h>
#include <sys/x_call.h>
#include <sys/cpu_sgnblk_defs.h>
#include <sys/membar.h>
#include <sys/stack.h>
#include <sys/sysmacros.h>
#include <sys/machsystm.h>
#include <sys/spitregs.h>

#include <sys/archsystm.h>
#include <vm/hat_sfmmu.h>
#include <sys/pte.h>
#include <sys/mmu.h>
#include <sys/x_call.h>
#include <sys/cpu_module.h>
#include <sys/cheetahregs.h>

#include <sys/autoconf.h>
#include <sys/cmn_err.h>

#include <sys/sbdpriv.h>

void
sbd_cpu_set_prop(sbd_cpu_unit_t *cp, dev_info_t *dip)
{
    uint32_t    clock_freq;
    int     ecache_size = 0;
    char        *cache_str = NULL;

    /* read in the CPU speed */
    clock_freq = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
        DDI_PROP_DONTPASS, "clock-frequency", 0);

    ASSERT(clock_freq != 0);

    /*
     * The ecache property string is not the same
     * for all CPU implementations.
     */
    switch (cp->sbc_cpu_impl) {
    case CHEETAH_IMPL:
    case CHEETAH_PLUS_IMPL:
        cache_str = "ecache-size";
        break;
    case JAGUAR_IMPL:
        cache_str = "l2-cache-size";
        break;
    case PANTHER_IMPL:
        cache_str = "l3-cache-size";
        break;
    default:
        cmn_err(CE_WARN, "cpu implementation type "
            "is an unknown %d value", cp->sbc_cpu_impl);
        ASSERT(0);
        break;
    }

    if (cache_str != NULL) {
        /* read in the ecache size */
        ecache_size = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
            DDI_PROP_DONTPASS, cache_str, 0);
    }

    /*
     * In the case the size is still 0,
     * a zero value will be displayed running non-debug.
     */
    ASSERT(ecache_size != 0);

    /* convert to the proper units */
    cp->sbc_speed = (clock_freq + 500000) / 1000000;
    cp->sbc_ecache = ecache_size / (1024 * 1024);
}

static void
sbd_fill_cpu_stat(sbd_cpu_unit_t *cp, dev_info_t *dip, sbd_cpu_stat_t *csp)
{
    int     namelen;

    bzero((caddr_t)csp, sizeof (*csp));
    csp->cs_type = cp->sbc_cm.sbdev_type;
    csp->cs_unit = cp->sbc_cm.sbdev_unum;
    namelen = sizeof (csp->cs_name);
    (void) ddi_getlongprop_buf(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
        OBP_DEVICETYPE, (caddr_t)csp->cs_name, &namelen);
    csp->cs_busy = cp->sbc_cm.sbdev_busy;
    csp->cs_time = cp->sbc_cm.sbdev_time;
    csp->cs_ostate = cp->sbc_cm.sbdev_ostate;
    csp->cs_cpuid = cp->sbc_cpu_id;
    csp->cs_suspend = 0;

    /*
     * If we have marked the cpu's condition previously
     * then don't rewrite it
     */
    if (csp->cs_cond != SBD_COND_UNUSABLE)
        csp->cs_cond = sbd_get_comp_cond(dip);

    /*
     * If the speed and ecache properties have not been
     * cached yet, read them in from the device tree.
     */
    if ((cp->sbc_speed == 0) || (cp->sbc_ecache == 0))
        sbd_cpu_set_prop(cp, dip);

    /* use the cached speed and ecache values */
    csp->cs_speed = cp->sbc_speed;
    csp->cs_ecache = cp->sbc_ecache;
}

static void
sbd_fill_cmp_stat(sbd_cpu_stat_t *csp, int ncores, int impl,
    sbd_cmp_stat_t *psp)
{
    int core;

    ASSERT(csp && psp && (ncores >= 1));

    bzero((caddr_t)psp, sizeof (*psp));

    /*
     * Fill in the common status information based
     * on the data for the first core.
     */
    psp->ps_type = SBD_COMP_CMP;
    psp->ps_unit = SBD_CMP_NUM(csp->cs_unit);
    (void) strncpy(psp->ps_name, csp->cs_name, sizeof (psp->ps_name));
    psp->ps_cond = csp->cs_cond;
    psp->ps_busy = csp->cs_busy;
    psp->ps_time = csp->cs_time;
    psp->ps_ostate = csp->cs_ostate;
    psp->ps_suspend = csp->cs_suspend;

    /* CMP specific status data */
    *psp->ps_cpuid = csp->cs_cpuid;
    psp->ps_ncores = 1;
    psp->ps_speed = csp->cs_speed;
    psp->ps_ecache = csp->cs_ecache;

    /*
     * Walk through the data for the remaining cores.
     * Make any adjustments to the common status data,
     * or the shared CMP specific data if necessary.
     */
    for (core = 1; core < ncores; core++) {

        /*
         * The following properties should be the same
         * for all the cores of the CMP.
         */
        ASSERT(psp->ps_unit == SBD_CMP_NUM(csp[core].cs_unit));
        ASSERT(psp->ps_speed == csp[core].cs_speed);

        psp->ps_cpuid[core] = csp[core].cs_cpuid;
        psp->ps_ncores++;

        /*
         * Jaguar has a split ecache, so the ecache
         * for each core must be added together to
         * get the total ecache for the whole chip.
         */
        if (IS_JAGUAR(impl)) {
            psp->ps_ecache += csp[core].cs_ecache;
        }

        /* adjust time if necessary */
        if (csp[core].cs_time > psp->ps_time) {
            psp->ps_time = csp[core].cs_time;
        }

        psp->ps_busy |= csp[core].cs_busy;

        /*
         * If any of the cores are configured, the
         * entire CMP is marked as configured.
         */
        if (csp[core].cs_ostate == SBD_STAT_CONFIGURED) {
            psp->ps_ostate = csp[core].cs_ostate;
        }
    }
}

int
sbd_cpu_flags(sbd_handle_t *hp, sbd_devset_t devset, sbd_dev_stat_t *dsp)
{
    int     cmp;
    int     ncpu;
    sbd_board_t *sbp;
    sbdp_handle_t   *hdp;
    sbd_cpu_stat_t  cstat[MAX_CORES_PER_CMP];

    sbp = SBDH2BD(hp->h_sbd);
    hdp = sbd_get_sbdp_handle(sbp, hp);

    /*
     * Grab the status lock before accessing the dip as we allow
     * concurrent status and branch unconfigure and disconnect.
     *
     * The disconnect thread clears the present devset first
     * and then destroys dips. It is possible that the status
     * thread checks the present devset before they are cleared
     * but accesses the dip after they are destroyed causing a
     * panic. To prevent this, the status thread should check
     * the present devset and access dips with status lock held.
     * Similarly disconnect thread should clear the present devset
     * and destroy dips with status lock held.
     */
    mutex_enter(&sbp->sb_slock);

    /*
     * Only look for requested devices that are actually present.
     */
    devset &= SBD_DEVS_PRESENT(sbp);

    /*
     * Treat every CPU as a CMP.  In the case where the
     * device is not a CMP, treat it as a CMP with only
     * one core.
     */
    for (cmp = ncpu = 0; cmp < MAX_CMP_UNITS_PER_BOARD; cmp++) {

        int     ncores;
        int     core;
        dev_info_t  *dip;
        sbd_cpu_unit_t  *cp;
        sbd_cmp_stat_t  *psp;

        if (DEVSET_IN_SET(devset, SBD_COMP_CMP, cmp) == 0)
            continue;

        ncores = 0;

        for (core = 0; core < MAX_CORES_PER_CMP; core++) {
            int unit;

            unit = sbdp_portid_to_cpu_unit(cmp, core);

            /*
             * Check to make sure the cpu is in a state
             * where its fully initialized.
             */
            if (SBD_DEVICE_STATE(sbp, SBD_COMP_CPU, unit) ==
                SBD_STATE_EMPTY)
                continue;

            dip = sbp->sb_devlist[NIX(SBD_COMP_CMP)][unit];
            if (dip == NULL)
                continue;

            cp = SBD_GET_BOARD_CPUUNIT(sbp, unit);

            sbd_fill_cpu_stat(cp, dip, &cstat[ncores++]);
        }

        if (ncores == 0)
            continue;

        /*
         * Store the data to the outgoing array. If the
         * device is a CMP, combine all the data for the
         * cores into a single stat structure.
         *
         * The check for a CMP device uses the last core
         * found, assuming that all cores will have the
         * same implementation.
         */
        if (CPU_IMPL_IS_CMP(cp->sbc_cpu_impl)) {
            psp = (sbd_cmp_stat_t *)dsp;
            sbd_fill_cmp_stat(cstat, ncores, cp->sbc_cpu_impl, psp);
        } else {
            ASSERT(ncores == 1);
            bcopy(cstat, dsp, sizeof (sbd_cpu_stat_t));
        }

        dsp++;
        ncpu++;
    }

    mutex_exit(&sbp->sb_slock);

    sbd_release_sbdp_handle(hdp);

    return (ncpu);
}

int
sbd_pre_release_cpu(sbd_handle_t *hp, sbd_devlist_t *devlist, int devnum)
{
    int     i, rv = 0, unit;
    dev_info_t  *dip;
    processorid_t   cpuid;
    struct cpu  *cpup;
    sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
    sbderror_t  *ep = SBD_HD2ERR(hp);
    sbd_cpu_unit_t  *cp;
    static fn_t f = "sbd_pre_release_cpu";
    sbdp_handle_t   *hdp;

    hdp = sbd_get_sbdp_handle(sbp, hp);
    /*
     * May have to juggle bootproc in release_component
     */
    mutex_enter(&cpu_lock);

    for (i = 0; i < devnum; i++, devlist++) {
        dip = devlist->dv_dip;

        cpuid = sbdp_get_cpuid(hdp, dip);
        if (cpuid < 0) {
            if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) {
                cmn_err(CE_WARN,
                    "sbd:%s: failed to get cpuid for "
                    "dip (0x%p)", f, (void *)dip);
                continue;
            } else {
                SBD_GET_PERR(hdp->h_err, SBD_HD2ERR(hp));
                break;
            }
        }


        unit = sbdp_get_unit_num(hdp, dip);
        if (unit < 0) {
            if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) {
            cmn_err(CE_WARN,
                "sbd:%s: failed to get unit (cpu %d)",
                f, cpuid);
                continue;
            } else {
                SBD_GET_PERR(hdp->h_err, SBD_HD2ERR(hp));
                break;
            }
        }

        cp = SBD_GET_BOARD_CPUUNIT(sbp, unit);
        cp->sbc_cpu_flags = cpu[cpuid]->cpu_flags;

        if (cpu_flagged_active(cp->sbc_cpu_flags)) {
            int cpu_offline_flags = 0;

            if (hp->h_flags & SBD_IOCTL_FLAG_FORCE)
                cpu_offline_flags = CPU_FORCED;
            PR_CPU("%s: offlining cpuid %d unit %d", f,
                cpuid, unit);
            if (cpu_offline(cpu[cpuid], cpu_offline_flags)) {
                cmn_err(CE_WARN,
                    "%s: failed to offline cpu %d",
                    f, cpuid);
                rv = -1;
                SBD_SET_ERR(ep, ESBD_OFFLINE);
                SBD_SET_ERRSTR(ep, sbp->sb_cpupath[i]);
                cpup = cpu_get(cpuid);
                if (cpup && disp_bound_threads(cpup, 0)) {
                    cmn_err(CE_WARN, "sbd:%s: thread(s) "
                        "bound to cpu %d",
                        f, cpup->cpu_id);
                }
                break;
            }
        }

        if (rv == 0) {
            if (sbdp_release_component(hdp, dip)) {
                SBD_GET_PERR(hdp->h_err, ep);
                break;
            }
        }

        if (rv)
            break;
    }

    mutex_exit(&cpu_lock);

    if (rv) {
        /*
         * Need to unwind others since at this level (pre-release)
         * the device state has not yet transitioned and failures
         * will prevent us from reaching the "post" release
         * function where states are normally transitioned.
         */
        for (; i >= 0; i--, devlist--) {
            dip = devlist->dv_dip;
            unit = sbdp_get_unit_num(hdp, dip);
            if (unit < 0) {
                cmn_err(CE_WARN,
                    "sbd:%s: failed to get unit for "
                    "dip (0x%p)", f, (void *)dip);
                break;
            }
            (void) sbd_cancel_cpu(hp, unit);
        }
    }

    SBD_INJECT_ERR(SBD_OFFLINE_CPU_PSEUDO_ERR,
        hp->h_err, EIO,
        ESBD_OFFLINE,
        sbp->sb_cpupath[devnum - 1]);

    sbd_release_sbdp_handle(hdp);

    return (rv);
}

int
sbd_pre_attach_cpu(sbd_handle_t *hp, sbd_devlist_t *devlist, int devnum)
{
    int     i;
    int     unit;
    processorid_t   cpuid;
    sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
    sbd_istate_t    dstate;
    dev_info_t  *dip;
    static fn_t f = "sbd_pre_attach_cpu";
    sbdp_handle_t   *hdp;

    PR_CPU("%s...\n", f);

    hdp = sbd_get_sbdp_handle(sbp, hp);

    for (i = 0; i < devnum; i++, devlist++) {
        dip = devlist->dv_dip;

        ASSERT(sbd_is_cmp_child(dip) || e_ddi_branch_held(dip));

        cpuid = sbdp_get_cpuid(hdp, dip);
        if (cpuid < 0) {
            if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) {
                cmn_err(CE_WARN,
                    "sbd:%s: failed to get cpuid for "
                    "dip (0x%p)", f, (void *)dip);
                continue;
            } else {
                SBD_GET_PERR(hdp->h_err, SBD_HD2ERR(hp));
                break;
            }
        }

        unit = sbdp_get_unit_num(hdp, dip);
        if (unit < 0) {
            if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) {
            cmn_err(CE_WARN,
                "sbd:%s: failed to get unit (cpu %d)",
                f, cpuid);
                continue;
            } else {
                SBD_GET_PERR(hdp->h_err, SBD_HD2ERR(hp));
                break;
            }
        }

        PR_CPU("%s: attach cpu-unit (%d.%d)\n",
            f, sbp->sb_num, unit);

        dstate = SBD_DEVICE_STATE(sbp, SBD_COMP_CPU, unit);

        if (dstate == SBD_STATE_UNCONFIGURED) {
            /*
             * If we're coming from the UNCONFIGURED
             * state then the cpu's sigblock will
             * still be mapped in.  Need to unmap it
             * before continuing with attachment.
             */
            PR_CPU("%s: unmapping sigblk for cpu %d\n",
                f, cpuid);

            /* platform specific release of sigblk */
            CPU_SGN_MAPOUT(cpuid);
        }

    }

    mutex_enter(&cpu_lock);

    sbd_release_sbdp_handle(hdp);

    return (0);
}

int
sbd_post_attach_cpu(sbd_handle_t *hp, sbd_devlist_t *devlist, int devnum)
{
    int     i;
    sbderror_t  *ep = SBD_HD2ERR(hp);
    sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
    processorid_t   cpuid;
    struct cpu  *cp;
    dev_info_t  *dip;
    int     err = ESBD_NOERROR;
    sbdp_handle_t   *hdp;
    static fn_t f = "sbd_post_attach_cpu";
    sbd_cpu_unit_t  *cpup;
    int     unit;

    hdp = sbd_get_sbdp_handle(sbp, hp);

    /* Startup and online newly-attached CPUs */
    for (i = 0; i < devnum; i++, devlist++) {
        dip = devlist->dv_dip;
        cpuid = sbdp_get_cpuid(hdp, dip);
        if (cpuid < 0) {
            if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) {
                cmn_err(CE_WARN,
                    "sbd:%s: failed to get cpuid for "
                    "dip (0x%p)", f, (void *)dip);
                continue;
            } else {
                SBD_GET_PERR(hdp->h_err, ep);
                break;
            }
        }

        cp = cpu_get(cpuid);

        if (cp == NULL) {
            if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) {
                cmn_err(CE_WARN,
                    "sbd:%s: cpu_get failed for cpu %d",
                    f, cpuid);
                continue;
            } else {
                SBD_SET_ERR(ep, ESBD_INTERNAL);
                SBD_SET_ERRSTR(ep, sbp->sb_cpupath[i]);
                break;
            }
        }

        if (cpu_is_poweredoff(cp)) {
            if (cpu_poweron(cp) != 0) {
                SBD_SET_ERR(ep, ESBD_CPUSTART);
                SBD_SET_ERRSTR(ep, sbp->sb_cpupath[i]);
                cmn_err(CE_WARN,
                    "%s: failed to power-on cpu %d",
                    f, cpuid);
                break;
            }
            SBD_INJECT_ERR(SBD_POWERON_CPU_PSEUDO_ERR,
                ep, EIO,
                ESBD_CPUSTOP,
                sbp->sb_cpupath[i]);
            PR_CPU("%s: cpu %d powered ON\n", f, cpuid);
        }

        if (cpu_is_offline(cp)) {
            PR_CPU("%s: onlining cpu %d...\n", f, cpuid);

            if (cpu_online(cp) != 0) {
                SBD_SET_ERR(ep, ESBD_ONLINE);
                SBD_SET_ERRSTR(ep, sbp->sb_cpupath[i]);
                cmn_err(CE_WARN,
                    "%s: failed to online cpu %d",
                    f, cp->cpu_id);
            }
            SBD_INJECT_ERR(SBD_ONLINE_CPU_PSEUDO_ERR,
                ep, EIO,
                ESBD_ONLINE,
                sbp->sb_cpupath[i]);
        }

        /*
         * if there is no error mark the cpu as OK to use
         */
        if (SBD_GET_ERR(ep) == 0) {
            unit = sbdp_get_unit_num(hdp, dip);
            if (unit < 0) {
                if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) {
                    cmn_err(CE_WARN,
                        "sbd:%s: failed to get unit "
                        "(cpu %d)", f, cpuid);
                    continue;
                } else {
                    SBD_GET_PERR(hdp->h_err,
                        SBD_HD2ERR(hp));
                    break;
                }
            }
            cpup = SBD_GET_BOARD_CPUUNIT(sbp, unit);
            cpup->sbc_cm.sbdev_cond = SBD_COND_OK;
        }
    }

    mutex_exit(&cpu_lock);

    sbd_release_sbdp_handle(hdp);

    if (err != ESBD_NOERROR) {
        return (-1);
    } else {
        return (0);
    }
}

int
sbd_pre_detach_cpu(sbd_handle_t *hp, sbd_devlist_t *devlist, int devnum)
{
    int     i;
    int     unit;
    processorid_t   cpuid;
    dev_info_t  *dip;
    struct cpu  *cpu;
    sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
    sbderror_t  *ep = SBD_HD2ERR(hp);
    static fn_t f = "sbd_pre_detach_cpu";
    sbdp_handle_t   *hdp;
    int     rv = 0;

    PR_CPU("%s...\n", f);

    hdp = sbd_get_sbdp_handle(sbp, hp);

    mutex_enter(&cpu_lock);

    for (i = 0; i < devnum; i++, devlist++) {
        dip = devlist->dv_dip;
        cpuid = sbdp_get_cpuid(hdp, dip);
        if (cpuid < 0) {
            if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) {
                cmn_err(CE_WARN,
                    "sbd:%s: failed to get cpuid for "
                    "dip (0x%p)", f, (void *)dip);
                continue;
            } else {
                SBD_GET_PERR(hdp->h_err, SBD_HD2ERR(hp));
                break;
            }
        }

        cpu = cpu_get(cpuid);

        if (cpu == NULL) {
            if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) {
                cmn_err(CE_WARN,
                    "sbd:%s: failed to get cpu %d",
                    f, cpuid);
                continue;
            } else {
                SBD_SET_ERR(ep, ESBD_INTERNAL);
                SBD_SET_ERRSTR(ep, sbp->sb_cpupath[i]);
                break;
            }
        }

        unit = sbdp_get_unit_num(hdp, dip);
        if (unit < 0) {
            if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) {
                cmn_err(CE_WARN,
                    "sbd:%s: failed to get unit (cpu %d)",
                    f, cpuid);
                continue;
            } else {
                SBD_GET_PERR(hdp->h_err, SBD_HD2ERR(hp));
                break;
            }
        }

        PR_CPU("%s: OS detach cpu-unit (%d.%d)\n",
            f, sbp->sb_num, unit);

        /*
         * CPUs were offlined during Release.
         */
        if (cpu_is_poweredoff(cpu)) {
            PR_CPU("%s: cpu %d already powered OFF\n", f, cpuid);
            continue;
        }

        if (cpu_is_offline(cpu)) {
            int e;

            if (e = cpu_poweroff(cpu)) {
                cmn_err(CE_WARN,
                    "%s: failed to power-off cpu %d "
                    "(errno %d)",
                    f, cpu->cpu_id, e);
                SBD_SET_ERR(ep, ESBD_CPUSTOP);
                SBD_SET_ERRSTR(ep, sbp->sb_cpupath[i]);

                rv = -1;
                break;
            } else {
                PR_CPU("%s: cpu %d powered OFF\n",
                    f, cpuid);
            }
        } else {
            cmn_err(CE_WARN, "%s: cpu %d still active",
                f, cpu->cpu_id);
            SBD_SET_ERR(ep, ESBD_BUSY);
            SBD_SET_ERRSTR(ep, sbp->sb_cpupath[i]);
            rv = -1;
            break;
        }
    }

    sbd_release_sbdp_handle(hdp);

    return (rv);
}

int
sbd_post_detach_cpu(sbd_handle_t *hp, sbd_devlist_t *devlist, int devnum)
{
    static fn_t f = "sbd_post_detach_cpu";
    int     i;
    sbderror_t  *ep = SBD_HD2ERR(hp);
    sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
    processorid_t   cpuid;
    dev_info_t  *dip;
    sbdp_handle_t   *hdp;
    sbd_cpu_unit_t  *cpup;
    int     unit;

    PR_CPU("%s...\n", f);

    /*
     * We should be holding the cpu_lock at this point,
     * and should have blocked device tree changes.
     */
    ASSERT(MUTEX_HELD(&cpu_lock));

    for (i = 0; i < devnum; i++, devlist++) {
        dip = devlist->dv_dip;
        hdp = sbd_get_sbdp_handle(sbp, hp);
        cpuid = sbdp_get_cpuid(hdp, dip);
        if (cpuid < 0) {
            if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) {
                cmn_err(CE_WARN,
                    "sbd:%s: failed to get cpuid for "
                    "dip (0x%p)", f, (void *)dip);
                continue;
            } else {
                SBD_GET_PERR(hdp->h_err, ep);
                break;
            }
        }
        /*
         * if there is no error mark the cpu as unusable
         */
        if (SBD_GET_ERR(ep) == 0) {
            unit = sbdp_get_unit_num(hdp, dip);
            if (unit < 0) {
                if (hp->h_flags & SBD_IOCTL_FLAG_FORCE) {
                    cmn_err(CE_WARN,
                        "sbd:%s: failed to get unit "
                        "(cpu %d)", f, cpuid);
                    continue;
                } else {
                    SBD_GET_PERR(hdp->h_err,
                        SBD_HD2ERR(hp));
                    break;
                }
            }
            cpup = SBD_GET_BOARD_CPUUNIT(sbp, unit);
            cpup->sbc_cm.sbdev_cond = SBD_COND_UNUSABLE;
        }
        sbd_release_sbdp_handle(hdp);
    }

    mutex_exit(&cpu_lock);


    return (0);
}

/*
 * Cancel previous release operation for cpu.  For cpus this means simply
 * bringing cpus that were offline back online.  Note that they had to have been
 * online at the time they were released.  If attempting to power on or online
 * a CPU fails, SBD_CPUERR_FATAL is returned to indicate that the CPU appears to
 * be unsalvageable.  If a CPU reaches an online or nointr state but can't be
 * taken to a "lesser" state, SBD_CPUERR_RECOVERABLE is returned to indicate
 * that it was not returned to its original state but appears to be functional.
 * Note that the latter case can occur due to unexpected but non-erroneous CPU
 * manipulation (e.g. by the "psradm" command) during the DR operation.
 */
int
sbd_cancel_cpu(sbd_handle_t *hp, int unit)
{
    int     rv = SBD_CPUERR_NONE;
    sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
    sbderror_t  *ep = SBD_HD2ERR(hp);
    sbd_cpu_unit_t  *cp;
    static fn_t f = "sbd_cancel_cpu";
    struct cpu  *cpup;
    int     cpu_offline_flags = 0;

    PR_ALL("%s...\n", f);

    cp = SBD_GET_BOARD_CPUUNIT(sbp, unit);

    /*
     * If CPU should remain off, nothing needs to be done.
     */
    if (cpu_flagged_poweredoff(cp->sbc_cpu_flags))
        return (rv);

    if (hp->h_flags & SBD_IOCTL_FLAG_FORCE)
        cpu_offline_flags = CPU_FORCED;

    /*
     * CPU had been either offline, online, or set to no-intr.  We
     * will return a component to its original state that it was
     * prior to the failed DR operation.  There is a possible race
     * condition between the calls to this function and re-obtaining
     * the cpu_lock where a cpu state could change.  Because of this
     * we can't externally document that we are trying to roll cpus
     * back to their original state, but we believe a best effort
     * should be made.
     */

    mutex_enter(&cpu_lock);
    cpup = cpu[cp->sbc_cpu_id];

    /*
     * The following will compare the cpu's current state with a
     * snapshot of its state taken before the failed DR operation
     * had started.
     */
    /* POWEROFF */
    if (cpu_is_poweredoff(cpup)) {
        if (cpu_poweron(cpup)) {
            cmn_err(CE_WARN,
                "sbd:%s: failed to power-on cpu %d",
                f, cp->sbc_cpu_id);
            SBD_SET_ERR(ep, ESBD_CPUSTART);
            SBD_SET_ERRSTR(ep, sbp->sb_cpupath[unit]);
            rv = SBD_CPUERR_FATAL;
            goto out;
        }
        SBD_INJECT_ERR(SBD_POWERON_CPU_PSEUDO_ERR,
            hp->h_err, EIO,
            ESBD_CPUSTART,
            sbp->sb_cpupath[unit]);
    }

    /* OFFLINE */
    if (cpu_is_offline(cpup)) {
        if (cpu_flagged_offline(cp->sbc_cpu_flags)) {
            PR_CPU("%s: leaving cpu %d OFFLINE\n",
                f, cp->sbc_cpu_id);
        } else if (cpu_online(cpup)) {
            cmn_err(CE_WARN,
                "sbd:%s: failed to online cpu %d",
                f, cp->sbc_cpu_id);
            SBD_SET_ERR(ep, ESBD_ONLINE);
            SBD_SET_ERRSTR(ep, sbp->sb_cpupath[unit]);
            rv = SBD_CPUERR_FATAL;
            goto out;
        } else {
            SBD_INJECT_ERR(SBD_ONLINE_CPU_PSEUDO_ERR,
                hp->h_err, EIO,
                ESBD_ONLINE,
                sbp->sb_cpupath[unit]);
        }
    }

    /* ONLINE */
    if (cpu_is_online(cpup)) {
        if (cpu_flagged_online(cp->sbc_cpu_flags)) {
            PR_CPU("%s: setting cpu %d ONLINE\n",
                f, cp->sbc_cpu_id);
        } else if (cpu_flagged_offline(cp->sbc_cpu_flags)) {
            if (cpu_offline(cpup, cpu_offline_flags)) {
                cmn_err(CE_WARN,
                    "sbd:%s: failed to offline"
                    " cpu %d", f, cp->sbc_cpu_id);
                rv = SBD_CPUERR_RECOVERABLE;
                goto out;
            }
        } else if (cpu_flagged_nointr(cp->sbc_cpu_flags)) {
            if (cpu_intr_disable(cpup)) {
                cmn_err(CE_WARN, "%s: failed to "
                    "disable interrupts on cpu %d",
                    f, cp->sbc_cpu_id);
                rv = SBD_CPUERR_RECOVERABLE;
            } else {
                PR_CPU("%s: setting cpu %d to NOINTR"
                    " (was online)\n",
                    f, cp->sbc_cpu_id);
            }
            goto out;
        }
    }

    /* NOINTR */
    if (cpu_is_nointr(cpup)) {
        if (cpu_flagged_online(cp->sbc_cpu_flags)) {
            cpu_intr_enable(cpup);
            PR_CPU("%s: setting cpu %d ONLINE"
                "(was nointr)\n",
                f, cp->sbc_cpu_id);
        }
        if (cpu_flagged_offline(cp->sbc_cpu_flags)) {
            if (cpu_offline(cpup, cpu_offline_flags)) {
                cmn_err(CE_WARN,
                    "sbd:%s: failed to offline"
                    " cpu %d", f, cp->sbc_cpu_id);
                rv = SBD_CPUERR_RECOVERABLE;
            }
        }
    }
out:
    mutex_exit(&cpu_lock);

    return (rv);
}

int
sbd_connect_cpu(sbd_board_t *sbp, int unit)
{
    int     rv;
    processorid_t   cpuid;
    struct cpu  *cpu;
    dev_info_t  *dip;
    sbdp_handle_t   *hdp;
    extern kmutex_t cpu_lock;
    static fn_t f = "sbd_connect_cpu";
    sbd_handle_t    *hp = MACHBD2HD(sbp);

    /*
     * get dip for cpu just located in tree walk
     */
    if (SBD_DEV_IS_PRESENT(sbp, SBD_COMP_CPU, unit)) {
        dip = sbp->sb_devlist[NIX(SBD_COMP_CPU)][unit];
        if (dip == NULL) {
            cmn_err(CE_WARN,
            "sbd:%s: bad dip for cpu unit %d board %d",
            f, unit, sbp->sb_num);
            return (-1);
        }
        PR_CPU("%s...\n", f);
    } else {
        return (0);
    }

    /*
     * if sbd has attached this cpu, no need to bring
     * it out of reset
     */
    if (SBD_DEV_IS_ATTACHED(sbp, SBD_COMP_CPU, unit)) {
        return (0);
    }

    hdp = sbd_get_sbdp_handle(sbp, hp);

    cpuid = sbdp_get_cpuid(hdp, dip);
    if (cpuid == -1) {
        sbd_release_sbdp_handle(hdp);
        return (-1);
    }

    /*
     * if the cpu is already under Solaris control,
     * do not wake it up
     */
    mutex_enter(&cpu_lock);
    cpu = cpu_get(cpuid);
    mutex_exit(&cpu_lock);
    if (cpu != NULL) {
        sbd_release_sbdp_handle(hdp);
        return (0);
    }

    rv = sbdp_connect_cpu(hdp, dip, cpuid);

    if (rv != 0) {
        sbp->sb_memaccess_ok = 0;
        cmn_err(CE_WARN,
            "sbd:%s: failed to wake up cpu unit %d board %d",
            f, unit, sbp->sb_num);
        sbd_release_sbdp_handle(hdp);
        return (rv);
    }
    sbd_release_sbdp_handle(hdp);

    return (rv);
}

int
sbd_disconnect_cpu(sbd_handle_t *hp, int unit)
{
    sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
    int     rv;
    dev_info_t  *dip;
    sbdp_handle_t   *hdp;
    sbd_cpu_unit_t *cp;
    processorid_t   cpuid;
    static fn_t f = "sbd_disconnect_cpu";

    PR_CPU("%s...\n", f);

    ASSERT((SBD_DEVICE_STATE(sbp, SBD_COMP_CPU, unit) ==
                        SBD_STATE_CONNECTED) ||
        (SBD_DEVICE_STATE(sbp, SBD_COMP_CPU, unit) ==
                        SBD_STATE_UNCONFIGURED));

    cp = SBD_GET_BOARD_CPUUNIT(sbp, unit);

    cpuid = cp->sbc_cpu_id;

    dip = sbp->sb_devlist[NIX(SBD_COMP_CPU)][unit];

    hdp = sbd_get_sbdp_handle(sbp, hp);

    rv = sbdp_disconnect_cpu(hdp, dip, cpuid);

    if (rv != 0) {
        SBD_GET_PERR(hdp->h_err, SBD_HD2ERR(hp));
    }
    sbd_release_sbdp_handle(hdp);

    return (rv);
}