9023 port Delphix Xen-related fixes

[unleashed.git] / usr / src / uts / i86pc / i86hvm / io / xdf_shell.c

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

#include <io/xdf_shell.h>
#include <sys/dkio.h>
#include <sys/scsi/scsi_types.h>

/*
 * General Notes
 *
 * We don't support disks with bad block mappins.  We have this
 * limitation because the underlying xdf driver doesn't support
 * bad block remapping.  If there is a need to support this feature
 * it should be added directly to the xdf driver and we should just
 * pass requests strait on through and let it handle the remapping.
 * Also, it's probably worth pointing out that most modern disks do bad
 * block remapping internally in the hardware so there's actually less
 * of a chance of us ever discovering bad blocks.  Also, in most cases
 * this driver (and the xdf driver) will only be used with virtualized
 * devices, so one might wonder why a virtual device would ever actually
 * experience bad blocks.  To wrap this up, you might be wondering how
 * these bad block mappings get created and how they are managed.  Well,
 * there are two tools for managing bad block mappings, format(1M) and
 * addbadsec(1M).  Format(1M) can be used to do a surface scan of a disk
 * to attempt to find bad block and create mappings for them.  Format(1M)
 * and addbadsec(1M) can also be used to edit existing mappings that may
 * be saved on the disk.
 *
 * The underlying PV driver that this driver passes on requests to is the
 * xdf driver.  Since in most cases the xdf driver doesn't deal with
 * physical disks it has it's own algorithm for assigning a physical
 * geometry to a virtual disk (ie, cylinder count, head count, etc.)
 * The default values chosen by the xdf driver may not match those
 * assigned to a disk by a hardware disk emulator in an HVM environment.
 * This is a problem since these physical geometry attributes affect
 * things like the partition table, backup label location, etc.  So
 * to emulate disk devices correctly we need to know the physical geometry
 * that was assigned to a disk at the time of it's initalization.
 * Normally in an HVM environment this information will passed to
 * the BIOS and operating system from the hardware emulator that is
 * emulating the disk devices.  In the case of a solaris dom0+xvm
 * this would be qemu.  So to work around this issue, this driver will
 * query the emulated hardware to get the assigned physical geometry
 * and then pass this geometry onto the xdf driver so that it can use it.
 * But really, this information is essentially metadata about the disk
 * that should be kept with the disk image itself.  (Assuming or course
 * that a disk image is the actual backingstore for this emulated device.)
 * This metadata should also be made available to PV drivers via a common
 * mechanism, probably the xenstore.  The fact that this metadata isn't
 * available outside of HVM domains means that it's difficult to move
 * disks between HVM and PV domains, since a fully PV domain will have no
 * way of knowing what the correct geometry of the target device is.
 * (Short of reading the disk, looking for things like partition tables
 * and labels, and taking a best guess at what the geometry was when
 * the disk was initialized.  Unsuprisingly, qemu actually does this.)
 *
 * This driver has to map xdf shell device instances into their corresponding
 * xdf device instances.  We have to do this to ensure that when a user
 * accesses a emulated xdf shell device we map those accesses to the proper
 * paravirtualized device.  Basically what we need to know is how multiple
 * 'disk' entries in a domU configuration file get mapped to emulated
 * xdf shell devices and to xdf devices.  The 'disk' entry to xdf instance
 * mappings we know because those are done within the Solaris xvdi code
 * and the xpvd nexus driver.  But the config to emulated devices mappings
 * are handled entirely within the xen management tool chain and the
 * hardware emulator.  Since all the tools that establish these mappings
 * live in dom0, dom0 should really supply us with this information,
 * probably via the xenstore.  Unfortunatly it doesn't so, since there's
 * no good way to determine this mapping dynamically, this driver uses
 * a hard coded set of static mappings.  These mappings are hardware
 * emulator specific because each different hardware emulator could have
 * a different device tree with different xdf shell device paths.  This
 * means that if we want to continue to use this static mapping approach
 * to allow Solaris to run on different hardware emulators we'll have
 * to analyze each of those emulators to determine what paths they
 * use and hard code those paths into this driver.  yech.  This metadata
 * really needs to be supplied to us by dom0.
 *
 * This driver access underlying xdf nodes.  Unfortunatly, devices
 * must create minor nodes during attach, and for disk devices to create
 * minor nodes, they have to look at the label on the disk, so this means
 * that disk drivers must be able to access a disk contents during
 * attach.  That means that this disk driver must be able to access
 * underlying xdf nodes during attach.  Unfortunatly, due to device tree
 * locking restrictions, we cannot have an attach operation occuring on
 * this device and then attempt to access another device which may
 * cause another attach to occur in a different device tree branch
 * since this could result in deadlock.  Hence, this driver can only
 * access xdf device nodes that we know are attached, and it can't use
 * any ddi interfaces to access those nodes if those interfaces could
 * trigger an attach of the xdf device.  So this driver works around
 * these restrictions by talking directly to xdf devices via
 * xdf_hvm_hold().  This interface takes a pathname to an xdf device,
 * and if that device is already attached then it returns the a held dip
 * pointer for that device node.  This prevents us from getting into
 * deadlock situations, but now we need a mechanism to ensure that all
 * the xdf device nodes this driver might access are attached before
 * this driver tries to access them.  This is accomplished via the
 * hvmboot_rootconf() callback which is invoked just before root is
 * mounted.  hvmboot_rootconf() will attach xpvd and tell it to configure
 * all xdf device visible to the system.  All these xdf device nodes
 * will also be marked with the "ddi-no-autodetach" property so that
 * once they are configured, the will not be automatically unconfigured.
 * The only way that they could be unconfigured is if the administrator
 * explicitly attempts to unload required modules via rem_drv(1M)
 * or modunload(1M).
 */

/*
 * 16 paritions + fdisk (see xdf.h)
 */
#define XDFS_DEV2UNIT(dev)      XDF_INST((getminor((dev))))
#define XDFS_DEV2PART(dev)      XDF_PART((getminor((dev))))

#define OTYP_VALID(otyp)        ((otyp == OTYP_BLK) ||                  \
                                        (otyp == OTYP_CHR) ||           \
                                        (otyp == OTYP_LYR))

#define XDFS_NODES              4

#define XDFS_HVM_MODE(sp)       (XDFS_HVM_STATE(sp)->xdfs_hs_mode)
#define XDFS_HVM_DIP(sp)        (XDFS_HVM_STATE(sp)->xdfs_hs_dip)
#define XDFS_HVM_PATH(sp)       (XDFS_HVM_STATE(sp)->xdfs_hs_path)
#define XDFS_HVM_STATE(sp)                                              \
                ((xdfs_hvm_state_t *)(&((char *)(sp))[XDFS_HVM_STATE_OFFSET]))
#define XDFS_HVM_STATE_OFFSET   (xdfs_ss_size - sizeof (xdfs_hvm_state_t))
#define XDFS_HVM_SANE(sp)                                               \
                ASSERT(XDFS_HVM_MODE(sp));                              \
                ASSERT(XDFS_HVM_DIP(sp) != NULL);                       \
                ASSERT(XDFS_HVM_PATH(sp) != NULL);


typedef struct xdfs_hvm_state {
        boolean_t       xdfs_hs_mode;
        dev_info_t      *xdfs_hs_dip;
        char            *xdfs_hs_path;
} xdfs_hvm_state_t;

/* local function and structure prototypes */
static int xdfs_iodone(struct buf *);
static boolean_t xdfs_isopen_part(xdfs_state_t *, int);
static boolean_t xdfs_isopen(xdfs_state_t *);
static cmlb_tg_ops_t xdfs_lb_ops;

/*
 * Globals
 */
major_t                 xdfs_major;
#define                 xdfs_hvm_dev_ops (xdfs_c_hvm_dev_ops)
#define                 xdfs_hvm_cb_ops (xdfs_hvm_dev_ops->devo_cb_ops)

/*
 * Private globals
 */
volatile boolean_t      xdfs_pv_disable = B_FALSE;
static void             *xdfs_ssp;
static size_t           xdfs_ss_size;

/*
 * Private helper functions
 */
static boolean_t
xdfs_tgt_hold(xdfs_state_t *xsp)
{
        mutex_enter(&xsp->xdfss_mutex);
        ASSERT(xsp->xdfss_tgt_holds >= 0);
        if (!xsp->xdfss_tgt_attached) {
                mutex_exit(&xsp->xdfss_mutex);
                return (B_FALSE);
        }
        xsp->xdfss_tgt_holds++;
        mutex_exit(&xsp->xdfss_mutex);
        return (B_TRUE);
}

static void
xdfs_tgt_release(xdfs_state_t *xsp)
{
        mutex_enter(&xsp->xdfss_mutex);
        ASSERT(xsp->xdfss_tgt_attached);
        ASSERT(xsp->xdfss_tgt_holds > 0);
        if (--xsp->xdfss_tgt_holds == 0)
                cv_broadcast(&xsp->xdfss_cv);
        mutex_exit(&xsp->xdfss_mutex);
}

/*ARGSUSED*/
static int
xdfs_lb_getinfo(dev_info_t *dip, int cmd, void *arg, void *tg_cookie)
{
        int             instance = ddi_get_instance(dip);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);
        int             rv;

        if (xsp == NULL)
                return (ENXIO);

        if (!xdfs_tgt_hold(xsp))
                return (ENXIO);

        if (cmd == TG_GETVIRTGEOM) {
                cmlb_geom_t     pgeom, *vgeomp;
                diskaddr_t      capacity;

                /*
                 * The native xdf driver doesn't support this ioctl.
                 * Intead of passing it on, emulate it here so that the
                 * results look the same as what we get for a real xdf
                 * shell device.
                 *
                 * Get the real size of the device
                 */
                if ((rv = xdf_lb_getinfo(xsp->xdfss_tgt_dip,
                    TG_GETPHYGEOM, &pgeom, tg_cookie)) != 0)
                        goto out;
                capacity = pgeom.g_capacity;

                /*
                 * If the controller returned us something that doesn't
                 * really fit into an Int 13/function 8 geometry
                 * result, just fail the ioctl.  See PSARC 1998/313.
                 */
                if (capacity >= (63 * 254 * 1024)) {
                        rv = EINVAL;
                        goto out;
                }

                vgeomp = (cmlb_geom_t *)arg;
                vgeomp->g_capacity      = capacity;
                vgeomp->g_nsect         = 63;
                vgeomp->g_nhead         = 254;
                vgeomp->g_ncyl          = capacity / (63 * 254);
                vgeomp->g_acyl          = 0;
                vgeomp->g_secsize       = 512;
                vgeomp->g_intrlv        = 1;
                vgeomp->g_rpm           = 3600;
                rv = 0;
                goto out;
        }

        rv = xdf_lb_getinfo(xsp->xdfss_tgt_dip, cmd, arg, tg_cookie);

out:
        xdfs_tgt_release(xsp);
        return (rv);
}

static boolean_t
xdfs_isopen_part(xdfs_state_t *xsp, int part)
{
        int otyp;

        ASSERT(MUTEX_HELD(&xsp->xdfss_mutex));
        for (otyp = 0; (otyp < OTYPCNT); otyp++) {
                if (xsp->xdfss_otyp_count[otyp][part] != 0) {
                        ASSERT(xsp->xdfss_tgt_attached);
                        ASSERT(xsp->xdfss_tgt_holds >= 0);
                        return (B_TRUE);
                }
        }
        return (B_FALSE);
}

static boolean_t
xdfs_isopen(xdfs_state_t *xsp)
{
        int part;

        ASSERT(MUTEX_HELD(&xsp->xdfss_mutex));
        for (part = 0; part < XDF_PEXT; part++) {
                if (xdfs_isopen_part(xsp, part))
                        return (B_TRUE);
        }
        return (B_FALSE);
}

static int
xdfs_iodone(struct buf *bp)
{
        struct buf      *bp_orig = bp->b_chain;

        /* Propegate back the io results */
        bp_orig->b_resid = bp->b_resid;
        bioerror(bp_orig, geterror(bp));
        biodone(bp_orig);

        freerbuf(bp);
        return (0);
}

static int
xdfs_cmlb_attach(xdfs_state_t *xsp)
{
        return (cmlb_attach(xsp->xdfss_dip, &xdfs_lb_ops,
            xsp->xdfss_tgt_is_cd ? DTYPE_RODIRECT : DTYPE_DIRECT,
            xdf_is_rm(xsp->xdfss_tgt_dip),
            B_TRUE,
            xdfs_c_cmlb_node_type(xsp),
            xdfs_c_cmlb_alter_behavior(xsp),
            xsp->xdfss_cmlbhandle, 0));
}

static boolean_t
xdfs_tgt_probe(xdfs_state_t *xsp, dev_info_t *tgt_dip)
{
        cmlb_geom_t             pgeom;
        int                     tgt_instance = ddi_get_instance(tgt_dip);

        ASSERT(MUTEX_HELD(&xsp->xdfss_mutex));
        ASSERT(!xdfs_isopen(xsp));
        ASSERT(!xsp->xdfss_tgt_attached);

        xsp->xdfss_tgt_dip = tgt_dip;
        xsp->xdfss_tgt_holds = 0;
        xsp->xdfss_tgt_dev = makedevice(ddi_driver_major(tgt_dip),
            XDF_MINOR(tgt_instance, 0));
        ASSERT((xsp->xdfss_tgt_dev & XDF_PMASK) == 0);
        xsp->xdfss_tgt_is_cd = xdf_is_cd(tgt_dip);

        /*
         * GROSS HACK ALERT!  GROSS HACK ALERT!
         *
         * Before we can initialize the cmlb layer, we have to tell the
         * underlying xdf device what it's physical geometry should be.
         * See the block comments at the top of this file for more info.
         */
        if (!xsp->xdfss_tgt_is_cd &&
            ((xdfs_c_getpgeom(xsp->xdfss_dip, &pgeom) != 0) ||
            (xdf_hvm_setpgeom(xsp->xdfss_tgt_dip, &pgeom) != 0)))
                return (B_FALSE);

        /*
         * Force the xdf front end driver to connect to the backend.  From
         * the solaris device tree perspective, the xdf driver devinfo node
         * is already in the ATTACHED state.  (Otherwise xdf_hvm_hold()
         * would not have returned a dip.)  But this doesn't mean that the
         * xdf device has actually established a connection to it's back
         * end driver.  For us to be able to access the xdf device it needs
         * to be connected.
         */
        if (!xdf_hvm_connect(xsp->xdfss_tgt_dip)) {
                cmn_err(CE_WARN, "pv driver failed to connect: %s",
                    xsp->xdfss_pv);
                return (B_FALSE);
        }

        if (xsp->xdfss_tgt_is_cd && !xdf_media_req_supported(tgt_dip)) {
                /*
                 * Unfortunatly, the dom0 backend driver doesn't support
                 * important media request operations like eject, so fail
                 * the probe (this should cause us to fall back to emulated
                 * hvm device access, which does support things like eject).
                 */
                return (B_FALSE);
        }

        /* create kstat for iostat(1M) */
        if (xdf_kstat_create(xsp->xdfss_tgt_dip, (char *)xdfs_c_name,
            tgt_instance) != 0)
                return (B_FALSE);

        /*
         * Now we need to mark ourselves as attached and drop xdfss_mutex.
         * We do this because the final steps in the attach process will
         * need to access the underlying disk to read the label and
         * possibly the devid.
         */
        xsp->xdfss_tgt_attached = B_TRUE;
        mutex_exit(&xsp->xdfss_mutex);

        if (!xsp->xdfss_tgt_is_cd && xdfs_c_bb_check(xsp)) {
                cmn_err(CE_WARN, "pv disks with bad blocks are unsupported: %s",
                    xsp->xdfss_hvm);
                mutex_enter(&xsp->xdfss_mutex);
                xdf_kstat_delete(xsp->xdfss_tgt_dip);
                xsp->xdfss_tgt_attached = B_FALSE;
                return (B_FALSE);
        }

        /*
         * Initalize cmlb.  Note that for partition information cmlb
         * will access the underly xdf disk device directly via
         * xdfs_lb_rdwr() and xdfs_lb_getinfo().  There are no
         * layered driver handles associated with this access because
         * it is a direct disk access that doesn't go through
         * any of the device nodes exported by the xdf device (since
         * all exported device nodes only reflect the portion of
         * the device visible via the partition/slice that the node
         * is associated with.)  So while not observable via the LDI,
         * this direct disk access is ok since we're actually holding
         * the target device.
         */
        if (xdfs_cmlb_attach(xsp) != 0) {
                mutex_enter(&xsp->xdfss_mutex);
                xdf_kstat_delete(xsp->xdfss_tgt_dip);
                xsp->xdfss_tgt_attached = B_FALSE;
                return (B_FALSE);
        }

        /* setup devid string */
        xsp->xdfss_tgt_devid = NULL;
        if (!xsp->xdfss_tgt_is_cd)
                xdfs_c_devid_setup(xsp);

        (void) cmlb_validate(xsp->xdfss_cmlbhandle, 0, 0);

        /* Have the system report any newly created device nodes */
        ddi_report_dev(xsp->xdfss_dip);

        mutex_enter(&xsp->xdfss_mutex);
        return (B_TRUE);
}

static boolean_t
xdfs_tgt_detach(xdfs_state_t *xsp)
{
        ASSERT(MUTEX_HELD(&xsp->xdfss_mutex));
        ASSERT(xsp->xdfss_tgt_attached);
        ASSERT(xsp->xdfss_tgt_holds >= 0);

        if ((xdfs_isopen(xsp)) || (xsp->xdfss_tgt_holds != 0))
                return (B_FALSE);

        ddi_devid_unregister(xsp->xdfss_dip);
        if (xsp->xdfss_tgt_devid != NULL)
                ddi_devid_free(xsp->xdfss_tgt_devid);

        xdf_kstat_delete(xsp->xdfss_tgt_dip);
        xsp->xdfss_tgt_attached = B_FALSE;
        return (B_TRUE);
}

/*
 * Xdf_shell interfaces that may be called from outside this file.
 */
void
xdfs_minphys(struct buf *bp)
{
        xdfmin(bp);
}

/*
 * Cmlb ops vector, allows the cmlb module to directly access the entire
 * xdf disk device without going through any partitioning layers.
 */
int
xdfs_lb_rdwr(dev_info_t *dip, uchar_t cmd, void *bufaddr,
    diskaddr_t start, size_t count, void *tg_cookie)
{
        int             instance = ddi_get_instance(dip);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);
        int             rv;

        if (xsp == NULL)
                return (ENXIO);

        if (!xdfs_tgt_hold(xsp))
                return (ENXIO);

        rv = xdf_lb_rdwr(xsp->xdfss_tgt_dip,
            cmd, bufaddr, start, count, tg_cookie);

        xdfs_tgt_release(xsp);
        return (rv);
}

/*
 * Driver PV and HVM cb_ops entry points
 */
/*ARGSUSED*/
static int
xdfs_open(dev_t *dev_p, int flag, int otyp, cred_t *credp)
{
        ldi_ident_t     li;
        dev_t           dev = *dev_p;
        int             instance = XDFS_DEV2UNIT(dev);
        int             part = XDFS_DEV2PART(dev);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);
        dev_t           tgt_devt = xsp->xdfss_tgt_dev | part;
        int             err = 0;

        if ((otyp < 0) || (otyp >= OTYPCNT))
                return (EINVAL);

        if (XDFS_HVM_MODE(xsp)) {
                if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL))
                        return (ENOTSUP);
                return (xdfs_hvm_cb_ops->cb_open(dev_p, flag, otyp, credp));
        }

        /* allocate an ldi handle */
        VERIFY(ldi_ident_from_dev(*dev_p, &li) == 0);

        mutex_enter(&xsp->xdfss_mutex);

        /*
         * We translate all device opens (chr, blk, and lyr) into
         * block device opens.  Why?  Because for all the opens that
         * come through this driver, we only keep around one LDI handle.
         * So that handle can only be of one open type.  The reason
         * that we choose the block interface for this is that to use
         * the block interfaces for a device the system needs to allocate
         * buf_ts, which are associated with system memory which can act
         * as a cache for device data.  So normally when a block device
         * is closed the system will ensure that all these pages get
         * flushed out of memory.  But if we were to open the device
         * as a character device, then when we went to close the underlying
         * device (even if we had invoked the block interfaces) any data
         * remaining in memory wouldn't necessairly be flushed out
         * before the device was closed.
         */
        if (xsp->xdfss_tgt_lh[part] == NULL) {
                ASSERT(!xdfs_isopen_part(xsp, part));

                err = ldi_open_by_dev(&tgt_devt, OTYP_BLK, flag, credp,
                    &xsp->xdfss_tgt_lh[part], li);

                if (err != 0) {
                        mutex_exit(&xsp->xdfss_mutex);
                        ldi_ident_release(li);
                        return (err);
                }

                /* Disk devices really shouldn't clone */
                ASSERT(tgt_devt == (xsp->xdfss_tgt_dev | part));
        } else {
                ldi_handle_t lh_tmp;

                ASSERT(xdfs_isopen_part(xsp, part));

                /* do ldi open/close to get flags and cred check */
                err = ldi_open_by_dev(&tgt_devt, OTYP_BLK, flag, credp,
                    &lh_tmp, li);
                if (err != 0) {
                        mutex_exit(&xsp->xdfss_mutex);
                        ldi_ident_release(li);
                        return (err);
                }

                /* Disk devices really shouldn't clone */
                ASSERT(tgt_devt == (xsp->xdfss_tgt_dev | part));
                (void) ldi_close(lh_tmp, flag, credp);
        }
        ldi_ident_release(li);

        xsp->xdfss_otyp_count[otyp][part]++;

        mutex_exit(&xsp->xdfss_mutex);
        return (0);
}

/*ARGSUSED*/
static int
xdfs_close(dev_t dev, int flag, int otyp, cred_t *credp)
{
        int             instance = XDFS_DEV2UNIT(dev);
        int             part = XDFS_DEV2PART(dev);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);
        int             err = 0;

        ASSERT((otyp >= 0) && otyp < OTYPCNT);

        /* Sanity check the dev_t associated with this request. */
        ASSERT(getmajor(dev) == xdfs_major);
        if (getmajor(dev) != xdfs_major)
                return (ENXIO);

        if (XDFS_HVM_MODE(xsp)) {
                if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL))
                        return (ENOTSUP);
                return (xdfs_hvm_cb_ops->cb_close(dev, flag, otyp, credp));
        }

        /*
         * Sanity check that that the device is actually open.  On debug
         * kernels we'll panic and on non-debug kernels we'll return failure.
         */
        mutex_enter(&xsp->xdfss_mutex);
        ASSERT(xdfs_isopen_part(xsp, part));
        if (!xdfs_isopen_part(xsp, part)) {
                mutex_exit(&xsp->xdfss_mutex);
                return (ENXIO);
        }

        ASSERT(xsp->xdfss_tgt_lh[part] != NULL);
        ASSERT(xsp->xdfss_otyp_count[otyp][part] > 0);
        if (otyp == OTYP_LYR) {
                xsp->xdfss_otyp_count[otyp][part]--;
        } else {
                xsp->xdfss_otyp_count[otyp][part] = 0;
        }

        if (!xdfs_isopen_part(xsp, part)) {
                err = ldi_close(xsp->xdfss_tgt_lh[part], flag, credp);
                xsp->xdfss_tgt_lh[part] = NULL;
        }

        mutex_exit(&xsp->xdfss_mutex);

        return (err);
}

int
xdfs_strategy(struct buf *bp)
{
        dev_t           dev = bp->b_edev;
        int             instance = XDFS_DEV2UNIT(dev);
        int             part = XDFS_DEV2PART(dev);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);
        dev_t           tgt_devt;
        struct buf      *bp_clone;

        /* Sanity check the dev_t associated with this request. */
        ASSERT(getmajor(dev) == xdfs_major);
        if (getmajor(dev) != xdfs_major)
                goto err;

        if (XDFS_HVM_MODE(xsp)) {
                if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL))
                        return (ENOTSUP);
                return (xdfs_hvm_cb_ops->cb_strategy(bp));
        }

        /*
         * Sanity checks that the dev_t associated with the buf we were
         * passed corresponds to an open partition.  On debug kernels we'll
         * panic and on non-debug kernels we'll return failure.
         */
        mutex_enter(&xsp->xdfss_mutex);
        ASSERT(xdfs_isopen_part(xsp, part));
        if (!xdfs_isopen_part(xsp, part)) {
                mutex_exit(&xsp->xdfss_mutex);
                goto err;
        }
        mutex_exit(&xsp->xdfss_mutex);

        /* clone this buffer */
        tgt_devt = xsp->xdfss_tgt_dev | part;
        bp_clone = bioclone(bp, 0, bp->b_bcount, tgt_devt, bp->b_blkno,
            xdfs_iodone, NULL, KM_SLEEP);
        bp_clone->b_chain = bp;

        /*
         * If we're being invoked on behalf of the physio() call in
         * xdfs_dioctl_rwcmd() then b_private will be set to
         * XB_SLICE_NONE and we need to propegate this flag into the
         * cloned buffer so that the xdf driver will see it.
         */
        if (bp->b_private == (void *)XB_SLICE_NONE)
                bp_clone->b_private = (void *)XB_SLICE_NONE;

        /*
         * Pass on the cloned buffer.  Note that we don't bother to check
         * for failure because the xdf strategy routine will have to
         * invoke biodone() if it wants to return an error, which means
         * that the xdfs_iodone() callback will get invoked and it
         * will propegate the error back up the stack and free the cloned
         * buffer.
         */
        ASSERT(xsp->xdfss_tgt_lh[part] != NULL);
        return (ldi_strategy(xsp->xdfss_tgt_lh[part], bp_clone));

err:
        bioerror(bp, ENXIO);
        bp->b_resid = bp->b_bcount;
        biodone(bp);
        return (0);
}

static int
xdfs_dump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk)
{
        int             instance = XDFS_DEV2UNIT(dev);
        int             part = XDFS_DEV2PART(dev);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);

        if (!XDFS_HVM_MODE(xsp))
                return (ldi_dump(xsp->xdfss_tgt_lh[part], addr, blkno, nblk));

        if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL))
                return (ENOTSUP);
        return (xdfs_hvm_cb_ops->cb_dump(dev, addr, blkno, nblk));
}

/*ARGSUSED*/
static int
xdfs_read(dev_t dev, struct uio *uio, cred_t *credp)
{
        int             instance = XDFS_DEV2UNIT(dev);
        int             part = XDFS_DEV2PART(dev);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);

        if (!XDFS_HVM_MODE(xsp))
                return (ldi_read(xsp->xdfss_tgt_lh[part], uio, credp));

        if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL))
                return (ENOTSUP);
        return (xdfs_hvm_cb_ops->cb_read(dev, uio, credp));
}

/*ARGSUSED*/
static int
xdfs_write(dev_t dev, struct uio *uio, cred_t *credp)
{
        int             instance = XDFS_DEV2UNIT(dev);
        int             part = XDFS_DEV2PART(dev);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);

        if (!XDFS_HVM_MODE(xsp))
                return (ldi_write(xsp->xdfss_tgt_lh[part], uio, credp));

        if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL))
                return (ENOTSUP);
        return (xdfs_hvm_cb_ops->cb_write(dev, uio, credp));
}

/*ARGSUSED*/
static int
xdfs_aread(dev_t dev, struct aio_req *aio, cred_t *credp)
{
        int             instance = XDFS_DEV2UNIT(dev);
        int             part = XDFS_DEV2PART(dev);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);

        if (!XDFS_HVM_MODE(xsp))
                return (ldi_aread(xsp->xdfss_tgt_lh[part], aio, credp));

        if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL) ||
            (xdfs_hvm_cb_ops->cb_strategy == NULL) ||
            (xdfs_hvm_cb_ops->cb_strategy == nodev) ||
            (xdfs_hvm_cb_ops->cb_aread == NULL))
                return (ENOTSUP);
        return (xdfs_hvm_cb_ops->cb_aread(dev, aio, credp));
}

/*ARGSUSED*/
static int
xdfs_awrite(dev_t dev, struct aio_req *aio, cred_t *credp)
{
        int             instance = XDFS_DEV2UNIT(dev);
        int             part = XDFS_DEV2PART(dev);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);

        if (!XDFS_HVM_MODE(xsp))
                return (ldi_awrite(xsp->xdfss_tgt_lh[part], aio, credp));

        if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL) ||
            (xdfs_hvm_cb_ops->cb_strategy == NULL) ||
            (xdfs_hvm_cb_ops->cb_strategy == nodev) ||
            (xdfs_hvm_cb_ops->cb_awrite == NULL))
                return (ENOTSUP);
        return (xdfs_hvm_cb_ops->cb_awrite(dev, aio, credp));
}

static int
xdfs_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *credp,
    int *rvalp)
{
        int             instance = XDFS_DEV2UNIT(dev);
        int             part = XDFS_DEV2PART(dev);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);
        int             rv;
        boolean_t       done;

        if (XDFS_HVM_MODE(xsp)) {
                if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL))
                        return (ENOTSUP);
                return (xdfs_hvm_cb_ops->cb_ioctl(
                    dev, cmd, arg, flag, credp, rvalp));
        }

        rv = xdfs_c_ioctl(xsp, dev, part, cmd, arg, flag, credp, rvalp, &done);
        if (done)
                return (rv);
        rv = ldi_ioctl(xsp->xdfss_tgt_lh[part], cmd, arg, flag, credp, rvalp);
        if (rv == 0) {
                /* Force Geometry Validation */
                (void) cmlb_invalidate(xsp->xdfss_cmlbhandle, 0);
                (void) cmlb_validate(xsp->xdfss_cmlbhandle, 0, 0);
        }
        return (rv);
}

static int
xdfs_hvm_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
    int flags, char *name, caddr_t valuep, int *lengthp)
{
        int             instance = ddi_get_instance(dip);
        void            *xsp = ddi_get_soft_state(xdfs_ssp, instance);

        ASSERT(XDFS_HVM_MODE(xsp));

        if ((xdfs_hvm_dev_ops == NULL) || (xdfs_hvm_cb_ops == NULL) ||
            (xdfs_hvm_cb_ops->cb_prop_op == NULL) ||
            (xdfs_hvm_cb_ops->cb_prop_op == nodev) ||
            (xdfs_hvm_cb_ops->cb_prop_op == nulldev))
                return (DDI_PROP_NOT_FOUND);

        return (xdfs_hvm_cb_ops->cb_prop_op(dev, dip, prop_op,
            flags, name, valuep, lengthp));
}

static int
xdfs_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
    int flags, char *name, caddr_t valuep, int *lengthp)
{
        int             instance = ddi_get_instance(dip);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);
        int             rv;
        dev_info_t      *tgt_dip;
        dev_t           tgt_devt;

        /*
         * Sanity check that if a dev_t or dip were specified that they
         * correspond to this device driver.  On debug kernels we'll
         * panic and on non-debug kernels we'll return failure.
         */
        ASSERT(ddi_driver_major(dip) == xdfs_major);
        ASSERT((dev == DDI_DEV_T_ANY) || (getmajor(dev) == xdfs_major));
        if ((ddi_driver_major(dip) != xdfs_major) ||
            ((dev != DDI_DEV_T_ANY) && (getmajor(dev) != xdfs_major)))
                return (DDI_PROP_NOT_FOUND);

        /*
         * This property lookup might be associated with a device node
         * that is not yet attached, if so pass it onto ddi_prop_op().
         */
        if (xsp == NULL)
                return (ddi_prop_op(dev, dip, prop_op, flags,
                    name, valuep, lengthp));

        /* If we're accessing the device in hvm mode, pass this request on */
        if (XDFS_HVM_MODE(xsp))
                return (xdfs_hvm_prop_op(dev, dip, prop_op,
                    flags, name, valuep, lengthp));

        /*
         * Make sure we only lookup static properties.
         *
         * If there are static properties of the underlying xdf driver
         * that we want to mirror, then we'll have to explicity look them
         * up and define them during attach.  There are a few reasons
         * for this.  Most importantly, most static properties are typed
         * and all dynamic properties are untyped, ie, for dynamic
         * properties the caller must know the type of the property and
         * how to interpret the value of the property.  the prop_op drivedr
         * entry point is only designed for returning dynamic/untyped
         * properties, so if we were to attempt to lookup and pass back
         * static properties of the underlying device here then we would
         * be losing the type information for those properties.  Another
         * reason we don't want to pass on static property requests is that
         * static properties are enumerable in the device tree, where as
         * dynamic ones are not.
         */
        flags |= DDI_PROP_DYNAMIC;

        /*
         * We can't use the ldi here to access the underlying device because
         * the ldi actually opens the device, and that open might fail if the
         * device has already been opened with the FEXCL flag.  If we used
         * the ldi here, it would also be possible for some other caller to
         * try open the device with the FEXCL flag and get a failure back
         * because we have it open to do a property query.  Instad we'll
         * grab a hold on the target dip.
         */
        if (!xdfs_tgt_hold(xsp))
                return (DDI_PROP_NOT_FOUND);

        /* figure out dip the dev_t we're going to pass on down */
        tgt_dip = xsp->xdfss_tgt_dip;
        if (dev == DDI_DEV_T_ANY) {
                tgt_devt = DDI_DEV_T_ANY;
        } else {
                tgt_devt = xsp->xdfss_tgt_dev | XDFS_DEV2PART(dev);
        }

        /*
         * Cdev_prop_op() is not a public interface, and normally the caller
         * is required to make sure that the target driver actually implements
         * this interface before trying to invoke it.  In this case we know
         * that we're always accessing the xdf driver and it does have this
         * interface defined, so we can skip the check.
         */
        rv = cdev_prop_op(tgt_devt, tgt_dip,
            prop_op, flags, name, valuep, lengthp);

        xdfs_tgt_release(xsp);
        return (rv);
}

/*
 * Driver PV and HVM dev_ops entry points
 */
/*ARGSUSED*/
static int
xdfs_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
    void **result)
{
        dev_t           dev = (dev_t)arg;
        int             instance = XDFS_DEV2UNIT(dev);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);

        switch (infocmd) {
                case DDI_INFO_DEVT2DEVINFO:
                        if (xsp == NULL)
                                return (DDI_FAILURE);
                        if (XDFS_HVM_MODE(xsp))
                                *result = XDFS_HVM_DIP(xsp);
                        else
                                *result = (void *)xsp->xdfss_dip;
                        break;
                case DDI_INFO_DEVT2INSTANCE:
                        *result = (void *)(intptr_t)instance;
                        break;
                default:
                        return (DDI_FAILURE);
        }
        return (DDI_SUCCESS);
}

static int
xdfs_hvm_probe(dev_info_t *dip, char *path)
{
        int             instance = ddi_get_instance(dip);
        int             rv = DDI_PROBE_SUCCESS;
        void            *xsp;

        ASSERT(path != NULL);
        cmn_err(CE_WARN, "PV access to device disabled: %s", path);

        (void) ddi_soft_state_zalloc(xdfs_ssp, instance);
        VERIFY((xsp = ddi_get_soft_state(xdfs_ssp, instance)) != NULL);

        if ((xdfs_hvm_dev_ops == NULL) ||
            (xdfs_hvm_dev_ops->devo_probe == NULL) ||
            ((rv = xdfs_hvm_dev_ops->devo_probe(dip)) == DDI_PROBE_FAILURE)) {
                ddi_soft_state_free(xdfs_ssp, instance);
                cmn_err(CE_WARN, "HVM probe of device failed: %s", path);
                kmem_free(path, MAXPATHLEN);
                return (DDI_PROBE_FAILURE);
        }

        XDFS_HVM_MODE(xsp) = B_TRUE;
        XDFS_HVM_DIP(xsp) = dip;
        XDFS_HVM_PATH(xsp) = path;

        return (rv);
}

static int
xdfs_probe(dev_info_t *dip)
{
        int             instance = ddi_get_instance(dip);
        xdfs_state_t    *xsp;
        dev_info_t      *tgt_dip;
        char            *path;
        int             i, pv_disable;

        /* if we've already probed the device then there's nothing todo */
        if (ddi_get_soft_state(xdfs_ssp, instance))
                return (DDI_PROBE_PARTIAL);

        /* Figure out our pathname */
        path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
        (void) ddi_pathname(dip, path);

        /* see if we should disable pv access mode */
        pv_disable = ddi_prop_get_int(DDI_DEV_T_ANY,
            dip, DDI_PROP_NOTPROM, "pv_disable", 0);

        if (xdfs_pv_disable || pv_disable)
                return (xdfs_hvm_probe(dip, path));

        /*
         * This xdf shell device layers on top of an xdf device.  So the first
         * thing we need to do is determine which xdf device instance this
         * xdf shell instance should be layered on top of.
         */
        for (i = 0; xdfs_c_h2p_map[i].xdfs_h2p_hvm != NULL; i++) {
                if (strcmp(xdfs_c_h2p_map[i].xdfs_h2p_hvm, path) == 0)
                        break;
        }

        if ((xdfs_c_h2p_map[i].xdfs_h2p_hvm == NULL) ||
            ((tgt_dip = xdf_hvm_hold(xdfs_c_h2p_map[i].xdfs_h2p_pv)) == NULL)) {
                /*
                 * UhOh.  We either don't know what xdf instance this xdf
                 * shell device should be mapped to or the xdf node assocaited
                 * with this instance isnt' attached.  in either case fall
                 * back to hvm access.
                 */
                return (xdfs_hvm_probe(dip, path));
        }

        /* allocate and initialize our state structure */
        (void) ddi_soft_state_zalloc(xdfs_ssp, instance);
        xsp = ddi_get_soft_state(xdfs_ssp, instance);
        mutex_init(&xsp->xdfss_mutex, NULL, MUTEX_DRIVER, NULL);
        cv_init(&xsp->xdfss_cv, NULL, CV_DEFAULT, NULL);
        mutex_enter(&xsp->xdfss_mutex);

        xsp->xdfss_dip = dip;
        xsp->xdfss_pv = xdfs_c_h2p_map[i].xdfs_h2p_pv;
        xsp->xdfss_hvm = xdfs_c_h2p_map[i].xdfs_h2p_hvm;
        xsp->xdfss_tgt_attached = B_FALSE;
        cmlb_alloc_handle((cmlb_handle_t *)&xsp->xdfss_cmlbhandle);

        if (!xdfs_tgt_probe(xsp, tgt_dip)) {
                mutex_exit(&xsp->xdfss_mutex);
                cmlb_free_handle(&xsp->xdfss_cmlbhandle);
                ddi_soft_state_free(xdfs_ssp, instance);
                ddi_release_devi(tgt_dip);
                return (xdfs_hvm_probe(dip, path));
        }
        mutex_exit(&xsp->xdfss_mutex);

        /*
         * Add a zero-length attribute to tell the world we support
         * kernel ioctls (for layered drivers).
         */
        (void) ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP,
            DDI_KERNEL_IOCTL, NULL, 0);

        kmem_free(path, MAXPATHLEN);
        return (DDI_PROBE_SUCCESS);
}

static int
xdfs_hvm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        int             instance = ddi_get_instance(dip);
        void            *xsp = ddi_get_soft_state(xdfs_ssp, instance);
        int             rv = DDI_FAILURE;

        XDFS_HVM_SANE(xsp);

        if ((xdfs_hvm_dev_ops == NULL) ||
            (xdfs_hvm_dev_ops->devo_attach == NULL) ||
            ((rv = xdfs_hvm_dev_ops->devo_attach(dip, cmd)) != DDI_SUCCESS)) {
                cmn_err(CE_WARN, "HVM attach of device failed: %s",
                    XDFS_HVM_PATH(xsp));
                kmem_free(XDFS_HVM_PATH(xsp), MAXPATHLEN);
                ddi_soft_state_free(xdfs_ssp, instance);
                return (rv);
        }

        return (DDI_SUCCESS);
}

/*
 * Autoconfiguration Routines
 */
static int
xdfs_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        int             instance = ddi_get_instance(dip);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);

        if (xsp == NULL)
                return (DDI_FAILURE);
        if (XDFS_HVM_MODE(xsp))
                return (xdfs_hvm_attach(dip, cmd));
        if (cmd != DDI_ATTACH)
                return (DDI_FAILURE);

        xdfs_c_attach(xsp);
        return (DDI_SUCCESS);
}

static int
xdfs_hvm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        int             instance = ddi_get_instance(dip);
        void            *xsp = ddi_get_soft_state(xdfs_ssp, instance);
        int             rv;

        XDFS_HVM_SANE(xsp);

        if ((xdfs_hvm_dev_ops == NULL) ||
            (xdfs_hvm_dev_ops->devo_detach == NULL))
                return (DDI_FAILURE);

        if ((rv = xdfs_hvm_dev_ops->devo_detach(dip, cmd)) != DDI_SUCCESS)
                return (rv);

        kmem_free(XDFS_HVM_PATH(xsp), MAXPATHLEN);
        ddi_soft_state_free(xdfs_ssp, instance);
        return (DDI_SUCCESS);
}

static int
xdfs_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        int             instance = ddi_get_instance(dip);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);

        if (XDFS_HVM_MODE(xsp))
                return (xdfs_hvm_detach(dip, cmd));
        if (cmd != DDI_DETACH)
                return (DDI_FAILURE);

        mutex_enter(&xsp->xdfss_mutex);
        if (!xdfs_tgt_detach(xsp)) {
                mutex_exit(&xsp->xdfss_mutex);
                return (DDI_FAILURE);
        }
        mutex_exit(&xsp->xdfss_mutex);

        cmlb_detach(xsp->xdfss_cmlbhandle, 0);
        cmlb_free_handle(&xsp->xdfss_cmlbhandle);
        ddi_release_devi(xsp->xdfss_tgt_dip);
        ddi_soft_state_free(xdfs_ssp, instance);
        ddi_prop_remove_all(dip);
        return (DDI_SUCCESS);
}

static int
xdfs_hvm_power(dev_info_t *dip, int component, int level)
{
        int             instance = ddi_get_instance(dip);
        void            *xsp = ddi_get_soft_state(xdfs_ssp, instance);

        XDFS_HVM_SANE(xsp);

        if ((xdfs_hvm_dev_ops == NULL) ||
            (xdfs_hvm_dev_ops->devo_power == NULL))
                return (DDI_FAILURE);
        return (xdfs_hvm_dev_ops->devo_power(dip, component, level));
}

static int
xdfs_power(dev_info_t *dip, int component, int level)
{
        int             instance = ddi_get_instance(dip);
        xdfs_state_t    *xsp = ddi_get_soft_state(xdfs_ssp, instance);

        if (XDFS_HVM_MODE(xsp))
                return (xdfs_hvm_power(dip, component, level));
        return (nodev());
}

/*
 * Cmlb ops vector
 */
static cmlb_tg_ops_t xdfs_lb_ops = {
        TG_DK_OPS_VERSION_1,
        xdfs_lb_rdwr,
        xdfs_lb_getinfo
};

/*
 * Device driver ops vector
 */
static struct cb_ops xdfs_cb_ops = {
        xdfs_open,              /* open */
        xdfs_close,             /* close */
        xdfs_strategy,          /* strategy */
        nodev,                  /* print */
        xdfs_dump,              /* dump */
        xdfs_read,              /* read */
        xdfs_write,             /* write */
        xdfs_ioctl,             /* ioctl */
        nodev,                  /* devmap */
        nodev,                  /* mmap */
        nodev,                  /* segmap */
        nochpoll,               /* poll */
        xdfs_prop_op,           /* cb_prop_op */
        0,                      /* streamtab  */
        D_64BIT | D_MP | D_NEW, /* Driver comaptibility flag */
        CB_REV,                 /* cb_rev */
        xdfs_aread,             /* async read */
        xdfs_awrite             /* async write */
};

struct dev_ops xdfs_ops = {
        DEVO_REV,               /* devo_rev, */
        0,                      /* refcnt  */
        xdfs_getinfo,           /* info */
        nulldev,                /* identify */
        xdfs_probe,             /* probe */
        xdfs_attach,            /* attach */
        xdfs_detach,            /* detach */
        nodev,                  /* reset */
        &xdfs_cb_ops,           /* driver operations */
        NULL,                   /* bus operations */
        xdfs_power,             /* power */
        ddi_quiesce_not_supported, /* devo_quiesce */
};

/*
 * Module linkage information for the kernel.
 */
static struct modldrv modldrv = {
        &mod_driverops,         /* Type of module.  This one is a driver. */
        NULL,                   /* Module description.  Set by _init() */
        &xdfs_ops,              /* Driver ops. */
};

static struct modlinkage modlinkage = {
        MODREV_1, (void *)&modldrv, NULL
};

int
_init(void)
{
        int rval;

        xdfs_major = ddi_name_to_major((char *)xdfs_c_name);
        if (xdfs_major == (major_t)-1)
                return (EINVAL);

        /*
         * Determine the size of our soft state structure.  The base
         * size of the structure is the larger of the hvm clients state
         * structure, or our shell state structure.  Then we'll align
         * the end of the structure to a pointer boundry and append
         * a xdfs_hvm_state_t structure.  This way the xdfs_hvm_state_t
         * structure is always present and we can use it to determine the
         * current device access mode (hvm or shell).
         */
        xdfs_ss_size = MAX(xdfs_c_hvm_ss_size, sizeof (xdfs_state_t));
        xdfs_ss_size = P2ROUNDUP(xdfs_ss_size, sizeof (uintptr_t));
        xdfs_ss_size += sizeof (xdfs_hvm_state_t);

        /*
         * In general ide usually supports 4 disk devices, this same
         * limitation also applies to software emulating ide devices.
         * so by default we pre-allocate 4 xdf shell soft state structures.
         */
        if ((rval = ddi_soft_state_init(&xdfs_ssp,
            xdfs_ss_size, XDFS_NODES)) != 0)
                return (rval);
        *xdfs_c_hvm_ss = xdfs_ssp;

        /* Install our module */
        if (modldrv.drv_linkinfo == NULL)
                modldrv.drv_linkinfo = (char *)xdfs_c_linkinfo;
        if ((rval = mod_install(&modlinkage)) != 0) {
                ddi_soft_state_fini(&xdfs_ssp);
                return (rval);
        }

        return (0);
}

int
_info(struct modinfo *modinfop)
{
        if (modldrv.drv_linkinfo == NULL)
                modldrv.drv_linkinfo = (char *)xdfs_c_linkinfo;
        return (mod_info(&modlinkage, modinfop));
}

int
_fini(void)
{
        int     rval;
        if ((rval = mod_remove(&modlinkage)) != 0)
                return (rval);
        ddi_soft_state_fini(&xdfs_ssp);
        return (0);
}