Merge remote-tracking branch 'origin/master'

[unleashed/lotheac.git] / usr / src / uts / common / io / cmlb.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 2012 DEY Storage Systems, Inc.  All rights reserved.
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2016 Toomas Soome <tsoome@me.com>
 */

/*
 * This module provides support for labeling operations for target
 * drivers.
 */

#include <sys/scsi/scsi.h>
#include <sys/sunddi.h>
#include <sys/dklabel.h>
#include <sys/dkio.h>
#include <sys/vtoc.h>
#include <sys/dktp/fdisk.h>
#include <sys/vtrace.h>
#include <sys/efi_partition.h>
#include <sys/cmlb.h>
#include <sys/cmlb_impl.h>
#if defined(__i386) || defined(__amd64)
#include <sys/fs/dv_node.h>
#endif
#include <sys/ddi_impldefs.h>

/*
 * Driver minor node structure and data table
 */
struct driver_minor_data {
        char    *name;
        minor_t minor;
        int     type;
};

static struct driver_minor_data dk_minor_data[] = {
        {"a", 0, S_IFBLK},
        {"b", 1, S_IFBLK},
        {"c", 2, S_IFBLK},
        {"d", 3, S_IFBLK},
        {"e", 4, S_IFBLK},
        {"f", 5, S_IFBLK},
        {"g", 6, S_IFBLK},
        {"h", 7, S_IFBLK},
#if defined(_SUNOS_VTOC_16)
        {"i", 8, S_IFBLK},
        {"j", 9, S_IFBLK},
        {"k", 10, S_IFBLK},
        {"l", 11, S_IFBLK},
        {"m", 12, S_IFBLK},
        {"n", 13, S_IFBLK},
        {"o", 14, S_IFBLK},
        {"p", 15, S_IFBLK},
#endif                  /* defined(_SUNOS_VTOC_16) */
#if defined(_FIRMWARE_NEEDS_FDISK)
        {"q", 16, S_IFBLK},
        {"r", 17, S_IFBLK},
        {"s", 18, S_IFBLK},
        {"t", 19, S_IFBLK},
        {"u", 20, S_IFBLK},
#endif                  /* defined(_FIRMWARE_NEEDS_FDISK) */
        {"a,raw", 0, S_IFCHR},
        {"b,raw", 1, S_IFCHR},
        {"c,raw", 2, S_IFCHR},
        {"d,raw", 3, S_IFCHR},
        {"e,raw", 4, S_IFCHR},
        {"f,raw", 5, S_IFCHR},
        {"g,raw", 6, S_IFCHR},
        {"h,raw", 7, S_IFCHR},
#if defined(_SUNOS_VTOC_16)
        {"i,raw", 8, S_IFCHR},
        {"j,raw", 9, S_IFCHR},
        {"k,raw", 10, S_IFCHR},
        {"l,raw", 11, S_IFCHR},
        {"m,raw", 12, S_IFCHR},
        {"n,raw", 13, S_IFCHR},
        {"o,raw", 14, S_IFCHR},
        {"p,raw", 15, S_IFCHR},
#endif                  /* defined(_SUNOS_VTOC_16) */
#if defined(_FIRMWARE_NEEDS_FDISK)
        {"q,raw", 16, S_IFCHR},
        {"r,raw", 17, S_IFCHR},
        {"s,raw", 18, S_IFCHR},
        {"t,raw", 19, S_IFCHR},
        {"u,raw", 20, S_IFCHR},
#endif                  /* defined(_FIRMWARE_NEEDS_FDISK) */
        {0}
};

#if defined(__i386) || defined(__amd64)
#if defined(_FIRMWARE_NEEDS_FDISK)
static struct driver_minor_data dk_ext_minor_data[] = {
        {"p5", 21, S_IFBLK},
        {"p6", 22, S_IFBLK},
        {"p7", 23, S_IFBLK},
        {"p8", 24, S_IFBLK},
        {"p9", 25, S_IFBLK},
        {"p10", 26, S_IFBLK},
        {"p11", 27, S_IFBLK},
        {"p12", 28, S_IFBLK},
        {"p13", 29, S_IFBLK},
        {"p14", 30, S_IFBLK},
        {"p15", 31, S_IFBLK},
        {"p16", 32, S_IFBLK},
        {"p17", 33, S_IFBLK},
        {"p18", 34, S_IFBLK},
        {"p19", 35, S_IFBLK},
        {"p20", 36, S_IFBLK},
        {"p21", 37, S_IFBLK},
        {"p22", 38, S_IFBLK},
        {"p23", 39, S_IFBLK},
        {"p24", 40, S_IFBLK},
        {"p25", 41, S_IFBLK},
        {"p26", 42, S_IFBLK},
        {"p27", 43, S_IFBLK},
        {"p28", 44, S_IFBLK},
        {"p29", 45, S_IFBLK},
        {"p30", 46, S_IFBLK},
        {"p31", 47, S_IFBLK},
        {"p32", 48, S_IFBLK},
        {"p33", 49, S_IFBLK},
        {"p34", 50, S_IFBLK},
        {"p35", 51, S_IFBLK},
        {"p36", 52, S_IFBLK},
        {"p5,raw", 21, S_IFCHR},
        {"p6,raw", 22, S_IFCHR},
        {"p7,raw", 23, S_IFCHR},
        {"p8,raw", 24, S_IFCHR},
        {"p9,raw", 25, S_IFCHR},
        {"p10,raw", 26, S_IFCHR},
        {"p11,raw", 27, S_IFCHR},
        {"p12,raw", 28, S_IFCHR},
        {"p13,raw", 29, S_IFCHR},
        {"p14,raw", 30, S_IFCHR},
        {"p15,raw", 31, S_IFCHR},
        {"p16,raw", 32, S_IFCHR},
        {"p17,raw", 33, S_IFCHR},
        {"p18,raw", 34, S_IFCHR},
        {"p19,raw", 35, S_IFCHR},
        {"p20,raw", 36, S_IFCHR},
        {"p21,raw", 37, S_IFCHR},
        {"p22,raw", 38, S_IFCHR},
        {"p23,raw", 39, S_IFCHR},
        {"p24,raw", 40, S_IFCHR},
        {"p25,raw", 41, S_IFCHR},
        {"p26,raw", 42, S_IFCHR},
        {"p27,raw", 43, S_IFCHR},
        {"p28,raw", 44, S_IFCHR},
        {"p29,raw", 45, S_IFCHR},
        {"p30,raw", 46, S_IFCHR},
        {"p31,raw", 47, S_IFCHR},
        {"p32,raw", 48, S_IFCHR},
        {"p33,raw", 49, S_IFCHR},
        {"p34,raw", 50, S_IFCHR},
        {"p35,raw", 51, S_IFCHR},
        {"p36,raw", 52, S_IFCHR},
        {0}
};
#endif                  /* defined(_FIRMWARE_NEEDS_FDISK) */
#endif                  /* if defined(__i386) || defined(__amd64) */

static struct driver_minor_data dk_minor_data_efi[] = {
        {"a", 0, S_IFBLK},
        {"b", 1, S_IFBLK},
        {"c", 2, S_IFBLK},
        {"d", 3, S_IFBLK},
        {"e", 4, S_IFBLK},
        {"f", 5, S_IFBLK},
        {"g", 6, S_IFBLK},
        {"wd", 7, S_IFBLK},
#if defined(_SUNOS_VTOC_16)
        {"i", 8, S_IFBLK},
        {"j", 9, S_IFBLK},
        {"k", 10, S_IFBLK},
        {"l", 11, S_IFBLK},
        {"m", 12, S_IFBLK},
        {"n", 13, S_IFBLK},
        {"o", 14, S_IFBLK},
        {"p", 15, S_IFBLK},
#endif                  /* defined(_SUNOS_VTOC_16) */
#if defined(_FIRMWARE_NEEDS_FDISK)
        {"q", 16, S_IFBLK},
        {"r", 17, S_IFBLK},
        {"s", 18, S_IFBLK},
        {"t", 19, S_IFBLK},
        {"u", 20, S_IFBLK},
#endif                  /* defined(_FIRMWARE_NEEDS_FDISK) */
        {"a,raw", 0, S_IFCHR},
        {"b,raw", 1, S_IFCHR},
        {"c,raw", 2, S_IFCHR},
        {"d,raw", 3, S_IFCHR},
        {"e,raw", 4, S_IFCHR},
        {"f,raw", 5, S_IFCHR},
        {"g,raw", 6, S_IFCHR},
        {"wd,raw", 7, S_IFCHR},
#if defined(_SUNOS_VTOC_16)
        {"i,raw", 8, S_IFCHR},
        {"j,raw", 9, S_IFCHR},
        {"k,raw", 10, S_IFCHR},
        {"l,raw", 11, S_IFCHR},
        {"m,raw", 12, S_IFCHR},
        {"n,raw", 13, S_IFCHR},
        {"o,raw", 14, S_IFCHR},
        {"p,raw", 15, S_IFCHR},
#endif                  /* defined(_SUNOS_VTOC_16) */
#if defined(_FIRMWARE_NEEDS_FDISK)
        {"q,raw", 16, S_IFCHR},
        {"r,raw", 17, S_IFCHR},
        {"s,raw", 18, S_IFCHR},
        {"t,raw", 19, S_IFCHR},
        {"u,raw", 20, S_IFCHR},
#endif                  /* defined(_FIRMWARE_NEEDS_FDISK) */
        {0}
};

/*
 * Declare the dynamic properties implemented in prop_op(9E) implementation
 * that we want to have show up in a di_init(3DEVINFO) device tree snapshot
 * of drivers that call cmlb_attach().
 */
static i_ddi_prop_dyn_t cmlb_prop_dyn[] = {
        {"Nblocks",             DDI_PROP_TYPE_INT64,    S_IFBLK},
        {"Size",                DDI_PROP_TYPE_INT64,    S_IFCHR},
        {"device-nblocks",      DDI_PROP_TYPE_INT64},
        {"device-blksize",      DDI_PROP_TYPE_INT},
        {"device-solid-state",  DDI_PROP_TYPE_INT},
        {"device-rotational",   DDI_PROP_TYPE_INT},
        {NULL}
};

/*
 * This implies an upper limit of 8192 GPT partitions
 * in one transfer for GUID Partition Entry Array.
 */
len_t cmlb_tg_max_efi_xfer = 1024 * 1024;

/*
 * External kernel interfaces
 */
extern struct mod_ops mod_miscops;

extern int ddi_create_internal_pathname(dev_info_t *dip, char *name,
    int spec_type, minor_t minor_num);

/*
 * Global buffer and mutex for debug logging
 */
static char     cmlb_log_buffer[1024];
static kmutex_t cmlb_log_mutex;


struct cmlb_lun *cmlb_debug_cl = NULL;
uint_t cmlb_level_mask = 0x0;

int cmlb_rot_delay = 4; /* default rotational delay */

static struct modlmisc modlmisc = {
        &mod_miscops,   /* Type of module */
        "Common Labeling module"
};

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

/* Local function prototypes */
static dev_t cmlb_make_device(struct cmlb_lun *cl);
static int cmlb_validate_geometry(struct cmlb_lun *cl, boolean_t forcerevalid,
    int flags, void *tg_cookie);
static void cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity,
    void *tg_cookie);
static int cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity,
    void *tg_cookie);
static void cmlb_swap_efi_gpt(efi_gpt_t *e);
static void cmlb_swap_efi_gpe(int nparts, efi_gpe_t *p);
static int cmlb_validate_efi(efi_gpt_t *labp);
static int cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags,
    void *tg_cookie);
static void cmlb_build_default_label(struct cmlb_lun *cl, void *tg_cookie);
static int  cmlb_uselabel(struct cmlb_lun *cl,  struct dk_label *l, int flags);
#if defined(_SUNOS_VTOC_8)
static void cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc);
#endif
static int cmlb_build_label_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc);
static int cmlb_write_label(struct cmlb_lun *cl, void *tg_cookie);
static int cmlb_set_vtoc(struct cmlb_lun *cl, struct dk_label *dkl,
    void *tg_cookie);
static void cmlb_clear_efi(struct cmlb_lun *cl, void *tg_cookie);
static void cmlb_clear_vtoc(struct cmlb_lun *cl, void *tg_cookie);
static void cmlb_setup_default_geometry(struct cmlb_lun *cl, void *tg_cookie);
static int cmlb_create_minor_nodes(struct cmlb_lun *cl);
static int cmlb_check_update_blockcount(struct cmlb_lun *cl, void *tg_cookie);
static boolean_t cmlb_check_efi_mbr(uchar_t *buf, boolean_t *is_mbr);

#if defined(__i386) || defined(__amd64)
static int cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie);
#endif

#if defined(_FIRMWARE_NEEDS_FDISK)
static boolean_t  cmlb_has_max_chs_vals(struct ipart *fdp);
#endif

#if defined(_SUNOS_VTOC_16)
static void cmlb_convert_geometry(struct cmlb_lun *cl, diskaddr_t capacity,
    struct dk_geom *cl_g, void *tg_cookie);
#endif

static int cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag,
    void *tg_cookie);
static int cmlb_dkio_set_geometry(struct cmlb_lun *cl, caddr_t arg, int flag);
static int cmlb_dkio_get_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
    void *tg_cookie);
static int cmlb_dkio_set_partition(struct cmlb_lun *cl, caddr_t arg, int flag);
static int cmlb_dkio_get_efi(struct cmlb_lun *cl, caddr_t arg, int flag,
    void *tg_cookie);
static int cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
    int flag, void *tg_cookie);
static int cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
    void *tg_cookie);
static int cmlb_dkio_get_extvtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
    void *tg_cookie);
static int cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
    int flag, void *tg_cookie);
static int cmlb_dkio_set_extvtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
    int flag, void *tg_cookie);
static int cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag,
    void *tg_cookie);
static int cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag,
    void *tg_cookie);
static int cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
    void *tg_cookie);

#if defined(__i386) || defined(__amd64)
static int cmlb_dkio_set_ext_part(struct cmlb_lun *cl, caddr_t arg, int flag,
    void *tg_cookie);
static int cmlb_validate_ext_part(struct cmlb_lun *cl, int part, int epart,
    uint32_t start, uint32_t size);
static int cmlb_is_linux_swap(struct cmlb_lun *cl, uint32_t part_start,
    void *tg_cookie);
static int cmlb_dkio_get_virtgeom(struct cmlb_lun *cl, caddr_t arg, int flag);
static int cmlb_dkio_get_phygeom(struct cmlb_lun *cl, caddr_t  arg, int flag,
    void *tg_cookie);
static int cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
    int flag);
static int cmlb_dkio_extpartinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
    int flag);
#endif

static void cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...);
static void cmlb_v_log(dev_info_t *dev, const char *label, uint_t level,
    const char *fmt, va_list ap);
static void cmlb_log(dev_info_t *dev, const char *label, uint_t level,
    const char *fmt, ...);

int
_init(void)
{
        mutex_init(&cmlb_log_mutex, NULL, MUTEX_DRIVER, NULL);
        return (mod_install(&modlinkage));
}

int
_info(struct modinfo *modinfop)
{
        return (mod_info(&modlinkage, modinfop));
}

int
_fini(void)
{
        int err;

        if ((err = mod_remove(&modlinkage)) != 0) {
                return (err);
        }

        mutex_destroy(&cmlb_log_mutex);
        return (err);
}

/*
 * cmlb_dbg is used for debugging to log additional info
 * Level of output is controlled via cmlb_level_mask setting.
 */
static void
cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...)
{
        va_list         ap;
        dev_info_t      *dev;
        uint_t          level_mask = 0;

        ASSERT(cl != NULL);
        dev = CMLB_DEVINFO(cl);
        ASSERT(dev != NULL);
        /*
         * Filter messages based on the global component and level masks,
         * also print if cl matches the value of cmlb_debug_cl, or if
         * cmlb_debug_cl is set to NULL.
         */
        if (comp & CMLB_TRACE)
                level_mask |= CMLB_LOGMASK_TRACE;

        if (comp & CMLB_INFO)
                level_mask |= CMLB_LOGMASK_INFO;

        if (comp & CMLB_ERROR)
                level_mask |= CMLB_LOGMASK_ERROR;

        if ((cmlb_level_mask & level_mask) &&
            ((cmlb_debug_cl == NULL) || (cmlb_debug_cl == cl))) {
                va_start(ap, fmt);
                cmlb_v_log(dev, CMLB_LABEL(cl), CE_CONT, fmt, ap);
                va_end(ap);
        }
}

/*
 * cmlb_log is basically a duplicate of scsi_log. It is redefined here
 * so that this module does not depend on scsi module.
 */
static void
cmlb_log(dev_info_t *dev, const char *label, uint_t level, const char *fmt, ...)
{
        va_list         ap;

        va_start(ap, fmt);
        cmlb_v_log(dev, label, level, fmt, ap);
        va_end(ap);
}

static void
cmlb_v_log(dev_info_t *dev, const char *label, uint_t level, const char *fmt,
    va_list ap)
{
        static char     name[256];
        int             log_only = 0;
        int             boot_only = 0;
        int             console_only = 0;

        mutex_enter(&cmlb_log_mutex);

        if (dev) {
                if (level == CE_PANIC || level == CE_WARN ||
                    level == CE_NOTE) {
                        (void) sprintf(name, "%s (%s%d):\n",
                            ddi_pathname(dev, cmlb_log_buffer),
                            label, ddi_get_instance(dev));
                } else {
                        name[0] = '\0';
                }
        } else {
                (void) sprintf(name, "%s:", label);
        }

        (void) vsprintf(cmlb_log_buffer, fmt, ap);

        switch (cmlb_log_buffer[0]) {
        case '!':
                log_only = 1;
                break;
        case '?':
                boot_only = 1;
                break;
        case '^':
                console_only = 1;
                break;
        }

        switch (level) {
        case CE_NOTE:
                level = CE_CONT;
                /* FALLTHROUGH */
        case CE_CONT:
        case CE_WARN:
        case CE_PANIC:
                if (boot_only) {
                        cmn_err(level, "?%s\t%s", name, &cmlb_log_buffer[1]);
                } else if (console_only) {
                        cmn_err(level, "^%s\t%s", name, &cmlb_log_buffer[1]);
                } else if (log_only) {
                        cmn_err(level, "!%s\t%s", name, &cmlb_log_buffer[1]);
                } else {
                        cmn_err(level, "%s\t%s", name, cmlb_log_buffer);
                }
                break;
        case CE_IGNORE:
                break;
        default:
                cmn_err(CE_CONT, "^DEBUG: %s\t%s", name, cmlb_log_buffer);
                break;
        }
        mutex_exit(&cmlb_log_mutex);
}


/*
 * cmlb_alloc_handle:
 *
 *      Allocates a handle.
 *
 * Arguments:
 *      cmlbhandlep     pointer to handle
 *
 * Notes:
 *      Allocates a handle and stores the allocated handle in the area
 *      pointed to by cmlbhandlep
 *
 * Context:
 *      Kernel thread only (can sleep).
 */
void
cmlb_alloc_handle(cmlb_handle_t *cmlbhandlep)
{
        struct cmlb_lun         *cl;

        cl = kmem_zalloc(sizeof (struct cmlb_lun), KM_SLEEP);
        ASSERT(cmlbhandlep != NULL);

        cl->cl_state = CMLB_INITED;
        cl->cl_def_labeltype = CMLB_LABEL_UNDEF;
        mutex_init(CMLB_MUTEX(cl), NULL, MUTEX_DRIVER, NULL);

        *cmlbhandlep = (cmlb_handle_t)(cl);
}

/*
 * cmlb_free_handle
 *
 *      Frees handle.
 *
 * Arguments:
 *      cmlbhandlep     pointer to handle
 */
void
cmlb_free_handle(cmlb_handle_t *cmlbhandlep)
{
        struct cmlb_lun         *cl;

        cl = (struct cmlb_lun *)*cmlbhandlep;
        if (cl != NULL) {
                mutex_destroy(CMLB_MUTEX(cl));
                kmem_free(cl, sizeof (struct cmlb_lun));
        }

}

/*
 * cmlb_attach:
 *
 *      Attach handle to device, create minor nodes for device.
 *
 * Arguments:
 *      devi            pointer to device's dev_info structure.
 *      tgopsp          pointer to array of functions cmlb can use to callback
 *                      to target driver.
 *
 *      device_type     Peripheral device type as defined in
 *                      scsi/generic/inquiry.h
 *
 *      is_removable    whether or not device is removable.
 *
 *      is_hotpluggable whether or not device is hotpluggable.
 *
 *      node_type       minor node type (as used by ddi_create_minor_node)
 *
 *      alter_behavior
 *                      bit flags:
 *
 *                      CMLB_CREATE_ALTSLICE_VTOC_16_DTYPE_DIRECT: create
 *                      an alternate slice for the default label, if
 *                      device type is DTYPE_DIRECT an architectures default
 *                      label type is VTOC16.
 *                      Otherwise alternate slice will no be created.
 *
 *
 *                      CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8: report a default
 *                      geometry and label for DKIOCGGEOM and DKIOCGVTOC
 *                      on architecture with VTOC8 label types.
 *
 *                      CMLB_OFF_BY_ONE: do the workaround for legacy off-by-
 *                      one bug in obtaining capacity (in sd):
 *                      SCSI READ_CAPACITY command returns the LBA number of the
 *                      last logical block, but sd once treated this number as
 *                      disks' capacity on x86 platform. And LBAs are addressed
 *                      based 0. So the last block was lost on x86 platform.
 *
 *                      Now, we remove this workaround. In order for present sd
 *                      driver to work with disks which are labeled/partitioned
 *                      via previous sd, we add workaround as follows:
 *
 *                      1) Locate backup EFI label: cmlb searches the next to
 *                         last
 *                         block for backup EFI label. If fails, it will
 *                         turn to the last block for backup EFI label;
 *
 *                      2) Clear backup EFI label: cmlb first search the last
 *                         block for backup EFI label, and will search the
 *                         next to last block only if failed for the last
 *                         block.
 *
 *                      3) Calculate geometry:refer to cmlb_convert_geometry()
 *                         If capacity increasing by 1 causes disks' capacity
 *                         to cross over the limits in geometry calculation,
 *                         geometry info will change. This will raise an issue:
 *                         In case that primary VTOC label is destroyed, format
 *                         commandline can restore it via backup VTOC labels.
 *                         And format locates backup VTOC labels by use of
 *                         geometry. So changing geometry will
 *                         prevent format from finding backup VTOC labels. To
 *                         eliminate this side effect for compatibility,
 *                         sd uses (capacity -1) to calculate geometry;
 *
 *                      4) 1TB disks: some important data structures use
 *                         32-bit signed long/int (for example, daddr_t),
 *                         so that sd doesn't support a disk with capacity
 *                         larger than 1TB on 32-bit platform. However,
 *                         for exactly 1TB disk, it was treated as (1T - 512)B
 *                         in the past, and could have valid Solaris
 *                         partitions. To workaround this, if an exactly 1TB
 *                         disk has Solaris fdisk partition, it will be allowed
 *                         to work with sd.
 *
 *
 *
 *                      CMLB_FAKE_LABEL_ONE_PARTITION: create s0 and s2 covering
 *                      the entire disk, if there is no valid partition info.
 *                      If there is a valid Solaris partition, s0 and s2 will
 *                      only cover the entire Solaris partition.
 *
 *                      CMLB_CREATE_P0_MINOR_NODE: create p0 node covering
 *                      the entire disk. Used by lofi to ensure presence of
 *                      whole disk device node in case of LOFI_MAP_FILE ioctl.
 *
 *      cmlbhandle      cmlb handle associated with device
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 * Notes:
 *      Assumes a default label based on capacity for non-removable devices.
 *      If capacity > 1TB, EFI is assumed otherwise VTOC (default VTOC
 *      for the architecture).
 *
 *      For removable devices, default label type is assumed to be VTOC
 *      type. Create minor nodes based on a default label type.
 *      Label on the media is not validated.
 *      minor number consists of:
 *              if _SUNOS_VTOC_8 is defined
 *                      lowest 3 bits is taken as partition number
 *                      the rest is instance number
 *              if _SUNOS_VTOC_16 is defined
 *                      lowest 6 bits is taken as partition number
 *                      the rest is instance number
 *
 *
 * Return values:
 *      0       Success
 *      ENXIO   creating minor nodes failed.
 *      EINVAL  invalid arg, unsupported tg_ops version
 */
int
cmlb_attach(dev_info_t *devi, cmlb_tg_ops_t *tgopsp, int device_type,
    boolean_t is_removable, boolean_t is_hotpluggable, char *node_type,
    int alter_behavior, cmlb_handle_t cmlbhandle, void *tg_cookie)
{

        struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
        diskaddr_t      cap;
        int             status;

        if (tgopsp->tg_version < TG_DK_OPS_VERSION_1)
                return (EINVAL);

        mutex_enter(CMLB_MUTEX(cl));

        CMLB_DEVINFO(cl) = devi;
        cl->cmlb_tg_ops = tgopsp;
        cl->cl_device_type = device_type;
        cl->cl_is_removable = is_removable;
        cl->cl_is_hotpluggable = is_hotpluggable;
        cl->cl_node_type = node_type;
        cl->cl_sys_blocksize = DEV_BSIZE;
        cl->cl_f_geometry_is_valid = B_FALSE;
        cl->cl_def_labeltype = CMLB_LABEL_VTOC;
        cl->cl_alter_behavior = alter_behavior;
        cl->cl_reserved = -1;
        cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
#if defined(__i386) || defined(__amd64)
        cl->cl_logical_drive_count = 0;
#endif

        if (!is_removable) {
                mutex_exit(CMLB_MUTEX(cl));
                status = DK_TG_GETCAP(cl, &cap, tg_cookie);
                mutex_enter(CMLB_MUTEX(cl));
                if (status == 0 && cap > CMLB_EXTVTOC_LIMIT) {
                        /* set default EFI if > 2TB */
                        cl->cl_def_labeltype = CMLB_LABEL_EFI;
                }
        }

        /* create minor nodes based on default label type */
        cl->cl_last_labeltype = CMLB_LABEL_UNDEF;
        cl->cl_cur_labeltype = CMLB_LABEL_UNDEF;

        if (cmlb_create_minor_nodes(cl) != 0) {
                mutex_exit(CMLB_MUTEX(cl));
                return (ENXIO);
        }

        /* Define the dynamic properties for devinfo spapshots. */
        i_ddi_prop_dyn_driver_set(CMLB_DEVINFO(cl), cmlb_prop_dyn);

        cl->cl_state = CMLB_ATTACHED;

        mutex_exit(CMLB_MUTEX(cl));
        return (0);
}

/*
 * cmlb_detach:
 *
 * Invalidate in-core labeling data and remove all minor nodes for
 * the device associate with handle.
 *
 * Arguments:
 *      cmlbhandle      cmlb handle associated with device.
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 */
/*ARGSUSED1*/
void
cmlb_detach(cmlb_handle_t cmlbhandle, void *tg_cookie)
{
        struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;

        mutex_enter(CMLB_MUTEX(cl));
        cl->cl_def_labeltype = CMLB_LABEL_UNDEF;
        cl->cl_f_geometry_is_valid = B_FALSE;
        ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
        i_ddi_prop_dyn_driver_set(CMLB_DEVINFO(cl), NULL);
        cl->cl_state = CMLB_INITED;
        mutex_exit(CMLB_MUTEX(cl));
}

/*
 * cmlb_validate:
 *
 *      Validates label.
 *
 * Arguments
 *      cmlbhandle      cmlb handle associated with device.
 *
 *      flags           operation flags. used for verbosity control
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 *
 * Notes:
 *      If new label type is different from the current, adjust minor nodes
 *      accordingly.
 *
 * Return values:
 *      0               success
 *                      Note: having fdisk but no solaris partition is assumed
 *                      success.
 *
 *      ENOMEM          memory allocation failed
 *      EIO             i/o errors during read or get capacity
 *      EACCESS         reservation conflicts
 *      EINVAL          label was corrupt, or no default label was assumed
 *      ENXIO           invalid handle
 */
int
cmlb_validate(cmlb_handle_t cmlbhandle, int flags, void *tg_cookie)
{
        struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
        int             rval;
        int             ret = 0;

        /*
         * Temp work-around checking cl for NULL since there is a bug
         * in sd_detach calling this routine from taskq_dispatch
         * inited function.
         */
        if (cl == NULL)
                return (ENXIO);

        mutex_enter(CMLB_MUTEX(cl));
        if (cl->cl_state < CMLB_ATTACHED) {
                mutex_exit(CMLB_MUTEX(cl));
                return (ENXIO);
        }

        rval = cmlb_validate_geometry((struct cmlb_lun *)cmlbhandle, B_TRUE,
            flags, tg_cookie);

        if (rval == ENOTSUP) {
                if (cl->cl_f_geometry_is_valid) {
                        cl->cl_cur_labeltype = CMLB_LABEL_EFI;
                        ret = 0;
                } else {
                        ret = EINVAL;
                }
        } else {
                ret = rval;
                if (ret == 0)
                        cl->cl_cur_labeltype = CMLB_LABEL_VTOC;
        }

        if (ret == 0)
                (void) cmlb_create_minor_nodes(cl);

        mutex_exit(CMLB_MUTEX(cl));
        return (ret);
}

/*
 * cmlb_invalidate:
 *      Invalidate in core label data
 *
 * Arguments:
 *      cmlbhandle      cmlb handle associated with device.
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 */
/*ARGSUSED1*/
void
cmlb_invalidate(cmlb_handle_t cmlbhandle, void *tg_cookie)
{
        struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;

        if (cl == NULL)
                return;

        mutex_enter(CMLB_MUTEX(cl));
        cl->cl_f_geometry_is_valid = B_FALSE;
        mutex_exit(CMLB_MUTEX(cl));
}

/*
 * cmlb_is_valid
 *      Get status on whether the incore label/geom data is valid
 *
 * Arguments:
 *      cmlbhandle      cmlb handle associated with device.
 *
 * Return values:
 *      B_TRUE if incore label/geom data is valid.
 *      B_FALSE otherwise.
 *
 */


boolean_t
cmlb_is_valid(cmlb_handle_t cmlbhandle)
{
        struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;

        if (cmlbhandle == NULL)
                return (B_FALSE);

        return (cl->cl_f_geometry_is_valid);

}



/*
 * cmlb_close:
 *
 * Close the device, revert to a default label minor node for the device,
 * if it is removable.
 *
 * Arguments:
 *      cmlbhandle      cmlb handle associated with device.
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 * Return values:
 *      0       Success
 *      ENXIO   Re-creating minor node failed.
 */
/*ARGSUSED1*/
int
cmlb_close(cmlb_handle_t cmlbhandle, void *tg_cookie)
{
        struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;

        mutex_enter(CMLB_MUTEX(cl));
        cl->cl_f_geometry_is_valid = B_FALSE;

        /* revert to default minor node for this device */
        if (ISREMOVABLE(cl)) {
                cl->cl_cur_labeltype = CMLB_LABEL_UNDEF;
                (void) cmlb_create_minor_nodes(cl);
        }

        mutex_exit(CMLB_MUTEX(cl));
        return (0);
}

/*
 * cmlb_get_devid_block:
 *       get the block number where device id is stored.
 *
 * Arguments:
 *      cmlbhandle      cmlb handle associated with device.
 *      devidblockp     pointer to block number.
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 * Notes:
 *      It stores the block number of device id in the area pointed to
 *      by devidblockp.
 *      with the block number of device id.
 *
 * Return values:
 *      0       success
 *      EINVAL  device id does not apply to current label type.
 */
/*ARGSUSED2*/
int
cmlb_get_devid_block(cmlb_handle_t cmlbhandle, diskaddr_t *devidblockp,
    void *tg_cookie)
{
        daddr_t                 spc, blk, head, cyl;
        struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;

        mutex_enter(CMLB_MUTEX(cl));
        if (cl->cl_state < CMLB_ATTACHED) {
                mutex_exit(CMLB_MUTEX(cl));
                return (EINVAL);
        }

        if ((!cl->cl_f_geometry_is_valid) ||
            (cl->cl_solaris_size < DK_LABEL_LOC)) {
                mutex_exit(CMLB_MUTEX(cl));
                return (EINVAL);
        }

        if (cl->cl_cur_labeltype == CMLB_LABEL_EFI) {
                if (cl->cl_reserved != -1) {
                        blk = cl->cl_map[cl->cl_reserved].dkl_cylno;
                } else {
                        mutex_exit(CMLB_MUTEX(cl));
                        return (EINVAL);
                }
        } else {
                /* if the disk is unlabeled, don't write a devid to it */
                if (cl->cl_label_from_media != CMLB_LABEL_VTOC) {
                        mutex_exit(CMLB_MUTEX(cl));
                        return (EINVAL);
                }

                /* this geometry doesn't allow us to write a devid */
                if (cl->cl_g.dkg_acyl < 2) {
                        mutex_exit(CMLB_MUTEX(cl));
                        return (EINVAL);
                }

                /*
                 * Subtract 2 guarantees that the next to last cylinder
                 * is used
                 */
                cyl  = cl->cl_g.dkg_ncyl  + cl->cl_g.dkg_acyl - 2;
                spc  = cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
                head = cl->cl_g.dkg_nhead - 1;
                blk  = cl->cl_solaris_offset +
                    (cyl * (spc - cl->cl_g.dkg_apc)) +
                    (head * cl->cl_g.dkg_nsect) + 1;
        }

        *devidblockp = blk;
        mutex_exit(CMLB_MUTEX(cl));
        return (0);
}

/*
 * cmlb_partinfo:
 *      Get partition info for specified partition number.
 *
 * Arguments:
 *      cmlbhandle      cmlb handle associated with device.
 *      part            partition number
 *      nblocksp        pointer to number of blocks
 *      startblockp     pointer to starting block
 *      partnamep       pointer to name of partition
 *      tagp            pointer to tag info
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 *
 * Notes:
 *      If in-core label is not valid, this functions tries to revalidate
 *      the label. If label is valid, it stores the total number of blocks
 *      in this partition in the area pointed to by nblocksp, starting
 *      block number in area pointed to by startblockp,  pointer to partition
 *      name in area pointed to by partnamep, and tag value in area
 *      pointed by tagp.
 *      For EFI labels, tag value will be set to 0.
 *
 *      For all nblocksp, startblockp and partnamep, tagp, a value of NULL
 *      indicates the corresponding info is not requested.
 *
 *
 * Return values:
 *      0       success
 *      EINVAL  no valid label or requested partition number is invalid.
 *
 */
int
cmlb_partinfo(cmlb_handle_t cmlbhandle, int part, diskaddr_t *nblocksp,
    diskaddr_t *startblockp, char **partnamep, uint16_t *tagp, void *tg_cookie)
{

        struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
        int rval;
#if defined(__i386) || defined(__amd64)
        int ext_part;
#endif

        ASSERT(cl != NULL);
        mutex_enter(CMLB_MUTEX(cl));
        if (cl->cl_state < CMLB_ATTACHED) {
                mutex_exit(CMLB_MUTEX(cl));
                return (EINVAL);
        }

        if (part  < 0 || part >= MAXPART) {
                rval = EINVAL;
        } else {
                if (!cl->cl_f_geometry_is_valid)
                        (void) cmlb_validate_geometry((struct cmlb_lun *)cl,
                            B_FALSE, 0, tg_cookie);

                if (((!cl->cl_f_geometry_is_valid) ||
                    (part < NDKMAP && cl->cl_solaris_size == 0)) &&
                    (part != P0_RAW_DISK)) {
                        rval = EINVAL;
                } else {
                        if (startblockp != NULL)
                                *startblockp = (diskaddr_t)cl->cl_offset[part];

                        if (nblocksp != NULL)
                                *nblocksp = (diskaddr_t)
                                    cl->cl_map[part].dkl_nblk;

                        if (tagp != NULL)
                                *tagp =
                                    ((cl->cl_cur_labeltype == CMLB_LABEL_EFI) ||
                                    (part >= NDKMAP)) ? V_UNASSIGNED :
                                    cl->cl_vtoc.v_part[part].p_tag;
                        rval = 0;
                }

                /* consistent with behavior of sd for getting minor name */
                if (partnamep != NULL) {
#if defined(__i386) || defined(__amd64)
#if defined(_FIRMWARE_NEEDS_FDISK)
                if (part > FDISK_P4) {
                        ext_part = part-FDISK_P4-1;
                        *partnamep = dk_ext_minor_data[ext_part].name;
                } else
#endif
#endif
                        *partnamep = dk_minor_data[part].name;
                }

        }

        mutex_exit(CMLB_MUTEX(cl));
        return (rval);
}

/*
 * cmlb_efi_label_capacity:
 *      Get capacity stored in EFI disk label.
 *
 * Arguments:
 *      cmlbhandle      cmlb handle associated with device.
 *      capacity        pointer to capacity stored in EFI disk label.
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 *
 * Notes:
 *      If in-core label is not valid, this functions tries to revalidate
 *      the label. If label is valid and is an EFI label, it stores the capacity
 *      in disk label in the area pointed to by capacity.
 *
 *
 * Return values:
 *      0       success
 *      EINVAL  no valid EFI label or capacity is NULL.
 *
 */
int
cmlb_efi_label_capacity(cmlb_handle_t cmlbhandle, diskaddr_t *capacity,
    void *tg_cookie)
{
        struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
        int rval;

        ASSERT(cl != NULL);
        mutex_enter(CMLB_MUTEX(cl));
        if (cl->cl_state < CMLB_ATTACHED) {
                mutex_exit(CMLB_MUTEX(cl));
                return (EINVAL);
        }

        if (!cl->cl_f_geometry_is_valid)
                (void) cmlb_validate_geometry((struct cmlb_lun *)cl, B_FALSE,
                    0, tg_cookie);

        if ((!cl->cl_f_geometry_is_valid) || (capacity == NULL) ||
            (cl->cl_cur_labeltype != CMLB_LABEL_EFI)) {
                rval = EINVAL;
        } else {
                *capacity = (diskaddr_t)cl->cl_map[WD_NODE].dkl_nblk;
                rval = 0;
        }

        mutex_exit(CMLB_MUTEX(cl));
        return (rval);
}

/* Caller should make sure Test Unit Ready succeeds before calling this. */
/*ARGSUSED*/
int
cmlb_ioctl(cmlb_handle_t cmlbhandle, dev_t dev, int cmd, intptr_t arg,
    int flag, cred_t *cred_p, int *rval_p, void *tg_cookie)
{

        int err;
        struct cmlb_lun *cl;

        cl = (struct cmlb_lun *)cmlbhandle;

        ASSERT(cl != NULL);

        mutex_enter(CMLB_MUTEX(cl));
        if (cl->cl_state < CMLB_ATTACHED) {
                mutex_exit(CMLB_MUTEX(cl));
                return (EIO);
        }

        switch (cmd) {
                case DKIOCSEXTVTOC:
                case DKIOCSGEOM:
                case DKIOCSETEFI:
                case DKIOCSMBOOT:
#if defined(__i386) || defined(__amd64)
                case DKIOCSETEXTPART:
#endif
                        break;
                case DKIOCSVTOC:
#if defined(__i386) || defined(__amd64)
                case DKIOCPARTINFO:
#endif
                        if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
                                mutex_exit(CMLB_MUTEX(cl));
                                return (EOVERFLOW);
                        }
                        break;
                default:
                        (void) cmlb_validate_geometry(cl, 1, CMLB_SILENT,
                            tg_cookie);

                        switch (cmd) {
                        case DKIOCGVTOC:
                        case DKIOCGAPART:
                        case DKIOCSAPART:

                                if (cl->cl_label_from_media == CMLB_LABEL_EFI) {
                                        /* GPT label on disk */
                                        mutex_exit(CMLB_MUTEX(cl));
                                        return (ENOTSUP);
                                } else if
                                    (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
                                        mutex_exit(CMLB_MUTEX(cl));
                                        return (EOVERFLOW);
                                }
                                break;

                        case DKIOCGGEOM:
                                if (cl->cl_label_from_media == CMLB_LABEL_EFI) {
                                        /* GPT label on disk */
                                        mutex_exit(CMLB_MUTEX(cl));
                                        return (ENOTSUP);
                                }
                                break;
                        default:
                                break;
                        }
        }

        mutex_exit(CMLB_MUTEX(cl));

        switch (cmd) {
        case DKIOCGGEOM:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCGGEOM\n");
                err = cmlb_dkio_get_geometry(cl, (caddr_t)arg, flag, tg_cookie);
                break;

        case DKIOCSGEOM:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCSGEOM\n");
                err = cmlb_dkio_set_geometry(cl, (caddr_t)arg, flag);
                break;

        case DKIOCGAPART:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCGAPART\n");
                err = cmlb_dkio_get_partition(cl, (caddr_t)arg,
                    flag, tg_cookie);
                break;

        case DKIOCSAPART:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCSAPART\n");
                err = cmlb_dkio_set_partition(cl, (caddr_t)arg, flag);
                break;

        case DKIOCGVTOC:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCGVTOC\n");
                err = cmlb_dkio_get_vtoc(cl, (caddr_t)arg, flag, tg_cookie);
                break;

        case DKIOCGEXTVTOC:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCGVTOC\n");
                err = cmlb_dkio_get_extvtoc(cl, (caddr_t)arg, flag, tg_cookie);
                break;

        case DKIOCGETEFI:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCGETEFI\n");
                err = cmlb_dkio_get_efi(cl, (caddr_t)arg, flag, tg_cookie);
                break;

        case DKIOCPARTITION:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTITION\n");
                err = cmlb_dkio_partition(cl, (caddr_t)arg, flag, tg_cookie);
                break;

        case DKIOCSVTOC:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCSVTOC\n");
                err = cmlb_dkio_set_vtoc(cl, dev, (caddr_t)arg, flag,
                    tg_cookie);
                break;

        case DKIOCSEXTVTOC:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCSVTOC\n");
                err = cmlb_dkio_set_extvtoc(cl, dev, (caddr_t)arg, flag,
                    tg_cookie);
                break;

        case DKIOCSETEFI:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCSETEFI\n");
                err = cmlb_dkio_set_efi(cl, dev, (caddr_t)arg, flag, tg_cookie);
                break;

        case DKIOCGMBOOT:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCGMBOOT\n");
                err = cmlb_dkio_get_mboot(cl, (caddr_t)arg, flag, tg_cookie);
                break;

        case DKIOCSMBOOT:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCSMBOOT\n");
                err = cmlb_dkio_set_mboot(cl, (caddr_t)arg, flag, tg_cookie);
                break;
        case DKIOCG_PHYGEOM:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_PHYGEOM\n");
#if defined(__i386) || defined(__amd64)
                err = cmlb_dkio_get_phygeom(cl, (caddr_t)arg, flag, tg_cookie);
#else
                err = ENOTTY;
#endif
                break;
        case DKIOCG_VIRTGEOM:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_VIRTGEOM\n");
#if defined(__i386) || defined(__amd64)
                err = cmlb_dkio_get_virtgeom(cl, (caddr_t)arg, flag);
#else
                err = ENOTTY;
#endif
                break;
        case DKIOCPARTINFO:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTINFO");
#if defined(__i386) || defined(__amd64)
                err = cmlb_dkio_partinfo(cl, dev, (caddr_t)arg, flag);
#else
                err = ENOTTY;
#endif
                break;
        case DKIOCEXTPARTINFO:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTINFO");
#if defined(__i386) || defined(__amd64)
                err = cmlb_dkio_extpartinfo(cl, dev, (caddr_t)arg, flag);
#else
                err = ENOTTY;
#endif
                break;
#if defined(__i386) || defined(__amd64)
        case DKIOCSETEXTPART:
                cmlb_dbg(CMLB_TRACE, cl, "DKIOCSETEXTPART");
                err = cmlb_dkio_set_ext_part(cl, (caddr_t)arg, flag, tg_cookie);
                break;
#endif
        default:
                err = ENOTTY;

        }

        /*
         * An ioctl that succeeds and changed ('set') size(9P) information
         * needs to invalidate the cached devinfo snapshot to avoid having
         * old information being returned in a snapshots.
         *
         * NB: When available, call ddi_change_minor_node() to clear
         * SSIZEVALID in specfs vnodes via spec_size_invalidate().
         */
        if (err == 0) {
                switch (cmd) {
                case DKIOCSGEOM:
                case DKIOCSAPART:
                case DKIOCSVTOC:
                case DKIOCSEXTVTOC:
                case DKIOCSETEFI:
                        i_ddi_prop_dyn_cache_invalidate(CMLB_DEVINFO(cl),
                            i_ddi_prop_dyn_driver_get(CMLB_DEVINFO(cl)));
                }
        }
        return (err);
}

dev_t
cmlb_make_device(struct cmlb_lun *cl)
{
        if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) {
                return (makedevice(ddi_driver_major(CMLB_DEVINFO(cl)),
                    ddi_get_instance(
                    CMLB_DEVINFO(cl)) << CMLBUNIT_FORCE_P0_SHIFT));
        } else {
                return (makedevice(ddi_driver_major(CMLB_DEVINFO(cl)),
                    ddi_get_instance(CMLB_DEVINFO(cl)) << CMLBUNIT_SHIFT));
        }
}

/*
 * Function: cmlb_check_update_blockcount
 *
 * Description: If current capacity value is invalid, obtains the
 *              current capacity from target driver.
 *
 * Return Code: 0       success
 *              EIO     failure
 */
static int
cmlb_check_update_blockcount(struct cmlb_lun *cl, void *tg_cookie)
{
        int status;
        diskaddr_t capacity;
        uint32_t lbasize;

        ASSERT(mutex_owned(CMLB_MUTEX(cl)));

        if (cl->cl_f_geometry_is_valid)
                return (0);

        mutex_exit(CMLB_MUTEX(cl));
        status = DK_TG_GETCAP(cl, &capacity, tg_cookie);
        if (status != 0) {
                mutex_enter(CMLB_MUTEX(cl));
                return (EIO);
        }

        status = DK_TG_GETBLOCKSIZE(cl, &lbasize, tg_cookie);
        mutex_enter(CMLB_MUTEX(cl));
        if (status != 0)
                return (EIO);

        if ((capacity != 0) && (lbasize != 0)) {
                cl->cl_blockcount = capacity;
                cl->cl_tgt_blocksize = lbasize;
                if (!cl->cl_is_removable) {
                        cl->cl_sys_blocksize = lbasize;
                }
                return (0);
        } else {
                return (EIO);
        }
}

static int
cmlb_create_minor(dev_info_t *dip, char *name, int spec_type,
    minor_t minor_num, char *node_type, int flag, boolean_t internal)
{
        if (internal)
                return (ddi_create_internal_pathname(dip,
                    name, spec_type, minor_num));
        else
                return (ddi_create_minor_node(dip,
                    name, spec_type, minor_num, node_type, flag));
}

/*
 *    Function: cmlb_create_minor_nodes
 *
 * Description: Create or adjust the minor device nodes for the instance.
 *              Minor nodes are created based on default label type,
 *              current label type and last label type we created
 *              minor nodes based on.
 *
 *
 *   Arguments: cl - driver soft state (unit) structure
 *
 * Return Code: 0 success
 *              ENXIO   failure.
 *
 *     Context: Kernel thread context
 */
static int
cmlb_create_minor_nodes(struct cmlb_lun *cl)
{
        struct driver_minor_data        *dmdp;
        int                             instance, shift;
        char                            name[48];
        cmlb_label_t                    newlabeltype;
        boolean_t                       internal;

        ASSERT(cl != NULL);
        ASSERT(mutex_owned(CMLB_MUTEX(cl)));

        internal = (cl->cl_alter_behavior & CMLB_INTERNAL_MINOR_NODES) != 0;

        if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
                shift = CMLBUNIT_FORCE_P0_SHIFT;
        else
                shift = CMLBUNIT_SHIFT;

        /* check the most common case */
        if (cl->cl_cur_labeltype != CMLB_LABEL_UNDEF &&
            cl->cl_last_labeltype == cl->cl_cur_labeltype) {
                /* do nothing */
                return (0);
        }

        if (cl->cl_def_labeltype == CMLB_LABEL_UNDEF) {
                /* we should never get here */
                return (ENXIO);
        }

        if (cl->cl_last_labeltype == CMLB_LABEL_UNDEF) {
                /* first time during attach */
                newlabeltype = cl->cl_def_labeltype;

                instance = ddi_get_instance(CMLB_DEVINFO(cl));

                /* Create all the minor nodes for this target. */
                dmdp = (newlabeltype == CMLB_LABEL_EFI) ? dk_minor_data_efi :
                    dk_minor_data;
                while (dmdp->name != NULL) {

                        (void) sprintf(name, "%s", dmdp->name);

                        if (cmlb_create_minor(CMLB_DEVINFO(cl), name,
                            dmdp->type,
                            (instance << shift) | dmdp->minor,
                            cl->cl_node_type, 0, internal) == DDI_FAILURE) {
                                /*
                                 * Clean up any nodes that may have been
                                 * created, in case this fails in the middle
                                 * of the loop.
                                 */
                                ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
                                return (ENXIO);
                        }
                        dmdp++;
                }
                cl->cl_last_labeltype = newlabeltype;
#if defined(_SUNOS_VTOC_8)
                /*
                 * "emulate" p0 device for sparc, used by lofi
                 */
                if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) {
                        if (cmlb_create_minor(CMLB_DEVINFO(cl), "q", S_IFBLK,
                            (instance << CMLBUNIT_FORCE_P0_SHIFT) | P0_RAW_DISK,
                            cl->cl_node_type, NULL, internal) == DDI_FAILURE) {
                                ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
                                return (ENXIO);
                        }

                        if (cmlb_create_minor(CMLB_DEVINFO(cl), "q,raw",
                            S_IFCHR,
                            (instance << CMLBUNIT_FORCE_P0_SHIFT) | P0_RAW_DISK,
                            cl->cl_node_type, NULL, internal) == DDI_FAILURE) {
                                ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
                                return (ENXIO);
                        }
                }
#endif  /* defined(_SUNOS_VTOC_8) */
                return (0);
        }

        /* Not first time  */
        if (cl->cl_cur_labeltype == CMLB_LABEL_UNDEF) {
                if (cl->cl_last_labeltype != cl->cl_def_labeltype) {
                        /* close time, revert to default. */
                        newlabeltype = cl->cl_def_labeltype;
                } else {
                        /*
                         * do nothing since the type for which we last created
                         * nodes matches the default
                         */
                        return (0);
                }
        } else {
                if (cl->cl_cur_labeltype != cl->cl_last_labeltype) {
                        /* We are not closing, use current label type */
                        newlabeltype = cl->cl_cur_labeltype;
                } else {
                        /*
                         * do nothing since the type for which we last created
                         * nodes matches the current label type
                         */
                        return (0);
                }
        }

        instance = ddi_get_instance(CMLB_DEVINFO(cl));

        /*
         * Currently we only fix up the s7 node when we are switching
         * label types from or to EFI. This is consistent with
         * current behavior of sd.
         */
        if (newlabeltype == CMLB_LABEL_EFI &&
            cl->cl_last_labeltype != CMLB_LABEL_EFI) {
                /* from vtoc to EFI */
                ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
                ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
                (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd",
                    S_IFBLK, (instance << shift) | WD_NODE,
                    cl->cl_node_type, 0, internal);
                (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd,raw",
                    S_IFCHR, (instance << shift) | WD_NODE,
                    cl->cl_node_type, 0, internal);
        } else {
                /* from efi to vtoc */
                ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
                ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
                (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
                    S_IFBLK, (instance << shift) | WD_NODE,
                    cl->cl_node_type, 0, internal);
                (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
                    S_IFCHR, (instance << shift) | WD_NODE,
                    cl->cl_node_type, 0, internal);
        }

        cl->cl_last_labeltype = newlabeltype;
        return (0);
}

/*
 *    Function: cmlb_validate_geometry
 *
 * Description: Read the label from the disk (if present). Update the unit's
 *              geometry and vtoc information from the data in the label.
 *              Verify that the label is valid.
 *
 *   Arguments:
 *      cl              driver soft state (unit) structure
 *
 *      forcerevalid    force revalidation even if we are already valid.
 *      flags           operation flags from target driver. Used for verbosity
 *                      control at this time.
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 * Return Code: 0 - Successful completion
 *              EINVAL  - Invalid value in cl->cl_tgt_blocksize or
 *                        cl->cl_blockcount; or label on disk is corrupted
 *                        or unreadable.
 *              EACCES  - Reservation conflict at the device.
 *              ENOMEM  - Resource allocation error
 *              ENOTSUP - geometry not applicable
 *
 *     Context: Kernel thread only (can sleep).
 */
static int
cmlb_validate_geometry(struct cmlb_lun *cl, boolean_t forcerevalid, int flags,
    void *tg_cookie)
{
        int             label_error = 0;
        diskaddr_t      capacity;
        int             count;

        ASSERT(mutex_owned(CMLB_MUTEX(cl)));

        if ((cl->cl_f_geometry_is_valid) && (!forcerevalid)) {
                if (cl->cl_cur_labeltype == CMLB_LABEL_EFI)
                        return (ENOTSUP);
                return (0);
        }

        if (cmlb_check_update_blockcount(cl, tg_cookie) != 0)
                return (EIO);

        capacity = cl->cl_blockcount;

        /*
         * Set up the "whole disk" fdisk partition; this should always
         * exist, regardless of whether the disk contains an fdisk table
         * or vtoc.
         */
        cl->cl_map[P0_RAW_DISK].dkl_cylno = 0;
        cl->cl_offset[P0_RAW_DISK] = 0;
        /*
         * note if capacity > int32_max(1TB) we are in 64bit environment
         * so no truncation happens
         */
        cl->cl_map[P0_RAW_DISK].dkl_nblk  = capacity;

        /*
         * Refresh the logical and physical geometry caches.
         * (data from MODE SENSE format/rigid disk geometry pages,
         * and scsi_ifgetcap("geometry").
         */
        cmlb_resync_geom_caches(cl, capacity, tg_cookie);

        cl->cl_label_from_media = CMLB_LABEL_UNDEF;
        label_error = cmlb_use_efi(cl, capacity, flags, tg_cookie);
        if (label_error == 0) {

                /* found a valid EFI label */
                cmlb_dbg(CMLB_TRACE, cl,
                    "cmlb_validate_geometry: found EFI label\n");
                /*
                 * solaris_size and geometry_is_valid are set in
                 * cmlb_use_efi
                 */
                return (ENOTSUP);
        }

        /* NO EFI label found */

        if (capacity > CMLB_EXTVTOC_LIMIT) {
                if (label_error == ESRCH) {
                        /*
                         * they've configured a LUN over 2TB, but used
                         * format.dat to restrict format's view of the
                         * capacity to be under 2TB in some earlier Solaris
                         * release.
                         */
                        /* i.e > 2TB with a VTOC < 2TB */
                        if (!(flags & CMLB_SILENT) &&
                            (cl->cl_msglog_flag & CMLB_ALLOW_2TB_WARN)) {

                                cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
                                    CE_NOTE, "!Disk (%s%d) is limited to 2 TB "
                                    "due to VTOC label. To use the full "
                                    "capacity of the disk, use format(8) to "
                                    "relabel the disk with EFI/GPT label.\n",
                                    CMLB_LABEL(cl),
                                    ddi_get_instance(CMLB_DEVINFO(cl)));

                                cl->cl_msglog_flag &= ~CMLB_ALLOW_2TB_WARN;
                        }
                } else {
                                return (ENOTSUP);
                }
        }

        label_error = 0;

        /*
         * at this point it is either labeled with a VTOC or it is
         * under 1TB (<= 1TB actually for off-by-1)
         */

        /*
         * Only DIRECT ACCESS devices will have Scl labels.
         * CD's supposedly have a Scl label, too
         */
        if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) {
                struct  dk_label *dkl;
                offset_t label_addr;
                int     rval;
                size_t  buffer_size;

                /*
                 * Note: This will set up cl->cl_solaris_size and
                 * cl->cl_solaris_offset.
                 */
                rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
                if ((rval != 0) && !ISCD(cl)) {
                        ASSERT(mutex_owned(CMLB_MUTEX(cl)));
                        return (rval);
                }

                if (cl->cl_solaris_size <= DK_LABEL_LOC) {
                        /*
                         * Found fdisk table but no Solaris partition entry,
                         * so don't call cmlb_uselabel() and don't create
                         * a default label.
                         */
                        label_error = 0;
                        cl->cl_f_geometry_is_valid = B_TRUE;
                        goto no_solaris_partition;
                }

                label_addr = (daddr_t)(cl->cl_solaris_offset + DK_LABEL_LOC);

                buffer_size = cl->cl_sys_blocksize;

                cmlb_dbg(CMLB_TRACE, cl, "cmlb_validate_geometry: "
                    "label_addr: 0x%x allocation size: 0x%x\n",
                    label_addr, buffer_size);

                if ((dkl = kmem_zalloc(buffer_size, KM_NOSLEEP)) == NULL)
                        return (ENOMEM);

                mutex_exit(CMLB_MUTEX(cl));
                rval = DK_TG_READ(cl, dkl, label_addr, buffer_size, tg_cookie);
                mutex_enter(CMLB_MUTEX(cl));

                switch (rval) {
                case 0:
                        /*
                         * cmlb_uselabel will establish that the geometry
                         * is valid.
                         */
                        if (cmlb_uselabel(cl,
                            (struct dk_label *)(uintptr_t)dkl, flags) !=
                            CMLB_LABEL_IS_VALID) {
                                label_error = EINVAL;
                        } else
                                cl->cl_label_from_media = CMLB_LABEL_VTOC;
                        break;
                case EACCES:
                        label_error = EACCES;
                        break;
                default:
                        label_error = EINVAL;
                        break;
                }

                kmem_free(dkl, buffer_size);
        }

        /*
         * If a valid label was not found, AND if no reservation conflict
         * was detected, then go ahead and create a default label (4069506).
         *
         * Note: currently, for VTOC_8 devices, the default label is created
         * for removables and hotpluggables only.  For VTOC_16 devices, the
         * default label will be created for all devices.
         * (see cmlb_build_default_label)
         */
#if defined(_SUNOS_VTOC_8)
        if ((ISREMOVABLE(cl) || ISHOTPLUGGABLE(cl)) &&
            (label_error != EACCES)) {
#elif defined(_SUNOS_VTOC_16)
        if (label_error != EACCES) {
#endif
                if (!cl->cl_f_geometry_is_valid) {
                        cmlb_build_default_label(cl, tg_cookie);
                }
                label_error = 0;
        }

no_solaris_partition:

#if defined(_SUNOS_VTOC_16)
        /*
         * If we have valid geometry, set up the remaining fdisk partitions.
         * Note that dkl_cylno is not used for the fdisk map entries, so
         * we set it to an entirely bogus value.
         */
        for (count = 0; count < FDISK_PARTS; count++) {
                cl->cl_map[FDISK_P1 + count].dkl_cylno = UINT16_MAX;
                cl->cl_map[FDISK_P1 + count].dkl_nblk =
                    cl->cl_fmap[count].fmap_nblk;

                cl->cl_offset[FDISK_P1 + count] =
                    cl->cl_fmap[count].fmap_start;
        }
#endif

        for (count = 0; count < NDKMAP; count++) {
#if defined(_SUNOS_VTOC_8)
                struct dk_map *lp  = &cl->cl_map[count];
                cl->cl_offset[count] =
                    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
#elif defined(_SUNOS_VTOC_16)
                struct dkl_partition *vp = &cl->cl_vtoc.v_part[count];

                cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset;
#else
#error "No VTOC format defined."
#endif
        }

        return (label_error);
}

#if defined(_SUNOS_VTOC_16)
/*
 *    Function: cmlb_convert_geometry
 *
 * Description: Convert physical geometry into a dk_geom structure. In
 *              other words, make sure we don't wrap 16-bit values.
 *              e.g. converting from geom_cache to dk_geom
 *
 *     Context: Kernel thread only
 */
static void
cmlb_convert_geometry(struct cmlb_lun *cl, diskaddr_t capacity,
    struct dk_geom *cl_g, void *tg_cookie)
{

        ASSERT(cl != NULL);
        ASSERT(mutex_owned(CMLB_MUTEX(cl)));

        /* Unlabeled SCSI floppy device */
        if (capacity < 160) {
                /* Less than 80K */
                cl_g->dkg_nhead = 1;
                cl_g->dkg_ncyl = capacity;
                cl_g->dkg_nsect = 1;
                return;
        } else if (capacity <= 0x1000) {
                cl_g->dkg_nhead = 2;
                cl_g->dkg_ncyl = 80;
                cl_g->dkg_nsect = capacity / (cl_g->dkg_nhead * cl_g->dkg_ncyl);
                return;
        }

        /*
         * For all devices we calculate cylinders using the heads and sectors
         * we assign based on capacity of the device.  The algorithm is
         * designed to be compatible with the way other operating systems
         * lay out fdisk tables for X86 and to insure that the cylinders never
         * exceed 65535 to prevent problems with X86 ioctls that report
         * geometry.
         * For some smaller disk sizes we report geometry that matches those
         * used by X86 BIOS usage. For larger disks, we use SPT that are
         * multiples of 63, since other OSes that are not limited to 16-bits
         * for cylinders stop at 63 SPT we make do by using multiples of 63 SPT.
         *
         * The following table (in order) illustrates some end result
         * calculations:
         *
         * Maximum number of blocks             nhead   nsect
         *
         * 2097152 (1GB)                        64      32
         * 16777216 (8GB)                       128     32
         * 1052819775 (502.02GB)                255     63
         * 2105639550 (0.98TB)                  255     126
         * 3158459325 (1.47TB)                  255     189
         * 4211279100 (1.96TB)                  255     252
         * 5264098875 (2.45TB)                  255     315
         * ...
         *
         * For Solid State Drive(SSD), it uses 4K page size inside and may be
         * double with every new generation. If the I/O is not aligned with
         * page size on SSDs, SSDs perform a lot slower.
         * By default, Solaris partition starts from cylinder 1. It will be
         * misaligned even with 4K if using heads(255) and SPT(63). To
         * workaround the problem, if the device is SSD, we use heads(224) and
         * SPT multiple of 56. Thus the default Solaris partition starts from
         * a position that aligns with 128K on a 512 bytes sector size SSD.
         */

        if (capacity <= 0x200000) {
                cl_g->dkg_nhead = 64;
                cl_g->dkg_nsect = 32;
        } else if (capacity <= 0x01000000) {
                cl_g->dkg_nhead = 128;
                cl_g->dkg_nsect = 32;
        } else {
                tg_attribute_t tgattribute;
                int is_solid_state;
                unsigned short nhead;
                unsigned short nsect;

                bzero(&tgattribute, sizeof (tg_attribute_t));

                mutex_exit(CMLB_MUTEX(cl));
                is_solid_state =
                    (DK_TG_GETATTRIBUTE(cl, &tgattribute, tg_cookie) == 0) ?
                    tgattribute.media_is_solid_state : FALSE;
                mutex_enter(CMLB_MUTEX(cl));

                if (is_solid_state) {
                        nhead = 224;
                        nsect = 56;
                } else {
                        nhead = 255;
                        nsect = 63;
                }

                cl_g->dkg_nhead = nhead;

                /* make dkg_nsect be smallest multiple of nsect */
                cl_g->dkg_nsect = ((capacity +
                    (UINT16_MAX * nhead * nsect) - 1) /
                    (UINT16_MAX * nhead * nsect)) * nsect;

                if (cl_g->dkg_nsect == 0)
                        cl_g->dkg_nsect = (UINT16_MAX / nsect) * nsect;
        }

}
#endif

/*
 *    Function: cmlb_resync_geom_caches
 *
 * Description: (Re)initialize both geometry caches: the virtual geometry
 *            information is extracted from the HBA (the "geometry"
 *            capability), and the physical geometry cache data is
 *            generated by issuing MODE SENSE commands.
 *
 *   Arguments:
 *      cl              driver soft state (unit) structure
 *      capacity        disk capacity in #blocks
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 *     Context: Kernel thread only (can sleep).
 */
static void
cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity,
    void *tg_cookie)
{
        struct  cmlb_geom       pgeom;
        struct  cmlb_geom       lgeom;
        struct  cmlb_geom       *pgeomp = &pgeom;
        unsigned short          nhead;
        unsigned short          nsect;
        int                     spc;
        int                     ret;

        ASSERT(cl != NULL);
        ASSERT(mutex_owned(CMLB_MUTEX(cl)));

        /*
         * Ask the controller for its logical geometry.
         * Note: if the HBA does not support scsi_ifgetcap("geometry"),
         * then the lgeom cache will be invalid.
         */
        mutex_exit(CMLB_MUTEX(cl));
        bzero(&lgeom, sizeof (struct cmlb_geom));
        ret = DK_TG_GETVIRTGEOM(cl, &lgeom, tg_cookie);
        mutex_enter(CMLB_MUTEX(cl));

        bcopy(&lgeom, &cl->cl_lgeom, sizeof (cl->cl_lgeom));

        /*
         * Initialize the pgeom cache from lgeom, so that if MODE SENSE
         * doesn't work, DKIOCG_PHYSGEOM can return reasonable values.
         */
        if (ret != 0 || cl->cl_lgeom.g_nsect == 0 ||
            cl->cl_lgeom.g_nhead == 0) {
                /*
                 * Note: Perhaps this needs to be more adaptive? The rationale
                 * is that, if there's no HBA geometry from the HBA driver, any
                 * guess is good, since this is the physical geometry. If MODE
                 * SENSE fails this gives a max cylinder size for non-LBA access
                 */
                nhead = 255;
                nsect = 63;
        } else {
                nhead = cl->cl_lgeom.g_nhead;
                nsect = cl->cl_lgeom.g_nsect;
        }

        if (ISCD(cl)) {
                pgeomp->g_nhead = 1;
                pgeomp->g_nsect = nsect * nhead;
        } else {
                pgeomp->g_nhead = nhead;
                pgeomp->g_nsect = nsect;
        }

        spc = pgeomp->g_nhead * pgeomp->g_nsect;
        pgeomp->g_capacity = capacity;
        if (spc == 0)
                pgeomp->g_ncyl = 0;
        else
                pgeomp->g_ncyl = pgeomp->g_capacity / spc;
        pgeomp->g_acyl = 0;

        /*
         * Retrieve fresh geometry data from the hardware, stash it
         * here temporarily before we rebuild the incore label.
         *
         * We want to use the MODE SENSE commands to derive the
         * physical geometry of the device, but if either command
         * fails, the logical geometry is used as the fallback for
         * disk label geometry.
         */

        mutex_exit(CMLB_MUTEX(cl));
        (void) DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie);
        mutex_enter(CMLB_MUTEX(cl));

        /*
         * Now update the real copy while holding the mutex. This
         * way the global copy is never in an inconsistent state.
         */
        bcopy(pgeomp, &cl->cl_pgeom,  sizeof (cl->cl_pgeom));

        cmlb_dbg(CMLB_INFO, cl, "cmlb_resync_geom_caches: "
            "(cached from lgeom)\n");
        cmlb_dbg(CMLB_INFO,  cl,
            "   ncyl: %ld; acyl: %d; nhead: %d; nsect: %d\n",
            cl->cl_pgeom.g_ncyl, cl->cl_pgeom.g_acyl,
            cl->cl_pgeom.g_nhead, cl->cl_pgeom.g_nsect);
        cmlb_dbg(CMLB_INFO,  cl, "   lbasize: %d; capacity: %ld; "
            "intrlv: %d; rpm: %d\n", cl->cl_pgeom.g_secsize,
            cl->cl_pgeom.g_capacity, cl->cl_pgeom.g_intrlv,
            cl->cl_pgeom.g_rpm);
}


#if defined(__i386) || defined(__amd64)
/*
 *    Function: cmlb_update_ext_minor_nodes
 *
 * Description: Routine to add/remove extended partition device nodes
 *
 *   Arguments:
 *      cl              driver soft state (unit) structure
 *      num_parts       Number of logical drives found on the LUN
 *
 * Should be called with the mutex held
 *
 * Return Code: 0 for success
 *
 *     Context: User and Kernel thread
 *
 */
static int
cmlb_update_ext_minor_nodes(struct cmlb_lun *cl, int num_parts)
{
        int                             i, count, shift;
        char                            name[48];
        int                             instance;
        struct driver_minor_data        *demdp, *demdpr;
        char                            *devnm;
        dev_info_t                      *pdip;
        boolean_t                       internal;

        ASSERT(mutex_owned(CMLB_MUTEX(cl)));
        ASSERT(cl->cl_update_ext_minor_nodes == 1);

        internal = (cl->cl_alter_behavior & CMLB_INTERNAL_MINOR_NODES) != 0;
        instance = ddi_get_instance(CMLB_DEVINFO(cl));
        demdp = dk_ext_minor_data;
        demdpr = &dk_ext_minor_data[MAX_EXT_PARTS];

        if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
                shift = CMLBUNIT_FORCE_P0_SHIFT;
        else
                shift = CMLBUNIT_SHIFT;

        if (cl->cl_logical_drive_count) {
                for (i = 0; i < cl->cl_logical_drive_count; i++) {
                        (void) sprintf(name, "%s", demdp->name);
                        ddi_remove_minor_node(CMLB_DEVINFO(cl), name);
                        (void) sprintf(name, "%s", demdpr->name);
                        ddi_remove_minor_node(CMLB_DEVINFO(cl), name);
                        demdp++;
                        demdpr++;
                }
                /* There are existing device nodes. Remove them */
                devnm = kmem_alloc(MAXNAMELEN + 1, KM_SLEEP);
                (void) ddi_deviname(cl->cl_devi, devnm);
                pdip = ddi_get_parent(cl->cl_devi);
                (void) devfs_clean(pdip, devnm + 1, DV_CLEAN_FORCE);
                kmem_free(devnm, MAXNAMELEN + 1);
        }

        demdp = dk_ext_minor_data;
        demdpr = &dk_ext_minor_data[MAX_EXT_PARTS];

        for (i = 0; i < num_parts; i++) {
                (void) sprintf(name, "%s", demdp->name);
                if (cmlb_create_minor(CMLB_DEVINFO(cl), name,
                    demdp->type,
                    (instance << shift) | demdp->minor,
                    cl->cl_node_type, 0, internal) == DDI_FAILURE) {
                        /*
                         * Clean up any nodes that may have been
                         * created, in case this fails in the middle
                         * of the loop.
                         */
                        ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
                        cl->cl_logical_drive_count = 0;
                        return (ENXIO);
                }
                (void) sprintf(name, "%s", demdpr->name);
                if (ddi_create_minor_node(CMLB_DEVINFO(cl), name,
                    demdpr->type,
                    (instance << shift) | demdpr->minor,
                    cl->cl_node_type, 0) == DDI_FAILURE) {
                        /*
                         * Clean up any nodes that may have been
                         * created, in case this fails in the middle
                         * of the loop.
                         */
                        ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
                        cl->cl_logical_drive_count = 0;
                        return (ENXIO);
                }
                demdp++;
                demdpr++;
        }

        /* Update the cl_map array for logical drives */
        for (count = 0; count < MAX_EXT_PARTS; count++) {
                cl->cl_map[FDISK_P4 + 1 + count].dkl_cylno = UINT32_MAX;
                cl->cl_map[FDISK_P4 + 1 + count].dkl_nblk =
                    cl->cl_fmap[FD_NUMPART + count].fmap_nblk;
                cl->cl_offset[FDISK_P4 + 1 + count] =
                    cl->cl_fmap[FD_NUMPART + count].fmap_start;
        }

        cl->cl_logical_drive_count = i;
        cl->cl_update_ext_minor_nodes = 0;
        return (0);
}
/*
 *    Function: cmlb_validate_ext_part
 *
 * Description: utility routine to validate an extended partition's
 *              metadata as found on disk
 *
 *   Arguments:
 *      cl              driver soft state (unit) structure
 *      part            partition number of the extended partition
 *      epart           partition number of the logical drive
 *      start           absolute sector number of the start of the logical
 *                      drive being validated
 *      size            size of logical drive being validated
 *
 * Return Code: 0 for success
 *
 *     Context: User and Kernel thread
 *
 * Algorithm :
 * Error cases are :
 *      1. If start block is lesser than or equal to the end block
 *      2. If either start block or end block is beyond the bounadry
 *         of the extended partition.
 *      3. start or end block overlap with existing partitions.
 *              To check this, first make sure that the start block doesnt
 *              overlap with existing partitions. Then, calculate the
 *              possible end block for the given start block that doesnt
 *              overlap with existing partitions. This can be calculated by
 *              first setting the possible end block to the end of the
 *              extended partition (optimistic) and then, checking if there
 *              is any other partition that lies after the start of the
 *              partition being validated. If so, set the possible end to
 *              one block less than the beginning of the next nearest partition
 *              If the actual end block is greater than the calculated end
 *              block, we have an overlap.
 *
 */
static int
cmlb_validate_ext_part(struct cmlb_lun *cl, int part, int epart, uint32_t start,
    uint32_t size)
{
        int i;
        uint32_t end = start + size - 1;
        uint32_t ext_start = cl->cl_fmap[part].fmap_start;
        uint32_t ext_end = ext_start + cl->cl_fmap[part].fmap_nblk - 1;
        uint32_t ts, te;
        uint32_t poss_end = ext_end;

        if (end <= start) {
                return (1);
        }

        /*
         * Check if the logical drive boundaries are within that of the
         * extended partition.
         */
        if (start <= ext_start || start > ext_end || end <= ext_start ||
            end > ext_end) {
                return (1);
        }

        /*
         * epart will be equal to FD_NUMPART if it is the first logical drive.
         * There is no need to check for overlaps with other logical drives,
         * since it is the only logical drive that we have come across so far.
         */
        if (epart == FD_NUMPART) {
                return (0);
        }

        /* Check for overlaps with existing logical drives */
        i = FD_NUMPART;
        ts = cl->cl_fmap[FD_NUMPART].fmap_start;
        te = ts + cl->cl_fmap[FD_NUMPART].fmap_nblk - 1;

        while ((i < epart) && ts && te) {
                if (start >= ts && start <= te) {
                        return (1);
                }

                if ((ts < poss_end) && (ts > start)) {
                        poss_end = ts - 1;
                }

                i++;
                ts = cl->cl_fmap[i].fmap_start;
                te = ts + cl->cl_fmap[i].fmap_nblk - 1;
        }

        if (end > poss_end) {
                return (1);
        }

        return (0);
}


/*
 *    Function: cmlb_is_linux_swap
 *
 * Description: utility routine to verify if a partition is a linux swap
 *              partition or not.
 *
 *   Arguments:
 *      cl              driver soft state (unit) structure
 *      part_start      absolute sector number of the start of the partition
 *                      being verified
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 * Return Code: 0 for success
 *
 *     Context: User and Kernel thread
 *
 * Notes:
 *      The linux swap magic "SWAP-SPACE" or "SWAPSPACE2" is found as the
 *      last 10 bytes of a disk block whose size is that of the linux page
 *      size. This disk block is found at the beginning of the swap partition.
 */
static int
cmlb_is_linux_swap(struct cmlb_lun *cl, uint32_t part_start, void *tg_cookie)
{
        int             i;
        int             rval = -1;
        uint32_t        seek_offset;
        uint32_t        linux_pg_size;
        char            *buf, *linux_swap_magic;
        int             sec_sz = cl->cl_sys_blocksize;
        /* Known linux kernel page sizes */
        uint32_t        linux_pg_size_arr[] = {4096, };

        ASSERT(cl != NULL);
        ASSERT(mutex_owned(CMLB_MUTEX(cl)));

        if ((buf = kmem_zalloc(sec_sz, KM_NOSLEEP)) == NULL) {
                return (ENOMEM);
        }

        /*
         * Check if there is a sane Solaris VTOC
         * If there is a valid vtoc, no need to lookup
         * for the linux swap signature.
         */
        mutex_exit(CMLB_MUTEX(cl));
        rval = DK_TG_READ(cl, buf, part_start + DK_LABEL_LOC,
            sec_sz, tg_cookie);
        mutex_enter(CMLB_MUTEX(cl));
        if (rval != 0) {
                cmlb_dbg(CMLB_ERROR,  cl,
                    "cmlb_is_linux_swap: disk vtoc read err\n");
                rval = EIO;
                goto done;
        }

        if ((((struct dk_label *)buf)->dkl_magic == DKL_MAGIC) &&
            (((struct dk_label *)buf)->dkl_vtoc.v_sanity == VTOC_SANE)) {
                rval = -1;
                goto done;
        }


        /* No valid vtoc, so check for linux swap signature */
        linux_swap_magic = buf + sec_sz - 10;

        for (i = 0; i < sizeof (linux_pg_size_arr)/sizeof (uint32_t); i++) {
                linux_pg_size = linux_pg_size_arr[i];
                seek_offset = linux_pg_size/sec_sz - 1;
                seek_offset += part_start;

                mutex_exit(CMLB_MUTEX(cl));
                rval = DK_TG_READ(cl, buf, seek_offset, sec_sz, tg_cookie);
                mutex_enter(CMLB_MUTEX(cl));

                if (rval != 0) {
                        cmlb_dbg(CMLB_ERROR,  cl,
                            "cmlb_is_linux_swap: disk read err\n");
                        rval = EIO;
                        break;
                }

                rval = -1;

                if ((strncmp(linux_swap_magic, "SWAP-SPACE", 10) == 0) ||
                    (strncmp(linux_swap_magic, "SWAPSPACE2", 10) == 0)) {
                        /* Found a linux swap */
                        rval = 0;
                        break;
                }
        }

done:
        kmem_free(buf, sec_sz);
        return (rval);
}
#endif

/*
 *    Function: cmlb_read_fdisk
 *
 * Description: utility routine to read the fdisk table.
 *
 *   Arguments:
 *      cl              driver soft state (unit) structure
 *      capacity        disk capacity in #blocks
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 * Return Code: 0 for success (includes not reading for no_fdisk_present case
 *              errnos from tg_rw if failed to read the first block.
 *
 *     Context: Kernel thread only (can sleep).
 */
/*ARGSUSED*/
static int
cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity, void *tg_cookie)
{
#if defined(_NO_FDISK_PRESENT)

        cl->cl_solaris_offset = 0;
        cl->cl_solaris_size = capacity;
        bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
        return (0);

#elif defined(_FIRMWARE_NEEDS_FDISK)

        struct ipart    *fdp;
        struct mboot    *mbp;
        struct ipart    fdisk[FD_NUMPART];
        int             i, k;
        char            sigbuf[2];
        caddr_t         bufp;
        int             uidx;
        int             rval;
        int             lba = 0;
        uint_t          solaris_offset; /* offset to solaris part. */
        daddr_t         solaris_size;   /* size of solaris partition */
        uint32_t        blocksize;
#if defined(__i386) || defined(__amd64)
        struct ipart    eparts[2];
        struct ipart    *efdp1 = &eparts[0];
        struct ipart    *efdp2 = &eparts[1];
        int             ext_part_exists = 0;
        int             ld_count = 0;
#endif

        ASSERT(cl != NULL);
        ASSERT(mutex_owned(CMLB_MUTEX(cl)));

        /*
         * Start off assuming no fdisk table
         */
        solaris_offset = 0;
        solaris_size   = capacity;

        blocksize = cl->cl_tgt_blocksize;

        bufp = kmem_zalloc(blocksize, KM_SLEEP);

        mutex_exit(CMLB_MUTEX(cl));
        rval = DK_TG_READ(cl, bufp, 0, blocksize, tg_cookie);
        mutex_enter(CMLB_MUTEX(cl));

        if (rval != 0) {
                cmlb_dbg(CMLB_ERROR,  cl,
                    "cmlb_read_fdisk: fdisk read err\n");
                bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
                goto done;
        }

        mbp = (struct mboot *)bufp;

        /*
         * The fdisk table does not begin on a 4-byte boundary within the
         * master boot record, so we copy it to an aligned structure to avoid
         * alignment exceptions on some processors.
         */
        bcopy(&mbp->parts[0], fdisk, sizeof (fdisk));

        /*
         * Check for lba support before verifying sig; sig might not be
         * there, say on a blank disk, but the max_chs mark may still
         * be present.
         *
         * Note: LBA support and BEFs are an x86-only concept but this
         * code should work OK on SPARC as well.
         */

        /*
         * First, check for lba-access-ok on root node (or prom root node)
         * if present there, don't need to search fdisk table.
         */
        if (ddi_getprop(DDI_DEV_T_ANY, ddi_root_node(), 0,
            "lba-access-ok", 0) != 0) {
                /* All drives do LBA; don't search fdisk table */
                lba = 1;
        } else {
                /* Okay, look for mark in fdisk table */
                for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) {
                        /* accumulate "lba" value from all partitions */
                        lba = (lba || cmlb_has_max_chs_vals(fdp));
                }
        }

        if (lba != 0) {
                dev_t dev = cmlb_make_device(cl);

                if (ddi_getprop(dev, CMLB_DEVINFO(cl), DDI_PROP_DONTPASS,
                    "lba-access-ok", 0) == 0) {
                        /* not found; create it */
                        if (ddi_prop_create(dev, CMLB_DEVINFO(cl), 0,
                            "lba-access-ok", NULL, 0) !=
                            DDI_PROP_SUCCESS) {
                                cmlb_dbg(CMLB_ERROR,  cl,
                                    "cmlb_read_fdisk: Can't create lba "
                                    "property for instance %d\n",
                                    ddi_get_instance(CMLB_DEVINFO(cl)));
                        }
                }
        }

        bcopy(&mbp->signature, sigbuf, sizeof (sigbuf));

        /*
         * Endian-independent signature check
         */
        if (((sigbuf[1] & 0xFF) != ((MBB_MAGIC >> 8) & 0xFF)) ||
            (sigbuf[0] != (MBB_MAGIC & 0xFF))) {
                cmlb_dbg(CMLB_ERROR,  cl,
                    "cmlb_read_fdisk: no fdisk\n");
                bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
                goto done;
        }

#ifdef CMLBDEBUG
        if (cmlb_level_mask & CMLB_LOGMASK_INFO) {
                fdp = fdisk;
                cmlb_dbg(CMLB_INFO,  cl, "cmlb_read_fdisk:\n");
                cmlb_dbg(CMLB_INFO,  cl, "         relsect    "
                    "numsect         sysid       bootid\n");
                for (i = 0; i < FD_NUMPART; i++, fdp++) {
                        cmlb_dbg(CMLB_INFO,  cl,
                            "    %d:  %8d   %8d     0x%08x     0x%08x\n",
                            i, fdp->relsect, fdp->numsect,
                            fdp->systid, fdp->bootid);
                }
        }
#endif

        /*
         * Try to find the unix partition
         */
        uidx = -1;
        solaris_offset = 0;
        solaris_size   = 0;

        for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) {
                uint32_t relsect;
                uint32_t numsect;
                uchar_t systid;
#if defined(__i386) || defined(__amd64)
                /*
                 * Stores relative block offset from the beginning of the
                 * Extended Partition.
                 */
                int     ext_relsect = 0;
#endif

                if (fdp->numsect == 0) {
                        cl->cl_fmap[i].fmap_start = 0;
                        cl->cl_fmap[i].fmap_nblk  = 0;
                        continue;
                }

                /*
                 * Data in the fdisk table is little-endian.
                 */
                relsect = LE_32(fdp->relsect);
                numsect = LE_32(fdp->numsect);

                cl->cl_fmap[i].fmap_start = relsect;
                cl->cl_fmap[i].fmap_nblk  = numsect;
                cl->cl_fmap[i].fmap_systid = LE_8(fdp->systid);

#if defined(__i386) || defined(__amd64)
                /* Support only one extended partition per LUN */
                if ((fdp->systid == EXTDOS || fdp->systid == FDISK_EXTLBA) &&
                    (ext_part_exists == 0)) {
                        int j;
                        uint32_t logdrive_offset;
                        uint32_t ext_numsect;
                        uint32_t abs_secnum;

                        ext_part_exists = 1;

                        for (j = FD_NUMPART; j < FDISK_PARTS; j++) {
                                mutex_exit(CMLB_MUTEX(cl));
                                rval = DK_TG_READ(cl, bufp,
                                    (relsect + ext_relsect), blocksize,
                                    tg_cookie);
                                mutex_enter(CMLB_MUTEX(cl));

                                if (rval != 0) {
                                        cmlb_dbg(CMLB_ERROR,  cl,
                                            "cmlb_read_fdisk: Extended "
                                            "partition read err\n");
                                        goto done;
                                }
                                /*
                                 * The first ipart entry provides the offset
                                 * at which the logical drive starts off from
                                 * the beginning of the container partition
                                 * and the size of the logical drive.
                                 * The second ipart entry provides the offset
                                 * of the next container partition from the
                                 * beginning of the extended partition.
                                 */
                                bcopy(&bufp[FDISK_PART_TABLE_START], eparts,
                                    sizeof (eparts));
                                logdrive_offset = LE_32(efdp1->relsect);
                                ext_numsect = LE_32(efdp1->numsect);
                                systid = LE_8(efdp1->systid);
                                if (logdrive_offset <= 0 || ext_numsect <= 0)
                                        break;
                                abs_secnum = relsect + ext_relsect +
                                    logdrive_offset;

                                /* Boundary condition and overlap checking */
                                if (cmlb_validate_ext_part(cl, i, j, abs_secnum,
                                    ext_numsect)) {
                                        break;
                                }

                                if ((cl->cl_fmap[j].fmap_start != abs_secnum) ||
                                    (cl->cl_fmap[j].fmap_nblk != ext_numsect) ||
                                    (cl->cl_fmap[j].fmap_systid != systid)) {
                                        /*
                                         * Indicates change from previous
                                         * partinfo. Need to recreate
                                         * logical device nodes.
                                         */
                                        cl->cl_update_ext_minor_nodes = 1;
                                }
                                cl->cl_fmap[j].fmap_start = abs_secnum;
                                cl->cl_fmap[j].fmap_nblk  = ext_numsect;
                                cl->cl_fmap[j].fmap_systid = systid;
                                ld_count++;

                                if ((efdp1->systid == SUNIXOS &&
                                    (cmlb_is_linux_swap(cl, abs_secnum,
                                    tg_cookie) != 0)) ||
                                    efdp1->systid == SUNIXOS2) {
                                        if (uidx == -1) {
                                                uidx = 0;
                                                solaris_offset = abs_secnum;
                                                solaris_size = ext_numsect;
                                        }
                                }

                                if ((ext_relsect = LE_32(efdp2->relsect)) == 0)
                                        break;
                        }
                }

#endif

                if (fdp->systid != SUNIXOS &&
                    fdp->systid != SUNIXOS2 &&
                    fdp->systid != EFI_PMBR) {
                        continue;
                }

                /*
                 * use the last active solaris partition id found
                 * (there should only be 1 active partition id)
                 *
                 * if there are no active solaris partition id
                 * then use the first inactive solaris partition id
                 */
                if ((uidx == -1) || (fdp->bootid == ACTIVE)) {
#if defined(__i386) || defined(__amd64)
                        if (fdp->systid != SUNIXOS ||
                            (fdp->systid == SUNIXOS &&
                            (cmlb_is_linux_swap(cl, relsect,
                            tg_cookie) != 0))) {
#endif
                                uidx = i;
                                solaris_offset = relsect;
                                solaris_size   = numsect;
#if defined(__i386) || defined(__amd64)
                        }
#endif
                }
        }
#if defined(__i386) || defined(__amd64)
        if (ld_count < cl->cl_logical_drive_count) {
                /*
                 * Some/all logical drives were deleted. Clear out
                 * the fmap entries correspoding to those deleted drives.
                 */
                for (k = ld_count + FD_NUMPART;
                    k < cl->cl_logical_drive_count + FD_NUMPART; k++) {
                        cl->cl_fmap[k].fmap_start = 0;
                        cl->cl_fmap[k].fmap_nblk  = 0;
                        cl->cl_fmap[k].fmap_systid = 0;
                }
                cl->cl_update_ext_minor_nodes = 1;
        }
        if (cl->cl_update_ext_minor_nodes) {
                rval = cmlb_update_ext_minor_nodes(cl, ld_count);
                if (rval != 0) {
                        goto done;
                }
        }
#endif
        cmlb_dbg(CMLB_INFO,  cl, "fdisk 0x%x 0x%lx",
            cl->cl_solaris_offset, cl->cl_solaris_size);
done:

        /*
         * Clear the VTOC info, only if the Solaris partition entry
         * has moved, changed size, been deleted, or if the size of
         * the partition is too small to even fit the label sector.
         */
        if ((cl->cl_solaris_offset != solaris_offset) ||
            (cl->cl_solaris_size != solaris_size) ||
            solaris_size <= DK_LABEL_LOC) {
                cmlb_dbg(CMLB_INFO,  cl, "fdisk moved 0x%x 0x%lx",
                    solaris_offset, solaris_size);
                bzero(&cl->cl_g, sizeof (struct dk_geom));
                bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
                bzero(&cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
                cl->cl_f_geometry_is_valid = B_FALSE;
        }
        cl->cl_solaris_offset = solaris_offset;
        cl->cl_solaris_size = solaris_size;
        kmem_free(bufp, blocksize);
        return (rval);

#else   /* #elif defined(_FIRMWARE_NEEDS_FDISK) */
#error "fdisk table presence undetermined for this platform."
#endif  /* #if defined(_NO_FDISK_PRESENT) */
}

static void
cmlb_swap_efi_gpt(efi_gpt_t *e)
{
        _NOTE(ASSUMING_PROTECTED(*e))
        e->efi_gpt_Signature = LE_64(e->efi_gpt_Signature);
        e->efi_gpt_Revision = LE_32(e->efi_gpt_Revision);
        e->efi_gpt_HeaderSize = LE_32(e->efi_gpt_HeaderSize);
        e->efi_gpt_HeaderCRC32 = LE_32(e->efi_gpt_HeaderCRC32);
        e->efi_gpt_MyLBA = LE_64(e->efi_gpt_MyLBA);
        e->efi_gpt_AlternateLBA = LE_64(e->efi_gpt_AlternateLBA);
        e->efi_gpt_FirstUsableLBA = LE_64(e->efi_gpt_FirstUsableLBA);
        e->efi_gpt_LastUsableLBA = LE_64(e->efi_gpt_LastUsableLBA);
        UUID_LE_CONVERT(e->efi_gpt_DiskGUID, e->efi_gpt_DiskGUID);
        e->efi_gpt_PartitionEntryLBA = LE_64(e->efi_gpt_PartitionEntryLBA);
        e->efi_gpt_NumberOfPartitionEntries =
            LE_32(e->efi_gpt_NumberOfPartitionEntries);
        e->efi_gpt_SizeOfPartitionEntry =
            LE_32(e->efi_gpt_SizeOfPartitionEntry);
        e->efi_gpt_PartitionEntryArrayCRC32 =
            LE_32(e->efi_gpt_PartitionEntryArrayCRC32);
}

static void
cmlb_swap_efi_gpe(int nparts, efi_gpe_t *p)
{
        int i;

        _NOTE(ASSUMING_PROTECTED(*p))
        for (i = 0; i < nparts; i++) {
                UUID_LE_CONVERT(p[i].efi_gpe_PartitionTypeGUID,
                    p[i].efi_gpe_PartitionTypeGUID);
                p[i].efi_gpe_StartingLBA = LE_64(p[i].efi_gpe_StartingLBA);
                p[i].efi_gpe_EndingLBA = LE_64(p[i].efi_gpe_EndingLBA);
                /* PartitionAttrs */
        }
}

static int
cmlb_validate_efi(efi_gpt_t *labp)
{
        if (labp->efi_gpt_Signature != EFI_SIGNATURE)
                return (EINVAL);
        /* at least 96 bytes in this version of the spec. */
        if (sizeof (efi_gpt_t) - sizeof (labp->efi_gpt_Reserved2) >
            labp->efi_gpt_HeaderSize)
                return (EINVAL);
        /* this should be 128 bytes */
        if (labp->efi_gpt_SizeOfPartitionEntry != sizeof (efi_gpe_t))
                return (EINVAL);
        return (0);
}

/*
 * This function returns B_FALSE if there is a valid MBR signature and no
 * partition table entries of type EFI_PMBR (0xEE). Otherwise it returns B_TRUE.
 *
 * The EFI spec (1.10 and later) requires having a Protective MBR (PMBR) to
 * recognize the disk as GPT partitioned. However, some other OS creates an MBR
 * where a PMBR entry is not the only one. Also, if the first block has been
 * corrupted, currently best attempt to allow data access would be to try to
 * check for GPT headers. Hence in case of more than one partition entry, but
 * at least one EFI_PMBR partition type or no valid magic number, the function
 * returns B_TRUE to continue with looking for GPT header.
 */

static boolean_t
cmlb_check_efi_mbr(uchar_t *buf, boolean_t *is_mbr)
{
        struct ipart    *fdp;
        struct mboot    *mbp = (struct mboot *)buf;
        struct ipart    fdisk[FD_NUMPART];
        int             i;

        if (is_mbr != NULL)
                *is_mbr = B_TRUE;

        if (LE_16(mbp->signature) != MBB_MAGIC) {
                if (is_mbr != NULL)
                        *is_mbr = B_FALSE;
                return (B_TRUE);
        }

        bcopy(&mbp->parts[0], fdisk, sizeof (fdisk));

        for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) {
                if (fdp->systid == EFI_PMBR)
                        return (B_TRUE);
        }

        return (B_FALSE);
}

static int
cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags,
    void *tg_cookie)
{
        int             i;
        int             rval = 0;
        efi_gpe_t       *partitions;
        uchar_t         *buf;
        uint_t          lbasize;        /* is really how much to read */
        diskaddr_t      cap = 0;
        uint_t          nparts;
        diskaddr_t      gpe_lba;
        diskaddr_t      alternate_lba;
        int             iofailed = 0;
        struct uuid     uuid_type_reserved = EFI_RESERVED;
#if defined(_FIRMWARE_NEEDS_FDISK)
        boolean_t       is_mbr;
#endif

        ASSERT(mutex_owned(CMLB_MUTEX(cl)));

        lbasize = cl->cl_sys_blocksize;

        cl->cl_reserved = -1;
        mutex_exit(CMLB_MUTEX(cl));

        buf = kmem_zalloc(EFI_MIN_ARRAY_SIZE, KM_SLEEP);

        rval = DK_TG_READ(cl, buf,  0, lbasize, tg_cookie);
        if (rval) {
                iofailed = 1;
                goto done_err;
        }
        if (((struct dk_label *)buf)->dkl_magic == DKL_MAGIC) {
                /* not ours */
                rval = ESRCH;
                goto done_err;
        }

#if defined(_FIRMWARE_NEEDS_FDISK)
        if (!cmlb_check_efi_mbr(buf, &is_mbr)) {
                if (is_mbr)
                        rval = ESRCH;
                else
                        rval = EINVAL;
                goto done_err;
        }
#else
        if (!cmlb_check_efi_mbr(buf, NULL)) {
                rval = EINVAL;
                goto done_err;
        }

#endif

        rval = DK_TG_READ(cl, buf, 1, lbasize, tg_cookie);
        if (rval) {
                iofailed = 1;
                goto done_err;
        }
        cmlb_swap_efi_gpt((efi_gpt_t *)buf);

        if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0) {
                /*
                 * Couldn't read the primary, try the backup.  Our
                 * capacity at this point could be based on CHS, so
                 * check what the device reports.
                 */
                rval = DK_TG_GETCAP(cl, &cap, tg_cookie);
                if (rval) {
                        iofailed = 1;
                        goto done_err;
                }

                /*
                 * CMLB_OFF_BY_ONE case, we check the next to last block first
                 * for backup GPT header, otherwise check the last block.
                 */

                if ((rval = DK_TG_READ(cl, buf,
                    cap - ((cl->cl_alter_behavior & CMLB_OFF_BY_ONE) ? 2 : 1),
                    lbasize, tg_cookie))
                    != 0) {
                        iofailed = 1;
                        goto done_err;
                }
                cmlb_swap_efi_gpt((efi_gpt_t *)buf);

                if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0) {

                        if (!(cl->cl_alter_behavior & CMLB_OFF_BY_ONE))
                                goto done_err;
                        if ((rval = DK_TG_READ(cl, buf, cap - 1, lbasize,
                            tg_cookie)) != 0)
                                goto done_err;
                        cmlb_swap_efi_gpt((efi_gpt_t *)buf);
                        if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0)
                                goto done_err;
                }
                if (!(flags & CMLB_SILENT))
                        cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
                            "primary label corrupt; using backup\n");
        }

        nparts = ((efi_gpt_t *)buf)->efi_gpt_NumberOfPartitionEntries;
        gpe_lba = ((efi_gpt_t *)buf)->efi_gpt_PartitionEntryLBA;
        alternate_lba = ((efi_gpt_t *)buf)->efi_gpt_AlternateLBA;

        rval = DK_TG_READ(cl, buf, gpe_lba, EFI_MIN_ARRAY_SIZE, tg_cookie);
        if (rval) {
                iofailed = 1;
                goto done_err;
        }
        partitions = (efi_gpe_t *)buf;

        if (nparts > MAXPART) {
                nparts = MAXPART;
        }
        cmlb_swap_efi_gpe(nparts, partitions);

        mutex_enter(CMLB_MUTEX(cl));

        /* Fill in partition table. */
        for (i = 0; i < nparts; i++) {
                if (partitions->efi_gpe_StartingLBA != 0 ||
                    partitions->efi_gpe_EndingLBA != 0) {
                        cl->cl_map[i].dkl_cylno =
                            partitions->efi_gpe_StartingLBA;
                        cl->cl_map[i].dkl_nblk =
                            partitions->efi_gpe_EndingLBA -
                            partitions->efi_gpe_StartingLBA + 1;
                        cl->cl_offset[i] =
                            partitions->efi_gpe_StartingLBA;
                }

                if (cl->cl_reserved == -1) {
                        if (bcmp(&partitions->efi_gpe_PartitionTypeGUID,
                            &uuid_type_reserved, sizeof (struct uuid)) == 0) {
                                cl->cl_reserved = i;
                        }
                }
                if (i == WD_NODE) {
                        /*
                         * minor number 7 corresponds to the whole disk
                         * if the disk capacity is expanded after disk is
                         * labeled, minor number 7 represents the capacity
                         * indicated by the disk label.
                         */
                        cl->cl_map[i].dkl_cylno = 0;
                        if (alternate_lba == 1) {
                                /*
                                 * We are using backup label. Since we can
                                 * find a valid label at the end of disk,
                                 * the disk capacity is not expanded.
                                 */
                                cl->cl_map[i].dkl_nblk = capacity;
                        } else {
                                cl->cl_map[i].dkl_nblk = alternate_lba + 1;
                        }
                        cl->cl_offset[i] = 0;
                }
                partitions++;
        }
        cl->cl_solaris_offset = 0;
        cl->cl_solaris_size = capacity;
        cl->cl_label_from_media = CMLB_LABEL_EFI;
        cl->cl_f_geometry_is_valid = B_TRUE;

        /* clear the vtoc label */
        bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));

        kmem_free(buf, EFI_MIN_ARRAY_SIZE);
        return (0);

done_err:
        kmem_free(buf, EFI_MIN_ARRAY_SIZE);
        mutex_enter(CMLB_MUTEX(cl));
done_err1:
        /*
         * if we didn't find something that could look like a VTOC
         * and the disk is over 1TB, we know there isn't a valid label.
         * Otherwise let cmlb_uselabel decide what to do.  We only
         * want to invalidate this if we're certain the label isn't
         * valid because cmlb_prop_op will now fail, which in turn
         * causes things like opens and stats on the partition to fail.
         */
        if ((capacity > CMLB_EXTVTOC_LIMIT) && (rval != ESRCH) && !iofailed) {
                cl->cl_f_geometry_is_valid = B_FALSE;
        }
        return (rval);
}


/*
 *    Function: cmlb_uselabel
 *
 * Description: Validate the disk label and update the relevant data (geometry,
 *              partition, vtoc, and capacity data) in the cmlb_lun struct.
 *              Marks the geometry of the unit as being valid.
 *
 *   Arguments: cl: unit struct.
 *              dk_label: disk label
 *
 * Return Code: CMLB_LABEL_IS_VALID: Label read from disk is OK; geometry,
 *              partition, vtoc, and capacity data are good.
 *
 *              CMLB_LABEL_IS_INVALID: Magic number or checksum error in the
 *              label; or computed capacity does not jibe with capacity
 *              reported from the READ CAPACITY command.
 *
 *     Context: Kernel thread only (can sleep).
 */
static int
cmlb_uselabel(struct cmlb_lun *cl, struct dk_label *labp, int flags)
{
        short           *sp;
        short           sum;
        short           count;
        int             label_error = CMLB_LABEL_IS_VALID;
        int             i;
        diskaddr_t      label_capacity;
        uint32_t        part_end;
        diskaddr_t      track_capacity;
#if defined(_SUNOS_VTOC_16)
        struct  dkl_partition   *vpartp;
#endif
        ASSERT(cl != NULL);
        ASSERT(mutex_owned(CMLB_MUTEX(cl)));

        /* Validate the magic number of the label. */
        if (labp->dkl_magic != DKL_MAGIC) {
                return (CMLB_LABEL_IS_INVALID);
        }

        /* Validate the checksum of the label. */
        sp  = (short *)labp;
        sum = 0;
        count = sizeof (struct dk_label) / sizeof (short);
        while (count--)  {
                sum ^= *sp++;
        }

        if (sum != 0) {
#if defined(_SUNOS_VTOC_16)
                if (!ISCD(cl)) {
#elif defined(_SUNOS_VTOC_8)
                if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
#endif
                        if (!(flags & CMLB_SILENT))
                                cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
                                    CE_WARN,
                                    "Corrupt label - label checksum failed\n");
                }
                return (CMLB_LABEL_IS_INVALID);
        }


        /*
         * Fill in geometry structure with data from label.
         */
        bzero(&cl->cl_g, sizeof (struct dk_geom));
        cl->cl_g.dkg_ncyl   = labp->dkl_ncyl;
        cl->cl_g.dkg_acyl   = labp->dkl_acyl;
        cl->cl_g.dkg_bcyl   = 0;
        cl->cl_g.dkg_nhead  = labp->dkl_nhead;
        cl->cl_g.dkg_nsect  = labp->dkl_nsect;
        cl->cl_g.dkg_intrlv = labp->dkl_intrlv;

#if defined(_SUNOS_VTOC_8)
        cl->cl_g.dkg_gap1   = labp->dkl_gap1;
        cl->cl_g.dkg_gap2   = labp->dkl_gap2;
        cl->cl_g.dkg_bhead  = labp->dkl_bhead;
#endif
#if defined(_SUNOS_VTOC_16)
        cl->cl_dkg_skew = labp->dkl_skew;
#endif

#if defined(__i386) || defined(__amd64)
        cl->cl_g.dkg_apc = labp->dkl_apc;
#endif

        /*
         * Currently we rely on the values in the label being accurate. If
         * dkl_rpm or dkl_pcly are zero in the label, use a default value.
         *
         * Note: In the future a MODE SENSE may be used to retrieve this data,
         * although this command is optional in SCSI-2.
         */
        cl->cl_g.dkg_rpm  = (labp->dkl_rpm  != 0) ? labp->dkl_rpm  : 3600;
        cl->cl_g.dkg_pcyl = (labp->dkl_pcyl != 0) ? labp->dkl_pcyl :
            (cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl);

        /*
         * The Read and Write reinstruct values may not be valid
         * for older disks.
         */
        cl->cl_g.dkg_read_reinstruct  = labp->dkl_read_reinstruct;
        cl->cl_g.dkg_write_reinstruct = labp->dkl_write_reinstruct;

        /* Fill in partition table. */
#if defined(_SUNOS_VTOC_8)
        for (i = 0; i < NDKMAP; i++) {
                cl->cl_map[i].dkl_cylno = labp->dkl_map[i].dkl_cylno;
                cl->cl_map[i].dkl_nblk  = labp->dkl_map[i].dkl_nblk;
        }
#endif
#if  defined(_SUNOS_VTOC_16)
        vpartp          = labp->dkl_vtoc.v_part;
        track_capacity  = labp->dkl_nhead * labp->dkl_nsect;

        /* Prevent divide by zero */
        if (track_capacity == 0) {
                if (!(flags & CMLB_SILENT))
                        cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
                            "Corrupt label - zero nhead or nsect value\n");

                return (CMLB_LABEL_IS_INVALID);
        }

        for (i = 0; i < NDKMAP; i++, vpartp++) {
                cl->cl_map[i].dkl_cylno = vpartp->p_start / track_capacity;
                cl->cl_map[i].dkl_nblk  = vpartp->p_size;
        }
#endif

        /* Fill in VTOC Structure. */
        bcopy(&labp->dkl_vtoc, &cl->cl_vtoc, sizeof (struct dk_vtoc));
#if defined(_SUNOS_VTOC_8)
        /*
         * The 8-slice vtoc does not include the ascii label; save it into
         * the device's soft state structure here.
         */
        bcopy(labp->dkl_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII);
#endif

        /* Now look for a valid capacity. */
        track_capacity  = (cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect);
        label_capacity  = (cl->cl_g.dkg_ncyl  * track_capacity);

        if (cl->cl_g.dkg_acyl) {
#if defined(__i386) || defined(__amd64)
                /* we may have > 1 alts cylinder */
                label_capacity += (track_capacity * cl->cl_g.dkg_acyl);
#else
                label_capacity += track_capacity;
#endif
        }

        /*
         * Force check here to ensure the computed capacity is valid.
         * If capacity is zero, it indicates an invalid label and
         * we should abort updating the relevant data then.
         */
        if (label_capacity == 0) {
                if (!(flags & CMLB_SILENT))
                        cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
                            "Corrupt label - no valid capacity could be "
                            "retrieved\n");

                return (CMLB_LABEL_IS_INVALID);
        }

        /* Mark the geometry as valid. */
        cl->cl_f_geometry_is_valid = B_TRUE;

        /*
         * if we got invalidated when mutex exit and entered again,
         * if blockcount different than when we came in, need to
         * retry from beginning of cmlb_validate_geometry.
         * revisit this on next phase of utilizing this for
         * sd.
         */

        if (label_capacity <= cl->cl_blockcount) {
#if defined(_SUNOS_VTOC_8)
                /*
                 * We can't let this happen on drives that are subdivided
                 * into logical disks (i.e., that have an fdisk table).
                 * The cl_blockcount field should always hold the full media
                 * size in sectors, period.  This code would overwrite
                 * cl_blockcount with the size of the Solaris fdisk partition.
                 */
                cmlb_dbg(CMLB_ERROR,  cl,
                    "cmlb_uselabel: Label %d blocks; Drive %d blocks\n",
                    label_capacity, cl->cl_blockcount);
                cl->cl_solaris_size = label_capacity;

#endif  /* defined(_SUNOS_VTOC_8) */
                goto done;
        }

        if (ISCD(cl)) {
                /* For CDROMs, we trust that the data in the label is OK. */
#if defined(_SUNOS_VTOC_8)
                for (i = 0; i < NDKMAP; i++) {
                        part_end = labp->dkl_nhead * labp->dkl_nsect *
                            labp->dkl_map[i].dkl_cylno +
                            labp->dkl_map[i].dkl_nblk  - 1;

                        if ((labp->dkl_map[i].dkl_nblk) &&
                            (part_end > cl->cl_blockcount)) {
                                cl->cl_f_geometry_is_valid = B_FALSE;
                                break;
                        }
                }
#endif
#if defined(_SUNOS_VTOC_16)
                vpartp = &(labp->dkl_vtoc.v_part[0]);
                for (i = 0; i < NDKMAP; i++, vpartp++) {
                        part_end = vpartp->p_start + vpartp->p_size;
                        if ((vpartp->p_size > 0) &&
                            (part_end > cl->cl_blockcount)) {
                                cl->cl_f_geometry_is_valid = B_FALSE;
                                break;
                        }
                }
#endif
        } else {
                /* label_capacity > cl->cl_blockcount */
                if (!(flags & CMLB_SILENT)) {
                        cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
                            "Corrupt label - bad geometry\n");
                        cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_CONT,
                            "Label says %llu blocks; Drive says %llu blocks\n",
                            label_capacity, cl->cl_blockcount);
                }
                cl->cl_f_geometry_is_valid = B_FALSE;
                label_error = CMLB_LABEL_IS_INVALID;
        }

done:

        cmlb_dbg(CMLB_INFO,  cl, "cmlb_uselabel: (label geometry)\n");
        cmlb_dbg(CMLB_INFO,  cl,
            "   ncyl: %d; acyl: %d; nhead: %d; nsect: %d\n",
            cl->cl_g.dkg_ncyl,  cl->cl_g.dkg_acyl,
            cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);

        cmlb_dbg(CMLB_INFO,  cl,
            "   label_capacity: %d; intrlv: %d; rpm: %d\n",
            cl->cl_blockcount, cl->cl_g.dkg_intrlv, cl->cl_g.dkg_rpm);
        cmlb_dbg(CMLB_INFO,  cl, "   wrt_reinstr: %d; rd_reinstr: %d\n",
            cl->cl_g.dkg_write_reinstruct, cl->cl_g.dkg_read_reinstruct);

        ASSERT(mutex_owned(CMLB_MUTEX(cl)));

        return (label_error);
}


/*
 *    Function: cmlb_build_default_label
 *
 * Description: Generate a default label for those devices that do not have
 *              one, e.g., new media, removable cartridges, etc..
 *
 *     Context: Kernel thread only
 */
/*ARGSUSED*/
static void
cmlb_build_default_label(struct cmlb_lun *cl, void *tg_cookie)
{
#if defined(_SUNOS_VTOC_16)
        uint_t  phys_spc;
        uint_t  disksize;
        struct  dk_geom cl_g;
        diskaddr_t capacity;
#endif

        ASSERT(cl != NULL);
        ASSERT(mutex_owned(CMLB_MUTEX(cl)));

#if defined(_SUNOS_VTOC_8)
        /*
         * Note: This is a legacy check for non-removable devices on VTOC_8
         * only. This may be a valid check for VTOC_16 as well.
         * Once we understand why there is this difference between SPARC and
         * x86 platform, we could remove this legacy check.
         */
        if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
                return;
        }
#endif

        bzero(&cl->cl_g, sizeof (struct dk_geom));
        bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
        bzero(&cl->cl_map, NDKMAP * (sizeof (struct dk_map)));

#if defined(_SUNOS_VTOC_8)

        /*
         * It's a REMOVABLE media, therefore no label (on sparc, anyway).
         * But it is still necessary to set up various geometry information,
         * and we are doing this here.
         */

        /*
         * For the rpm, we use the minimum for the disk.  For the head, cyl,
         * and number of sector per track, if the capacity <= 1GB, head = 64,
         * sect = 32.  else head = 255, sect 63 Note: the capacity should be
         * equal to C*H*S values.  This will cause some truncation of size due
         * to round off errors. For CD-ROMs, this truncation can have adverse
         * side effects, so returning ncyl and nhead as 1. The nsect will
         * overflow for most of CD-ROMs as nsect is of type ushort. (4190569)
         */
        cl->cl_solaris_size = cl->cl_blockcount;
        if (ISCD(cl)) {
                tg_attribute_t tgattribute;
                int is_writable;
                /*
                 * Preserve the old behavior for non-writable
                 * medias. Since dkg_nsect is a ushort, it
                 * will lose bits as cdroms have more than
                 * 65536 sectors. So if we recalculate
                 * capacity, it will become much shorter.
                 * But the dkg_* information is not
                 * used for CDROMs so it is OK. But for
                 * Writable CDs we need this information
                 * to be valid (for newfs say). So we
                 * make nsect and nhead > 1 that way
                 * nsect can still stay within ushort limit
                 * without losing any bits.
                 */

                bzero(&tgattribute, sizeof (tg_attribute_t));

                mutex_exit(CMLB_MUTEX(cl));
                is_writable =
                    (DK_TG_GETATTRIBUTE(cl, &tgattribute, tg_cookie) == 0) ?
                    tgattribute.media_is_writable : 1;
                mutex_enter(CMLB_MUTEX(cl));

                if (is_writable) {
                        cl->cl_g.dkg_nhead = 64;
                        cl->cl_g.dkg_nsect = 32;
                        cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32);
                        cl->cl_solaris_size = (diskaddr_t)cl->cl_g.dkg_ncyl *
                            cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
                } else {
                        cl->cl_g.dkg_ncyl  = 1;
                        cl->cl_g.dkg_nhead = 1;
                        cl->cl_g.dkg_nsect = cl->cl_blockcount;
                }
        } else {
                if (cl->cl_blockcount < 160) {
                        /* Less than 80K */
                        cl->cl_g.dkg_nhead = 1;
                        cl->cl_g.dkg_ncyl = cl->cl_blockcount;
                        cl->cl_g.dkg_nsect = 1;
                } else if (cl->cl_blockcount <= 0x1000) {
                        /* unlabeled SCSI floppy device */
                        cl->cl_g.dkg_nhead = 2;
                        cl->cl_g.dkg_ncyl = 80;
                        cl->cl_g.dkg_nsect = cl->cl_blockcount / (2 * 80);
                } else if (cl->cl_blockcount <= 0x200000) {
                        cl->cl_g.dkg_nhead = 64;
                        cl->cl_g.dkg_nsect = 32;
                        cl->cl_g.dkg_ncyl  = cl->cl_blockcount / (64 * 32);
                } else {
                        cl->cl_g.dkg_nhead = 255;

                        cl->cl_g.dkg_nsect = ((cl->cl_blockcount +
                            (UINT16_MAX * 255 * 63) - 1) /
                            (UINT16_MAX * 255 * 63)) * 63;

                        if (cl->cl_g.dkg_nsect == 0)
                                cl->cl_g.dkg_nsect = (UINT16_MAX / 63) * 63;

                        cl->cl_g.dkg_ncyl = cl->cl_blockcount /
                            (255 * cl->cl_g.dkg_nsect);
                }

                cl->cl_solaris_size =
                    (diskaddr_t)cl->cl_g.dkg_ncyl * cl->cl_g.dkg_nhead *
                    cl->cl_g.dkg_nsect;

        }

        cl->cl_g.dkg_acyl       = 0;
        cl->cl_g.dkg_bcyl       = 0;
        cl->cl_g.dkg_rpm        = 200;
        cl->cl_asciilabel[0]    = '\0';
        cl->cl_g.dkg_pcyl       = cl->cl_g.dkg_ncyl;

        cl->cl_map[0].dkl_cylno = 0;
        cl->cl_map[0].dkl_nblk  = cl->cl_solaris_size;

        cl->cl_map[2].dkl_cylno = 0;
        cl->cl_map[2].dkl_nblk  = cl->cl_solaris_size;

#elif defined(_SUNOS_VTOC_16)

        if (cl->cl_solaris_size == 0) {
                /*
                 * Got fdisk table but no solaris entry therefore
                 * don't create a default label
                 */
                cl->cl_f_geometry_is_valid = B_TRUE;
                return;
        }

        /*
         * For CDs we continue to use the physical geometry to calculate
         * number of cylinders. All other devices must convert the
         * physical geometry (cmlb_geom) to values that will fit
         * in a dk_geom structure.
         */
        if (ISCD(cl)) {
                phys_spc = cl->cl_pgeom.g_nhead * cl->cl_pgeom.g_nsect;
        } else {
                /* Convert physical geometry to disk geometry */
                bzero(&cl_g, sizeof (struct dk_geom));

                /*
                 * Refer to comments related to off-by-1 at the
                 * header of this file.
                 * Before calculating geometry, capacity should be
                 * decreased by 1.
                 */

                if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE)
                        capacity = cl->cl_blockcount - 1;
                else
                        capacity = cl->cl_blockcount;


                cmlb_convert_geometry(cl, capacity, &cl_g, tg_cookie);
                bcopy(&cl_g, &cl->cl_g, sizeof (cl->cl_g));
                phys_spc = cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
        }

        if (phys_spc == 0)
                return;
        cl->cl_g.dkg_pcyl = cl->cl_solaris_size / phys_spc;
        if (cl->cl_alter_behavior & CMLB_FAKE_LABEL_ONE_PARTITION) {
                /* disable devid */
                cl->cl_g.dkg_ncyl = cl->cl_g.dkg_pcyl;
                disksize = cl->cl_solaris_size;
        } else {
                cl->cl_g.dkg_acyl = DK_ACYL;
                cl->cl_g.dkg_ncyl = cl->cl_g.dkg_pcyl - DK_ACYL;
                disksize = cl->cl_g.dkg_ncyl * phys_spc;
        }

        if (ISCD(cl)) {
                /*
                 * CD's don't use the "heads * sectors * cyls"-type of
                 * geometry, but instead use the entire capacity of the media.
                 */
                disksize = cl->cl_solaris_size;
                cl->cl_g.dkg_nhead = 1;
                cl->cl_g.dkg_nsect = 1;
                cl->cl_g.dkg_rpm =
                    (cl->cl_pgeom.g_rpm == 0) ? 200 : cl->cl_pgeom.g_rpm;

                cl->cl_vtoc.v_part[0].p_start = 0;
                cl->cl_vtoc.v_part[0].p_size  = disksize;
                cl->cl_vtoc.v_part[0].p_tag   = V_BACKUP;
                cl->cl_vtoc.v_part[0].p_flag  = V_UNMNT;

                cl->cl_map[0].dkl_cylno = 0;
                cl->cl_map[0].dkl_nblk  = disksize;
                cl->cl_offset[0] = 0;

        } else {
                /*
                 * Hard disks and removable media cartridges
                 */
                cl->cl_g.dkg_rpm =
                    (cl->cl_pgeom.g_rpm == 0) ? 3600: cl->cl_pgeom.g_rpm;
                cl->cl_vtoc.v_sectorsz = cl->cl_sys_blocksize;

                /* Add boot slice */
                cl->cl_vtoc.v_part[8].p_start = 0;
                cl->cl_vtoc.v_part[8].p_size  = phys_spc;
                cl->cl_vtoc.v_part[8].p_tag   = V_BOOT;
                cl->cl_vtoc.v_part[8].p_flag  = V_UNMNT;

                cl->cl_map[8].dkl_cylno = 0;
                cl->cl_map[8].dkl_nblk  = phys_spc;
                cl->cl_offset[8] = 0;

                if ((cl->cl_alter_behavior &
                    CMLB_CREATE_ALTSLICE_VTOC_16_DTYPE_DIRECT) &&
                    cl->cl_device_type == DTYPE_DIRECT) {
                        cl->cl_vtoc.v_part[9].p_start = phys_spc;
                        cl->cl_vtoc.v_part[9].p_size  = 2 * phys_spc;
                        cl->cl_vtoc.v_part[9].p_tag   = V_ALTSCTR;
                        cl->cl_vtoc.v_part[9].p_flag  = 0;

                        cl->cl_map[9].dkl_cylno = 1;
                        cl->cl_map[9].dkl_nblk  = 2 * phys_spc;
                        cl->cl_offset[9] = phys_spc;
                }
        }

        cl->cl_g.dkg_apc = 0;

        /* Add backup slice */
        cl->cl_vtoc.v_part[2].p_start = 0;
        cl->cl_vtoc.v_part[2].p_size  = disksize;
        cl->cl_vtoc.v_part[2].p_tag   = V_BACKUP;
        cl->cl_vtoc.v_part[2].p_flag  = V_UNMNT;

        cl->cl_map[2].dkl_cylno = 0;
        cl->cl_map[2].dkl_nblk  = disksize;
        cl->cl_offset[2] = 0;

        /*
         * single slice (s0) covering the entire disk
         */
        if (cl->cl_alter_behavior & CMLB_FAKE_LABEL_ONE_PARTITION) {
                cl->cl_vtoc.v_part[0].p_start = 0;
                cl->cl_vtoc.v_part[0].p_tag   = V_UNASSIGNED;
                cl->cl_vtoc.v_part[0].p_flag  = 0;
                cl->cl_vtoc.v_part[0].p_size  = disksize;
                cl->cl_map[0].dkl_cylno = 0;
                cl->cl_map[0].dkl_nblk  = disksize;
                cl->cl_offset[0] = 0;
        }

        (void) sprintf(cl->cl_vtoc.v_asciilabel, "DEFAULT cyl %d alt %d"
            " hd %d sec %d", cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
            cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);

#else
#error "No VTOC format defined."
#endif

        cl->cl_g.dkg_read_reinstruct  = 0;
        cl->cl_g.dkg_write_reinstruct = 0;

        cl->cl_g.dkg_intrlv = 1;

        cl->cl_vtoc.v_sanity  = VTOC_SANE;
        cl->cl_vtoc.v_nparts = V_NUMPAR;
        cl->cl_vtoc.v_version = V_VERSION;

        cl->cl_f_geometry_is_valid = B_TRUE;
        cl->cl_label_from_media = CMLB_LABEL_UNDEF;

        cmlb_dbg(CMLB_INFO,  cl,
            "cmlb_build_default_label: Default label created: "
            "cyl: %d\tacyl: %d\tnhead: %d\tnsect: %d\tcap: %d\n",
            cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl, cl->cl_g.dkg_nhead,
            cl->cl_g.dkg_nsect, cl->cl_blockcount);
}


#if defined(_FIRMWARE_NEEDS_FDISK)
/*
 * Max CHS values, as they are encoded into bytes, for 1022/254/63
 */
#define LBA_MAX_SECT    (63 | ((1022 & 0x300) >> 2))
#define LBA_MAX_CYL     (1022 & 0xFF)
#define LBA_MAX_HEAD    (254)


/*
 *    Function: cmlb_has_max_chs_vals
 *
 * Description: Return B_TRUE if Cylinder-Head-Sector values are all at maximum.
 *
 *   Arguments: fdp - ptr to CHS info
 *
 * Return Code: True or false
 *
 *     Context: Any.
 */
static boolean_t
cmlb_has_max_chs_vals(struct ipart *fdp)
{
        return ((fdp->begcyl  == LBA_MAX_CYL)   &&
            (fdp->beghead == LBA_MAX_HEAD)      &&
            (fdp->begsect == LBA_MAX_SECT)      &&
            (fdp->endcyl  == LBA_MAX_CYL)       &&
            (fdp->endhead == LBA_MAX_HEAD)      &&
            (fdp->endsect == LBA_MAX_SECT));
}
#endif

/*
 *    Function: cmlb_dkio_get_geometry
 *
 * Description: This routine is the driver entry point for handling user
 *              requests to get the device geometry (DKIOCGGEOM).
 *
 *   Arguments:
 *      arg             pointer to user provided dk_geom structure specifying
 *                      the controller's notion of the current geometry.
 *
 *      flag            this argument is a pass through to ddi_copyxxx()
 *                      directly from the mode argument of ioctl().
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 * Return Code: 0
 *              EFAULT
 *              ENXIO
 *              EIO
 */
static int
cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag,
    void *tg_cookie)
{
        struct dk_geom  *tmp_geom = NULL;
        int             rval = 0;

        /*
         * cmlb_validate_geometry does not spin a disk up
         * if it was spcl down. We need to make sure it
         * is ready.
         */
        mutex_enter(CMLB_MUTEX(cl));
        rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie);
#if defined(_SUNOS_VTOC_8)
        if (rval == EINVAL &&
            cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) {
                /*
                 * This is to return a default label geometry even when we
                 * do not really assume a default label for the device.
                 * dad driver utilizes this.
                 */
                if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
                        cmlb_setup_default_geometry(cl, tg_cookie);
                        rval = 0;
                }
        }
#endif
        if (rval) {
                mutex_exit(CMLB_MUTEX(cl));
                return (rval);
        }

#if defined(__i386) || defined(__amd64)
        if (cl->cl_solaris_size == 0) {
                mutex_exit(CMLB_MUTEX(cl));
                return (EIO);
        }
#endif

        /*
         * Make a local copy of the soft state geometry to avoid some potential
         * race conditions associated with holding the mutex and updating the
         * write_reinstruct value
         */
        tmp_geom = kmem_zalloc(sizeof (struct dk_geom), KM_SLEEP);
        bcopy(&cl->cl_g, tmp_geom, sizeof (struct dk_geom));

        if (tmp_geom->dkg_write_reinstruct == 0) {
                tmp_geom->dkg_write_reinstruct =
                    (int)((int)(tmp_geom->dkg_nsect * tmp_geom->dkg_rpm *
                    cmlb_rot_delay) / (int)60000);
        }
        mutex_exit(CMLB_MUTEX(cl));

        rval = ddi_copyout(tmp_geom, (void *)arg, sizeof (struct dk_geom),
            flag);
        if (rval != 0) {
                rval = EFAULT;
        }

        kmem_free(tmp_geom, sizeof (struct dk_geom));
        return (rval);

}


/*
 *    Function: cmlb_dkio_set_geometry
 *
 * Description: This routine is the driver entry point for handling user
 *              requests to set the device geometry (DKIOCSGEOM). The actual
 *              device geometry is not updated, just the driver "notion" of it.
 *
 *   Arguments:
 *      arg             pointer to user provided dk_geom structure used to set
 *                      the controller's notion of the current geometry.
 *
 *      flag            this argument is a pass through to ddi_copyxxx()
 *                      directly from the mode argument of ioctl().
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 * Return Code: 0
 *              EFAULT
 *              ENXIO
 *              EIO
 */
static int
cmlb_dkio_set_geometry(struct cmlb_lun *cl, caddr_t arg, int flag)
{
        struct dk_geom  *tmp_geom;
        struct dk_map   *lp;
        int             rval = 0;
        int             i;


#if defined(__i386) || defined(__amd64)
        if (cl->cl_solaris_size == 0) {
                return (EIO);
        }
#endif
        /*
         * We need to copy the user specified geometry into local
         * storage and then update the softstate. We don't want to hold
         * the mutex and copyin directly from the user to the soft state
         */
        tmp_geom = (struct dk_geom *)
            kmem_zalloc(sizeof (struct dk_geom), KM_SLEEP);
        rval = ddi_copyin(arg, tmp_geom, sizeof (struct dk_geom), flag);
        if (rval != 0) {
                kmem_free(tmp_geom, sizeof (struct dk_geom));
                return (EFAULT);
        }

        mutex_enter(CMLB_MUTEX(cl));
        bcopy(tmp_geom, &cl->cl_g, sizeof (struct dk_geom));
        for (i = 0; i < NDKMAP; i++) {
                lp  = &cl->cl_map[i];
                cl->cl_offset[i] =
                    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
#if defined(__i386) || defined(__amd64)
                cl->cl_offset[i] += cl->cl_solaris_offset;
#endif
        }
        cl->cl_f_geometry_is_valid = B_FALSE;
        mutex_exit(CMLB_MUTEX(cl));
        kmem_free(tmp_geom, sizeof (struct dk_geom));

        return (rval);
}

/*
 *    Function: cmlb_dkio_get_partition
 *
 * Description: This routine is the driver entry point for handling user
 *              requests to get the partition table (DKIOCGAPART).
 *
 *   Arguments:
 *      arg             pointer to user provided dk_allmap structure specifying
 *                      the controller's notion of the current partition table.
 *
 *      flag            this argument is a pass through to ddi_copyxxx()
 *                      directly from the mode argument of ioctl().
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 * Return Code: 0
 *              EFAULT
 *              ENXIO
 *              EIO
 */
static int
cmlb_dkio_get_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
    void *tg_cookie)
{
        int             rval = 0;
        int             size;

        /*
         * Make sure the geometry is valid before getting the partition
         * information.
         */
        mutex_enter(CMLB_MUTEX(cl));
        if ((rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie)) != 0) {
                mutex_exit(CMLB_MUTEX(cl));
                return (rval);
        }
        mutex_exit(CMLB_MUTEX(cl));

#if defined(__i386) || defined(__amd64)
        if (cl->cl_solaris_size == 0) {
                return (EIO);
        }
#endif

#ifdef _MULTI_DATAMODEL
        switch (ddi_model_convert_from(flag & FMODELS)) {
        case DDI_MODEL_ILP32: {
                struct dk_map32 dk_map32[NDKMAP];
                int             i;

                for (i = 0; i < NDKMAP; i++) {
                        dk_map32[i].dkl_cylno = cl->cl_map[i].dkl_cylno;
                        dk_map32[i].dkl_nblk  = cl->cl_map[i].dkl_nblk;
                }
                size = NDKMAP * sizeof (struct dk_map32);
                rval = ddi_copyout(dk_map32, (void *)arg, size, flag);
                if (rval != 0) {
                        rval = EFAULT;
                }
                break;
        }
        case DDI_MODEL_NONE:
                size = NDKMAP * sizeof (struct dk_map);
                rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag);
                if (rval != 0) {
                        rval = EFAULT;
                }
                break;
        }
#else /* ! _MULTI_DATAMODEL */
        size = NDKMAP * sizeof (struct dk_map);
        rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag);
        if (rval != 0) {
                rval = EFAULT;
        }
#endif /* _MULTI_DATAMODEL */
        return (rval);
}

/*
 *    Function: cmlb_dkio_set_partition
 *
 * Description: This routine is the driver entry point for handling user
 *              requests to set the partition table (DKIOCSAPART). The actual
 *              device partition is not updated.
 *
 *   Arguments:
 *              arg  - pointer to user provided dk_allmap structure used to set
 *                      the controller's notion of the partition table.
 *              flag - this argument is a pass through to ddi_copyxxx()
 *                     directly from the mode argument of ioctl().
 *
 * Return Code: 0
 *              EINVAL
 *              EFAULT
 *              ENXIO
 *              EIO
 */
static int
cmlb_dkio_set_partition(struct cmlb_lun *cl, caddr_t arg, int flag)
{
        struct dk_map   dk_map[NDKMAP];
        struct dk_map   *lp;
        int             rval = 0;
        int             size;
        int             i;
#if defined(_SUNOS_VTOC_16)
        struct dkl_partition    *vp;
#endif

        /*
         * Set the map for all logical partitions.  We lock
         * the priority just to make sure an interrupt doesn't
         * come in while the map is half updated.
         */
        _NOTE(DATA_READABLE_WITHOUT_LOCK(cmlb_lun::cl_solaris_size))
        mutex_enter(CMLB_MUTEX(cl));

        if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
                mutex_exit(CMLB_MUTEX(cl));
                return (ENOTSUP);
        }
        mutex_exit(CMLB_MUTEX(cl));
        if (cl->cl_solaris_size == 0) {
                return (EIO);
        }

#ifdef _MULTI_DATAMODEL
        switch (ddi_model_convert_from(flag & FMODELS)) {
        case DDI_MODEL_ILP32: {
                struct dk_map32 dk_map32[NDKMAP];

                size = NDKMAP * sizeof (struct dk_map32);
                rval = ddi_copyin((void *)arg, dk_map32, size, flag);
                if (rval != 0) {
                        return (EFAULT);
                }
                for (i = 0; i < NDKMAP; i++) {
                        dk_map[i].dkl_cylno = dk_map32[i].dkl_cylno;
                        dk_map[i].dkl_nblk  = dk_map32[i].dkl_nblk;
                }
                break;
        }
        case DDI_MODEL_NONE:
                size = NDKMAP * sizeof (struct dk_map);
                rval = ddi_copyin((void *)arg, dk_map, size, flag);
                if (rval != 0) {
                        return (EFAULT);
                }
                break;
        }
#else /* ! _MULTI_DATAMODEL */
        size = NDKMAP * sizeof (struct dk_map);
        rval = ddi_copyin((void *)arg, dk_map, size, flag);
        if (rval != 0) {
                return (EFAULT);
        }
#endif /* _MULTI_DATAMODEL */

        mutex_enter(CMLB_MUTEX(cl));
        /* Note: The size used in this bcopy is set based upon the data model */
        bcopy(dk_map, cl->cl_map, size);
#if defined(_SUNOS_VTOC_16)
        vp = (struct dkl_partition *)&(cl->cl_vtoc);
#endif  /* defined(_SUNOS_VTOC_16) */
        for (i = 0; i < NDKMAP; i++) {
                lp  = &cl->cl_map[i];
                cl->cl_offset[i] =
                    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
#if defined(_SUNOS_VTOC_16)
                vp->p_start = cl->cl_offset[i];
                vp->p_size = lp->dkl_nblk;
                vp++;
#endif  /* defined(_SUNOS_VTOC_16) */
#if defined(__i386) || defined(__amd64)
                cl->cl_offset[i] += cl->cl_solaris_offset;
#endif
        }
        mutex_exit(CMLB_MUTEX(cl));
        return (rval);
}


/*
 *    Function: cmlb_dkio_get_vtoc
 *
 * Description: This routine is the driver entry point for handling user
 *              requests to get the current volume table of contents
 *              (DKIOCGVTOC).
 *
 *   Arguments:
 *      arg             pointer to user provided vtoc structure specifying
 *                      the current vtoc.
 *
 *      flag            this argument is a pass through to ddi_copyxxx()
 *                      directly from the mode argument of ioctl().
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 * Return Code: 0
 *              EFAULT
 *              ENXIO
 *              EIO
 */
static int
cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
{
#if defined(_SUNOS_VTOC_8)
        struct vtoc     user_vtoc;
#endif  /* defined(_SUNOS_VTOC_8) */
        int             rval = 0;

        mutex_enter(CMLB_MUTEX(cl));
        if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
                mutex_exit(CMLB_MUTEX(cl));
                return (EOVERFLOW);
        }

        rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie);

#if defined(_SUNOS_VTOC_8)
        if (rval == EINVAL &&
            (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8)) {
                /*
                 * This is to return a default label even when we do not
                 * really assume a default label for the device.
                 * dad driver utilizes this.
                 */
                if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
                        cmlb_setup_default_geometry(cl, tg_cookie);
                        rval = 0;
                }
        }
#endif
        if (rval) {
                mutex_exit(CMLB_MUTEX(cl));
                return (rval);
        }

#if defined(_SUNOS_VTOC_8)
        cmlb_build_user_vtoc(cl, &user_vtoc);
        mutex_exit(CMLB_MUTEX(cl));

#ifdef _MULTI_DATAMODEL
        switch (ddi_model_convert_from(flag & FMODELS)) {
        case DDI_MODEL_ILP32: {
                struct vtoc32 user_vtoc32;

                vtoctovtoc32(user_vtoc, user_vtoc32);
                if (ddi_copyout(&user_vtoc32, (void *)arg,
                    sizeof (struct vtoc32), flag)) {
                        return (EFAULT);
                }
                break;
        }

        case DDI_MODEL_NONE:
                if (ddi_copyout(&user_vtoc, (void *)arg,
                    sizeof (struct vtoc), flag)) {
                        return (EFAULT);
                }
                break;
        }
#else /* ! _MULTI_DATAMODEL */
        if (ddi_copyout(&user_vtoc, (void *)arg, sizeof (struct vtoc), flag)) {
                return (EFAULT);
        }
#endif /* _MULTI_DATAMODEL */

#elif defined(_SUNOS_VTOC_16)
        mutex_exit(CMLB_MUTEX(cl));

#ifdef _MULTI_DATAMODEL
        /*
         * The cl_vtoc structure is a "struct dk_vtoc"  which is always
         * 32-bit to maintain compatibility with existing on-disk
         * structures.  Thus, we need to convert the structure when copying
         * it out to a datamodel-dependent "struct vtoc" in a 64-bit
         * program.  If the target is a 32-bit program, then no conversion
         * is necessary.
         */
        /* LINTED: logical expression always true: op "||" */
        ASSERT(sizeof (cl->cl_vtoc) == sizeof (struct vtoc32));
        switch (ddi_model_convert_from(flag & FMODELS)) {
        case DDI_MODEL_ILP32:
                if (ddi_copyout(&(cl->cl_vtoc), (void *)arg,
                    sizeof (cl->cl_vtoc), flag)) {
                        return (EFAULT);
                }
                break;

        case DDI_MODEL_NONE: {
                struct vtoc user_vtoc;

                vtoc32tovtoc(cl->cl_vtoc, user_vtoc);
                if (ddi_copyout(&user_vtoc, (void *)arg,
                    sizeof (struct vtoc), flag)) {
                        return (EFAULT);
                }
                break;
        }
        }
#else /* ! _MULTI_DATAMODEL */
        if (ddi_copyout(&(cl->cl_vtoc), (void *)arg, sizeof (cl->cl_vtoc),
            flag)) {
                return (EFAULT);
        }
#endif /* _MULTI_DATAMODEL */
#else
#error "No VTOC format defined."
#endif

        return (rval);
}


/*
 *    Function: cmlb_dkio_get_extvtoc
 */
static int
cmlb_dkio_get_extvtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
    void *tg_cookie)
{
        struct extvtoc  ext_vtoc;
#if defined(_SUNOS_VTOC_8)
        struct vtoc     user_vtoc;
#endif  /* defined(_SUNOS_VTOC_8) */
        int             rval = 0;

        bzero(&ext_vtoc, sizeof (struct extvtoc));
        mutex_enter(CMLB_MUTEX(cl));
        rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie);

#if defined(_SUNOS_VTOC_8)
        if (rval == EINVAL &&
            (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8)) {
                /*
                 * This is to return a default label even when we do not
                 * really assume a default label for the device.
                 * dad driver utilizes this.
                 */
                if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
                        cmlb_setup_default_geometry(cl, tg_cookie);
                        rval = 0;
                }
        }
#endif
        if (rval) {
                mutex_exit(CMLB_MUTEX(cl));
                return (rval);
        }

#if defined(_SUNOS_VTOC_8)
        cmlb_build_user_vtoc(cl, &user_vtoc);
        mutex_exit(CMLB_MUTEX(cl));

        /*
         * Checking callers data model does not make much sense here
         * since extvtoc will always be equivalent to 64bit vtoc.
         * What is important is whether the kernel is in 32 or 64 bit
         */

#ifdef _LP64
                if (ddi_copyout(&user_vtoc, (void *)arg,
                    sizeof (struct extvtoc), flag)) {
                        return (EFAULT);
                }
#else
                vtoc32tovtoc(user_vtoc, ext_vtoc);
                if (ddi_copyout(&ext_vtoc, (void *)arg,
                    sizeof (struct extvtoc), flag)) {
                        return (EFAULT);
                }
#endif

#elif defined(_SUNOS_VTOC_16)
        /*
         * The cl_vtoc structure is a "struct dk_vtoc"  which is always
         * 32-bit to maintain compatibility with existing on-disk
         * structures.  Thus, we need to convert the structure when copying
         * it out to extvtoc
         */
        vtoc32tovtoc(cl->cl_vtoc, ext_vtoc);
        mutex_exit(CMLB_MUTEX(cl));

        if (ddi_copyout(&ext_vtoc, (void *)arg, sizeof (struct extvtoc), flag))
                return (EFAULT);
#else
#error "No VTOC format defined."
#endif

        return (rval);
}

/*
 * This routine implements the DKIOCGETEFI ioctl. This ioctl is currently
 * used to read the GPT Partition Table Header (primary/backup), the GUID
 * partition Entry Array (primary/backup), and the MBR.
 */
static int
cmlb_dkio_get_efi(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
{
        dk_efi_t        user_efi;
        int             rval = 0;
        void            *buffer;
        diskaddr_t      tgt_lba;

        if (ddi_copyin(arg, &user_efi, sizeof (dk_efi_t), flag))
                return (EFAULT);

        user_efi.dki_data = (void *)(uintptr_t)user_efi.dki_data_64;

        if (user_efi.dki_length == 0 ||
            user_efi.dki_length > cmlb_tg_max_efi_xfer)
                return (EINVAL);

        tgt_lba = user_efi.dki_lba;

        mutex_enter(CMLB_MUTEX(cl));
        if ((cmlb_check_update_blockcount(cl, tg_cookie) != 0) ||
            (cl->cl_tgt_blocksize == 0) ||
            (user_efi.dki_length % cl->cl_sys_blocksize)) {
                mutex_exit(CMLB_MUTEX(cl));
                return (EINVAL);
        }
        if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize)
                tgt_lba = tgt_lba * cl->cl_tgt_blocksize /
                    cl->cl_sys_blocksize;
        mutex_exit(CMLB_MUTEX(cl));

        buffer = kmem_alloc(user_efi.dki_length, KM_SLEEP);
        rval = DK_TG_READ(cl, buffer, tgt_lba, user_efi.dki_length, tg_cookie);
        if (rval == 0 && ddi_copyout(buffer, user_efi.dki_data,
            user_efi.dki_length, flag) != 0)
                rval = EFAULT;

        kmem_free(buffer, user_efi.dki_length);
        return (rval);
}

#if defined(_SUNOS_VTOC_8)
/*
 *    Function: cmlb_build_user_vtoc
 *
 * Description: This routine populates a pass by reference variable with the
 *              current volume table of contents.
 *
 *   Arguments: cl - driver soft state (unit) structure
 *              user_vtoc - pointer to vtoc structure to be populated
 */
static void
cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc)
{
        struct dk_map2          *lpart;
        struct dk_map           *lmap;
        struct partition        *vpart;
        uint32_t                nblks;
        int                     i;

        ASSERT(mutex_owned(CMLB_MUTEX(cl)));

        /*
         * Return vtoc structure fields in the provided VTOC area, addressed
         * by *vtoc.
         */
        bzero(user_vtoc, sizeof (struct vtoc));
        user_vtoc->v_bootinfo[0] = cl->cl_vtoc.v_bootinfo[0];
        user_vtoc->v_bootinfo[1] = cl->cl_vtoc.v_bootinfo[1];
        user_vtoc->v_bootinfo[2] = cl->cl_vtoc.v_bootinfo[2];
        user_vtoc->v_sanity     = VTOC_SANE;
        user_vtoc->v_version    = cl->cl_vtoc.v_version;
        bcopy(cl->cl_vtoc.v_volume, user_vtoc->v_volume, LEN_DKL_VVOL);
        user_vtoc->v_sectorsz = cl->cl_sys_blocksize;
        user_vtoc->v_nparts = cl->cl_vtoc.v_nparts;

        for (i = 0; i < 10; i++)
                user_vtoc->v_reserved[i] = cl->cl_vtoc.v_reserved[i];

        /*
         * Convert partitioning information.
         *
         * Note the conversion from starting cylinder number
         * to starting sector number.
         */
        lmap = cl->cl_map;
        lpart = (struct dk_map2 *)cl->cl_vtoc.v_part;
        vpart = user_vtoc->v_part;

        nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead;

        for (i = 0; i < V_NUMPAR; i++) {
                vpart->p_tag    = lpart->p_tag;
                vpart->p_flag   = lpart->p_flag;
                vpart->p_start  = lmap->dkl_cylno * nblks;
                vpart->p_size   = lmap->dkl_nblk;
                lmap++;
                lpart++;
                vpart++;

                /* (4364927) */
                user_vtoc->timestamp[i] = (time_t)cl->cl_vtoc.v_timestamp[i];
        }

        bcopy(cl->cl_asciilabel, user_vtoc->v_asciilabel, LEN_DKL_ASCII);
}
#endif

static int
cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
    void *tg_cookie)
{
        struct partition64      p64;
        int                     rval = 0;
        uint_t                  nparts;
        efi_gpe_t               *partitions;
        efi_gpt_t               *buffer;
        diskaddr_t              gpe_lba;
        int                     n_gpe_per_blk = 0;

        if (ddi_copyin((const void *)arg, &p64,
            sizeof (struct partition64), flag)) {
                return (EFAULT);
        }

        buffer = kmem_alloc(cl->cl_sys_blocksize, KM_SLEEP);
        rval = DK_TG_READ(cl, buffer, 1, cl->cl_sys_blocksize, tg_cookie);
        if (rval != 0)
                goto done_error;

        cmlb_swap_efi_gpt(buffer);

        if ((rval = cmlb_validate_efi(buffer)) != 0)
                goto done_error;

        nparts = buffer->efi_gpt_NumberOfPartitionEntries;
        gpe_lba = buffer->efi_gpt_PartitionEntryLBA;
        if (p64.p_partno >= nparts) {
                /* couldn't find it */
                rval = ESRCH;
                goto done_error;
        }
        /*
         * Read the block that contains the requested GPE.
         */
        n_gpe_per_blk = cl->cl_sys_blocksize / sizeof (efi_gpe_t);
        gpe_lba += p64.p_partno / n_gpe_per_blk;
        rval = DK_TG_READ(cl, buffer, gpe_lba, cl->cl_sys_blocksize, tg_cookie);

        if (rval) {
                goto done_error;
        }
        partitions = (efi_gpe_t *)buffer;
        partitions += p64.p_partno % n_gpe_per_blk;

        /* Byte swap only the requested GPE */
        cmlb_swap_efi_gpe(1, partitions);

        bcopy(&partitions->efi_gpe_PartitionTypeGUID, &p64.p_type,
            sizeof (struct uuid));
        p64.p_start = partitions->efi_gpe_StartingLBA;
        p64.p_size = partitions->efi_gpe_EndingLBA -
            p64.p_start + 1;

        if (ddi_copyout(&p64, (void *)arg, sizeof (struct partition64), flag))
                rval = EFAULT;

done_error:
        kmem_free(buffer, cl->cl_sys_blocksize);
        return (rval);
}


/*
 *    Function: cmlb_dkio_set_vtoc
 *
 * Description: This routine is the driver entry point for handling user
 *              requests to set the current volume table of contents
 *              (DKIOCSVTOC).
 *
 *   Arguments:
 *      dev             the device number
 *      arg             pointer to user provided vtoc structure used to set the
 *                      current vtoc.
 *
 *      flag            this argument is a pass through to ddi_copyxxx()
 *                      directly from the mode argument of ioctl().
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 * Return Code: 0
 *              EFAULT
 *              ENXIO
 *              EINVAL
 *              ENOTSUP
 */
static int
cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag,
    void *tg_cookie)
{
        struct vtoc     user_vtoc;
        int             shift, rval = 0;
        boolean_t       internal;

        internal = (cl->cl_alter_behavior & CMLB_INTERNAL_MINOR_NODES) != 0;

        if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
                shift = CMLBUNIT_FORCE_P0_SHIFT;
        else
                shift = CMLBUNIT_SHIFT;

#ifdef _MULTI_DATAMODEL
        switch (ddi_model_convert_from(flag & FMODELS)) {
        case DDI_MODEL_ILP32: {
                struct vtoc32 user_vtoc32;

                if (ddi_copyin((const void *)arg, &user_vtoc32,
                    sizeof (struct vtoc32), flag)) {
                        return (EFAULT);
                }
                vtoc32tovtoc(user_vtoc32, user_vtoc);
                break;
        }

        case DDI_MODEL_NONE:
                if (ddi_copyin((const void *)arg, &user_vtoc,
                    sizeof (struct vtoc), flag)) {
                        return (EFAULT);
                }
                break;
        }
#else /* ! _MULTI_DATAMODEL */
        if (ddi_copyin((const void *)arg, &user_vtoc,
            sizeof (struct vtoc), flag)) {
                return (EFAULT);
        }
#endif /* _MULTI_DATAMODEL */

        mutex_enter(CMLB_MUTEX(cl));

        if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
                mutex_exit(CMLB_MUTEX(cl));
                return (EOVERFLOW);
        }

#if defined(__i386) || defined(__amd64)
        if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) {
                mutex_exit(CMLB_MUTEX(cl));
                return (EINVAL);
        }
#endif

        if (cl->cl_g.dkg_ncyl == 0) {
                mutex_exit(CMLB_MUTEX(cl));
                return (EINVAL);
        }

        mutex_exit(CMLB_MUTEX(cl));
        cmlb_clear_efi(cl, tg_cookie);
        ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
        ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");

        /*
         * cmlb_dkio_set_vtoc creates duplicate minor nodes when
         * relabeling an SMI disk. To avoid that we remove them
         * before creating.
         * It should be OK to remove a non-existed minor node.
         */
        ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
        ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");

        (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
            S_IFBLK, (CMLBUNIT(dev, shift) << shift) | WD_NODE,
            cl->cl_node_type, 0, internal);
        (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
            S_IFCHR, (CMLBUNIT(dev, shift) << shift) | WD_NODE,
            cl->cl_node_type, 0, internal);
        mutex_enter(CMLB_MUTEX(cl));

        if ((rval = cmlb_build_label_vtoc(cl, &user_vtoc)) == 0) {
                if ((rval = cmlb_write_label(cl, tg_cookie)) == 0) {
                        if (cmlb_validate_geometry(cl,
                            B_TRUE, 0, tg_cookie) != 0) {
                                cmlb_dbg(CMLB_ERROR, cl,
                                    "cmlb_dkio_set_vtoc: "
                                    "Failed validate geometry\n");
                        }
                        cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
                }
        }
        mutex_exit(CMLB_MUTEX(cl));
        return (rval);
}

/*
 *    Function: cmlb_dkio_set_extvtoc
 */
static int
cmlb_dkio_set_extvtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag,
    void *tg_cookie)
{
        int             shift, rval = 0;
        struct vtoc     user_vtoc;
        boolean_t       internal;

        if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
                shift = CMLBUNIT_FORCE_P0_SHIFT;
        else
                shift = CMLBUNIT_SHIFT;

        /*
         * Checking callers data model does not make much sense here
         * since extvtoc will always be equivalent to 64bit vtoc.
         * What is important is whether the kernel is in 32 or 64 bit
         */

#ifdef _LP64
        if (ddi_copyin((const void *)arg, &user_vtoc,
                    sizeof (struct extvtoc), flag)) {
                        return (EFAULT);
        }
#else
        struct  extvtoc user_extvtoc;
        if (ddi_copyin((const void *)arg, &user_extvtoc,
                    sizeof (struct extvtoc), flag)) {
                        return (EFAULT);
        }

        vtoctovtoc32(user_extvtoc, user_vtoc);
#endif

        internal = (cl->cl_alter_behavior & CMLB_INTERNAL_MINOR_NODES) != 0;
        mutex_enter(CMLB_MUTEX(cl));
#if defined(__i386) || defined(__amd64)
        if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) {
                mutex_exit(CMLB_MUTEX(cl));
                return (EINVAL);
        }
#endif

        if (cl->cl_g.dkg_ncyl == 0) {
                mutex_exit(CMLB_MUTEX(cl));
                return (EINVAL);
        }

        mutex_exit(CMLB_MUTEX(cl));
        cmlb_clear_efi(cl, tg_cookie);
        ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
        ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
        /*
         * cmlb_dkio_set_extvtoc creates duplicate minor nodes when
         * relabeling an SMI disk. To avoid that we remove them
         * before creating.
         * It should be OK to remove a non-existed minor node.
         */
        ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
        ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");

        (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
            S_IFBLK, (CMLBUNIT(dev, shift) << shift) | WD_NODE,
            cl->cl_node_type, 0, internal);
        (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
            S_IFCHR, (CMLBUNIT(dev, shift) << shift) | WD_NODE,
            cl->cl_node_type, 0, internal);

        mutex_enter(CMLB_MUTEX(cl));

        if ((rval = cmlb_build_label_vtoc(cl, &user_vtoc)) == 0) {
                if ((rval = cmlb_write_label(cl, tg_cookie)) == 0) {
                        if (cmlb_validate_geometry(cl,
                            B_TRUE, 0, tg_cookie) != 0) {
                                cmlb_dbg(CMLB_ERROR, cl,
                                    "cmlb_dkio_set_vtoc: "
                                    "Failed validate geometry\n");
                        }
                }
        }
        mutex_exit(CMLB_MUTEX(cl));
        return (rval);
}

/*
 *    Function: cmlb_build_label_vtoc
 *
 * Description: This routine updates the driver soft state current volume table
 *              of contents based on a user specified vtoc.
 *
 *   Arguments: cl - driver soft state (unit) structure
 *              user_vtoc - pointer to vtoc structure specifying vtoc to be used
 *                          to update the driver soft state.
 *
 * Return Code: 0
 *              EINVAL
 */
static int
cmlb_build_label_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc)
{
        struct dk_map           *lmap;
        struct partition        *vpart;
        uint_t                  nblks;
#if defined(_SUNOS_VTOC_8)
        int                     ncyl;
        struct dk_map2          *lpart;
#endif  /* defined(_SUNOS_VTOC_8) */
        int                     i;

        ASSERT(mutex_owned(CMLB_MUTEX(cl)));

        /* Sanity-check the vtoc */
        if (user_vtoc->v_sanity != VTOC_SANE ||
            user_vtoc->v_sectorsz != cl->cl_sys_blocksize ||
            user_vtoc->v_nparts != V_NUMPAR) {
                cmlb_dbg(CMLB_INFO,  cl,
                    "cmlb_build_label_vtoc: vtoc not valid\n");
                return (EINVAL);
        }

        nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead;
        if (nblks == 0) {
                cmlb_dbg(CMLB_INFO,  cl,
                    "cmlb_build_label_vtoc: geom nblks is 0\n");
                return (EINVAL);
        }

#if defined(_SUNOS_VTOC_8)
        vpart = user_vtoc->v_part;
        for (i = 0; i < V_NUMPAR; i++) {
                if (((unsigned)vpart->p_start % nblks) != 0) {
                        cmlb_dbg(CMLB_INFO,  cl,
                            "cmlb_build_label_vtoc: p_start not multiply of"
                            "nblks part %d p_start %d nblks %d\n", i,
                            vpart->p_start, nblks);
                        return (EINVAL);
                }
                ncyl = (unsigned)vpart->p_start / nblks;
                ncyl += (unsigned)vpart->p_size / nblks;
                if (((unsigned)vpart->p_size % nblks) != 0) {
                        ncyl++;
                }
                if (ncyl > (int)cl->cl_g.dkg_ncyl) {
                        cmlb_dbg(CMLB_INFO,  cl,
                            "cmlb_build_label_vtoc: ncyl %d  > dkg_ncyl %d"
                            "p_size %ld p_start %ld nblks %d  part number %d"
                            "tag %d\n",
                            ncyl, cl->cl_g.dkg_ncyl, vpart->p_size,
                            vpart->p_start, nblks,
                            i, vpart->p_tag);

                        return (EINVAL);
                }
                vpart++;
        }
#endif  /* defined(_SUNOS_VTOC_8) */

        /* Put appropriate vtoc structure fields into the disk label */
#if defined(_SUNOS_VTOC_16)
        /*
         * The vtoc is always a 32bit data structure to maintain the
         * on-disk format. Convert "in place" instead of doing bcopy.
         */
        vtoctovtoc32((*user_vtoc), (*((struct vtoc32 *)&(cl->cl_vtoc))));

        /*
         * in the 16-slice vtoc, starting sectors are expressed in
         * numbers *relative* to the start of the Solaris fdisk partition.
         */
        lmap = cl->cl_map;
        vpart = user_vtoc->v_part;

        for (i = 0; i < (int)user_vtoc->v_nparts; i++, lmap++, vpart++) {
                lmap->dkl_cylno = (unsigned)vpart->p_start / nblks;
                lmap->dkl_nblk = (unsigned)vpart->p_size;
        }

#elif defined(_SUNOS_VTOC_8)

        cl->cl_vtoc.v_bootinfo[0] = (uint32_t)user_vtoc->v_bootinfo[0];
        cl->cl_vtoc.v_bootinfo[1] = (uint32_t)user_vtoc->v_bootinfo[1];
        cl->cl_vtoc.v_bootinfo[2] = (uint32_t)user_vtoc->v_bootinfo[2];

        cl->cl_vtoc.v_sanity = (uint32_t)user_vtoc->v_sanity;
        cl->cl_vtoc.v_version = (uint32_t)user_vtoc->v_version;

        bcopy(user_vtoc->v_volume, cl->cl_vtoc.v_volume, LEN_DKL_VVOL);

        cl->cl_vtoc.v_nparts = user_vtoc->v_nparts;

        for (i = 0; i < 10; i++)
                cl->cl_vtoc.v_reserved[i] =  user_vtoc->v_reserved[i];

        /*
         * Note the conversion from starting sector number
         * to starting cylinder number.
         * Return error if division results in a remainder.
         */
        lmap = cl->cl_map;
        lpart = cl->cl_vtoc.v_part;
        vpart = user_vtoc->v_part;

        for (i = 0; i < (int)user_vtoc->v_nparts; i++) {
                lpart->p_tag  = vpart->p_tag;
                lpart->p_flag = vpart->p_flag;
                lmap->dkl_cylno = (unsigned)vpart->p_start / nblks;
                lmap->dkl_nblk = (unsigned)vpart->p_size;

                lmap++;
                lpart++;
                vpart++;

                /* (4387723) */
#ifdef _LP64
                if (user_vtoc->timestamp[i] > TIME32_MAX) {
                        cl->cl_vtoc.v_timestamp[i] = TIME32_MAX;
                } else {
                        cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i];
                }
#else
                cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i];
#endif
        }

        bcopy(user_vtoc->v_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII);
#else
#error "No VTOC format defined."
#endif
        return (0);
}

/*
 *    Function: cmlb_clear_efi
 *
 * Description: This routine clears all EFI labels.
 *
 *   Arguments:
 *      cl               driver soft state (unit) structure
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 * Return Code: void
 */
static void
cmlb_clear_efi(struct cmlb_lun *cl, void *tg_cookie)
{
        efi_gpt_t       *gpt;
        diskaddr_t      cap;
        int             rval;

        ASSERT(!mutex_owned(CMLB_MUTEX(cl)));

        mutex_enter(CMLB_MUTEX(cl));
        cl->cl_reserved = -1;
        mutex_exit(CMLB_MUTEX(cl));

        gpt = kmem_alloc(cl->cl_sys_blocksize, KM_SLEEP);

        if (DK_TG_READ(cl, gpt, 1, cl->cl_sys_blocksize, tg_cookie) != 0) {
                goto done;
        }

        cmlb_swap_efi_gpt(gpt);
        rval = cmlb_validate_efi(gpt);
        if (rval == 0) {
                /* clear primary */
                bzero(gpt, sizeof (efi_gpt_t));
                if (rval = DK_TG_WRITE(cl, gpt, 1, cl->cl_sys_blocksize,
                    tg_cookie)) {
                        cmlb_dbg(CMLB_INFO,  cl,
                            "cmlb_clear_efi: clear primary label failed\n");
                }
        }
        /* the backup */
        rval = DK_TG_GETCAP(cl, &cap, tg_cookie);
        if (rval) {
                goto done;
        }

        if ((rval = DK_TG_READ(cl, gpt, cap - 1, cl->cl_sys_blocksize,
            tg_cookie)) != 0) {
                goto done;
        }
        cmlb_swap_efi_gpt(gpt);
        rval = cmlb_validate_efi(gpt);
        if (rval == 0) {
                /* clear backup */
                cmlb_dbg(CMLB_TRACE,  cl,
                    "cmlb_clear_efi clear backup@%lu\n", cap - 1);
                bzero(gpt, sizeof (efi_gpt_t));
                if ((rval = DK_TG_WRITE(cl,  gpt, cap - 1, cl->cl_sys_blocksize,
                    tg_cookie))) {
                        cmlb_dbg(CMLB_INFO,  cl,
                            "cmlb_clear_efi: clear backup label failed\n");
                }
        } else {
                /*
                 * Refer to comments related to off-by-1 at the
                 * header of this file
                 */
                if ((rval = DK_TG_READ(cl, gpt, cap - 2,
                    cl->cl_sys_blocksize, tg_cookie)) != 0) {
                        goto done;
                }
                cmlb_swap_efi_gpt(gpt);
                rval = cmlb_validate_efi(gpt);
                if (rval == 0) {
                        /* clear legacy backup EFI label */
                        cmlb_dbg(CMLB_TRACE,  cl,
                            "cmlb_clear_efi clear legacy backup@%lu\n",
                            cap - 2);
                        bzero(gpt, sizeof (efi_gpt_t));
                        if ((rval = DK_TG_WRITE(cl,  gpt, cap - 2,
                            cl->cl_sys_blocksize, tg_cookie))) {
                                cmlb_dbg(CMLB_INFO,  cl,
                                "cmlb_clear_efi: clear legacy backup label "
                                "failed\n");
                        }
                }
        }

done:
        kmem_free(gpt, cl->cl_sys_blocksize);
}

/*
 *    Function: cmlb_set_vtoc
 *
 * Description: This routine writes data to the appropriate positions
 *
 *   Arguments:
 *      cl              driver soft state (unit) structure
 *
 *      dkl             the data to be written
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 * Return: void
 */
static int
cmlb_set_vtoc(struct cmlb_lun *cl, struct dk_label *dkl, void *tg_cookie)
{
        uint_t  label_addr;
        int     sec;
        diskaddr_t      blk;
        int     head;
        int     cyl;
        int     rval;

#if defined(__i386) || defined(__amd64)
        label_addr = cl->cl_solaris_offset + DK_LABEL_LOC;
#else
        /* Write the primary label at block 0 of the solaris partition. */
        label_addr = 0;
#endif

        rval = DK_TG_WRITE(cl, dkl, label_addr, cl->cl_sys_blocksize,
            tg_cookie);

        if (rval != 0) {
                return (rval);
        }

        /*
         * Calculate where the backup labels go.  They are always on
         * the last alternate cylinder, but some older drives put them
         * on head 2 instead of the last head.  They are always on the
         * first 5 odd sectors of the appropriate track.
         *
         * We have no choice at this point, but to believe that the
         * disk label is valid.  Use the geometry of the disk
         * as described in the label.
         */
        cyl  = dkl->dkl_ncyl  + dkl->dkl_acyl - 1;
        head = dkl->dkl_nhead - 1;

        /*
         * Write and verify the backup labels. Make sure we don't try to
         * write past the last cylinder.
         */
        for (sec = 1; ((sec < 5 * 2 + 1) && (sec < dkl->dkl_nsect)); sec += 2) {
                blk = (diskaddr_t)(
                    (cyl * ((dkl->dkl_nhead * dkl->dkl_nsect) - dkl->dkl_apc)) +
                    (head * dkl->dkl_nsect) + sec);
#if defined(__i386) || defined(__amd64)
                blk += cl->cl_solaris_offset;
#endif
                rval = DK_TG_WRITE(cl, dkl, blk, cl->cl_sys_blocksize,
                    tg_cookie);
                cmlb_dbg(CMLB_INFO,  cl,
                "cmlb_set_vtoc: wrote backup label %llx\n", blk);
                if (rval != 0) {
                        goto exit;
                }
        }
exit:
        return (rval);
}

/*
 *    Function: cmlb_clear_vtoc
 *
 * Description: This routine clears out the VTOC labels.
 *
 *   Arguments:
 *      cl              driver soft state (unit) structure
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 * Return: void
 */
static void
cmlb_clear_vtoc(struct cmlb_lun *cl, void *tg_cookie)
{
        struct dk_label         *dkl;

        mutex_exit(CMLB_MUTEX(cl));
        dkl = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP);
        mutex_enter(CMLB_MUTEX(cl));
        /*
         * cmlb_set_vtoc uses these fields in order to figure out
         * where to overwrite the backup labels
         */
        dkl->dkl_apc    = cl->cl_g.dkg_apc;
        dkl->dkl_ncyl   = cl->cl_g.dkg_ncyl;
        dkl->dkl_acyl   = cl->cl_g.dkg_acyl;
        dkl->dkl_nhead  = cl->cl_g.dkg_nhead;
        dkl->dkl_nsect  = cl->cl_g.dkg_nsect;
        mutex_exit(CMLB_MUTEX(cl));
        (void) cmlb_set_vtoc(cl, dkl, tg_cookie);
        kmem_free(dkl, cl->cl_sys_blocksize);

        mutex_enter(CMLB_MUTEX(cl));
}

/*
 *    Function: cmlb_write_label
 *
 * Description: This routine will validate and write the driver soft state vtoc
 *              contents to the device.
 *
 *   Arguments:
 *      cl              cmlb handle
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 *
 * Return Code: the code returned by cmlb_send_scsi_cmd()
 *              0
 *              EINVAL
 *              ENXIO
 *              ENOMEM
 */
static int
cmlb_write_label(struct cmlb_lun *cl, void *tg_cookie)
{
        struct dk_label *dkl;
        short           sum;
        short           *sp;
        int             i;
        int             rval;

        ASSERT(mutex_owned(CMLB_MUTEX(cl)));
        mutex_exit(CMLB_MUTEX(cl));
        dkl = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP);
        mutex_enter(CMLB_MUTEX(cl));

        bcopy(&cl->cl_vtoc, &dkl->dkl_vtoc, sizeof (struct dk_vtoc));
        dkl->dkl_rpm    = cl->cl_g.dkg_rpm;
        dkl->dkl_pcyl   = cl->cl_g.dkg_pcyl;
        dkl->dkl_apc    = cl->cl_g.dkg_apc;
        dkl->dkl_intrlv = cl->cl_g.dkg_intrlv;
        dkl->dkl_ncyl   = cl->cl_g.dkg_ncyl;
        dkl->dkl_acyl   = cl->cl_g.dkg_acyl;
        dkl->dkl_nhead  = cl->cl_g.dkg_nhead;
        dkl->dkl_nsect  = cl->cl_g.dkg_nsect;

#if defined(_SUNOS_VTOC_8)
        dkl->dkl_obs1   = cl->cl_g.dkg_obs1;
        dkl->dkl_obs2   = cl->cl_g.dkg_obs2;
        dkl->dkl_obs3   = cl->cl_g.dkg_obs3;
        for (i = 0; i < NDKMAP; i++) {
                dkl->dkl_map[i].dkl_cylno = cl->cl_map[i].dkl_cylno;
                dkl->dkl_map[i].dkl_nblk  = cl->cl_map[i].dkl_nblk;
        }
        bcopy(cl->cl_asciilabel, dkl->dkl_asciilabel, LEN_DKL_ASCII);
#elif defined(_SUNOS_VTOC_16)
        dkl->dkl_skew   = cl->cl_dkg_skew;
#else
#error "No VTOC format defined."
#endif

        dkl->dkl_magic                  = DKL_MAGIC;
        dkl->dkl_write_reinstruct       = cl->cl_g.dkg_write_reinstruct;
        dkl->dkl_read_reinstruct        = cl->cl_g.dkg_read_reinstruct;

        /* Construct checksum for the new disk label */
        sum = 0;
        sp = (short *)dkl;
        i = sizeof (struct dk_label) / sizeof (short);
        while (i--) {
                sum ^= *sp++;
        }
        dkl->dkl_cksum = sum;

        mutex_exit(CMLB_MUTEX(cl));

        rval = cmlb_set_vtoc(cl, dkl, tg_cookie);
exit:
        kmem_free(dkl, cl->cl_sys_blocksize);
        mutex_enter(CMLB_MUTEX(cl));
        return (rval);
}

/*
 * This routine implements the DKIOCSETEFI ioctl. This ioctl is currently
 * used to write (or clear) the GPT Partition Table header (primary/backup)
 * and GUID partition Entry Array (primary/backup). It is also used to write
 * the Protective MBR.
 */
static int
cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag,
    void *tg_cookie)
{
        dk_efi_t        user_efi;
        int             shift, rval = 0;
        void            *buffer;
        diskaddr_t      tgt_lba;
        boolean_t       internal;

        if (ddi_copyin(arg, &user_efi, sizeof (dk_efi_t), flag))
                return (EFAULT);

        internal = (cl->cl_alter_behavior & CMLB_INTERNAL_MINOR_NODES) != 0;

        if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
                shift = CMLBUNIT_FORCE_P0_SHIFT;
        else
                shift = CMLBUNIT_SHIFT;

        user_efi.dki_data = (void *)(uintptr_t)user_efi.dki_data_64;

        if (user_efi.dki_length == 0 ||
            user_efi.dki_length > cmlb_tg_max_efi_xfer)
                return (EINVAL);

        tgt_lba = user_efi.dki_lba;

        mutex_enter(CMLB_MUTEX(cl));
        if ((cmlb_check_update_blockcount(cl, tg_cookie) != 0) ||
            (cl->cl_tgt_blocksize == 0) ||
            (user_efi.dki_length % cl->cl_sys_blocksize)) {
                mutex_exit(CMLB_MUTEX(cl));
                return (EINVAL);
        }
        if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize)
                tgt_lba = tgt_lba *
                    cl->cl_tgt_blocksize / cl->cl_sys_blocksize;
        mutex_exit(CMLB_MUTEX(cl));

        buffer = kmem_alloc(user_efi.dki_length, KM_SLEEP);
        if (ddi_copyin(user_efi.dki_data, buffer, user_efi.dki_length, flag)) {
                rval = EFAULT;
        } else {
                /*
                 * let's clear the vtoc labels and clear the softstate
                 * vtoc.
                 */
                mutex_enter(CMLB_MUTEX(cl));
                if (cl->cl_vtoc.v_sanity == VTOC_SANE) {
                        cmlb_dbg(CMLB_TRACE,  cl,
                            "cmlb_dkio_set_efi: CLEAR VTOC\n");
                        if (cl->cl_label_from_media == CMLB_LABEL_VTOC)
                                cmlb_clear_vtoc(cl, tg_cookie);
                        bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
                        mutex_exit(CMLB_MUTEX(cl));
                        ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
                        ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
                        (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd",
                            S_IFBLK,
                            (CMLBUNIT(dev, shift) << shift) | WD_NODE,
                            cl->cl_node_type, 0, internal);
                        (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd,raw",
                            S_IFCHR,
                            (CMLBUNIT(dev, shift) << shift) | WD_NODE,
                            cl->cl_node_type, 0, internal);
                } else
                        mutex_exit(CMLB_MUTEX(cl));

                rval = DK_TG_WRITE(cl, buffer, tgt_lba, user_efi.dki_length,
                    tg_cookie);

                if (rval == 0) {
                        mutex_enter(CMLB_MUTEX(cl));
                        cl->cl_f_geometry_is_valid = B_FALSE;
                        mutex_exit(CMLB_MUTEX(cl));
                }
        }
        kmem_free(buffer, user_efi.dki_length);
        return (rval);
}

/*
 *    Function: cmlb_dkio_get_mboot
 *
 * Description: This routine is the driver entry point for handling user
 *              requests to get the current device mboot (DKIOCGMBOOT)
 *
 *   Arguments:
 *      arg             pointer to user provided mboot structure specifying
 *                      the current mboot.
 *
 *      flag            this argument is a pass through to ddi_copyxxx()
 *                      directly from the mode argument of ioctl().
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 * Return Code: 0
 *              EINVAL
 *              EFAULT
 *              ENXIO
 */
static int
cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
{
        struct mboot    *mboot;
        int             rval;
        size_t          buffer_size;


#if defined(_SUNOS_VTOC_8)
        if ((!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) || (arg == NULL)) {
#elif defined(_SUNOS_VTOC_16)
        if (arg == NULL) {
#endif
                return (EINVAL);
        }

        /*
         * Read the mboot block, located at absolute block 0 on the target.
         */
        buffer_size = cl->cl_sys_blocksize;

        cmlb_dbg(CMLB_TRACE,  cl,
            "cmlb_dkio_get_mboot: allocation size: 0x%x\n", buffer_size);

        mboot = kmem_zalloc(buffer_size, KM_SLEEP);
        if ((rval = DK_TG_READ(cl, mboot, 0, buffer_size, tg_cookie)) == 0) {
                if (ddi_copyout(mboot, (void *)arg,
                    sizeof (struct mboot), flag) != 0) {
                        rval = EFAULT;
                }
        }
        kmem_free(mboot, buffer_size);
        return (rval);
}


/*
 *    Function: cmlb_dkio_set_mboot
 *
 * Description: This routine is the driver entry point for handling user
 *              requests to validate and set the device master boot
 *              (DKIOCSMBOOT).
 *
 *   Arguments:
 *      arg             pointer to user provided mboot structure used to set the
 *                      master boot.
 *
 *      flag            this argument is a pass through to ddi_copyxxx()
 *                      directly from the mode argument of ioctl().
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 * Return Code: 0
 *              EINVAL
 *              EFAULT
 *              ENXIO
 */
static int
cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
{
        struct mboot    *mboot = NULL;
        int             rval;
        ushort_t        magic;


        ASSERT(!mutex_owned(CMLB_MUTEX(cl)));

#if defined(_SUNOS_VTOC_8)
        if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
                return (EINVAL);
        }
#endif

        if (arg == NULL) {
                return (EINVAL);
        }

        mboot = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP);

        if (ddi_copyin((const void *)arg, mboot,
            cl->cl_sys_blocksize, flag) != 0) {
                kmem_free(mboot, cl->cl_sys_blocksize);
                return (EFAULT);
        }

        /* Is this really a master boot record? */
        magic = LE_16(mboot->signature);
        if (magic != MBB_MAGIC) {
                kmem_free(mboot, cl->cl_sys_blocksize);
                return (EINVAL);
        }

        rval = DK_TG_WRITE(cl, mboot, 0, cl->cl_sys_blocksize, tg_cookie);

        mutex_enter(CMLB_MUTEX(cl));
#if defined(__i386) || defined(__amd64)
        if (rval == 0) {
                /*
                 * mboot has been written successfully.
                 * update the fdisk and vtoc tables in memory
                 */
                rval = cmlb_update_fdisk_and_vtoc(cl, tg_cookie);
                if ((!cl->cl_f_geometry_is_valid) || (rval != 0)) {
                        mutex_exit(CMLB_MUTEX(cl));
                        kmem_free(mboot, cl->cl_sys_blocksize);
                        return (rval);
                }
        }

#ifdef __lock_lint
        cmlb_setup_default_geometry(cl, tg_cookie);
#endif

#else
        if (rval == 0) {
                /*
                 * mboot has been written successfully.
                 * set up the default geometry and VTOC
                 */
                if (cl->cl_blockcount <= CMLB_EXTVTOC_LIMIT)
                        cmlb_setup_default_geometry(cl, tg_cookie);
        }
#endif
        cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
        mutex_exit(CMLB_MUTEX(cl));
        kmem_free(mboot, cl->cl_sys_blocksize);
        return (rval);
}


#if defined(__i386) || defined(__amd64)
/*ARGSUSED*/
static int
cmlb_dkio_set_ext_part(struct cmlb_lun *cl, caddr_t arg, int flag,
    void *tg_cookie)
{
        int fdisk_rval;
        diskaddr_t capacity;

        ASSERT(!mutex_owned(CMLB_MUTEX(cl)));

        mutex_enter(CMLB_MUTEX(cl));
        capacity = cl->cl_blockcount;
        fdisk_rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
        if (fdisk_rval != 0) {
                mutex_exit(CMLB_MUTEX(cl));
                return (fdisk_rval);
        }

        mutex_exit(CMLB_MUTEX(cl));
        return (fdisk_rval);
}
#endif

/*
 *    Function: cmlb_setup_default_geometry
 *
 * Description: This local utility routine sets the default geometry as part of
 *              setting the device mboot.
 *
 *   Arguments:
 *      cl              driver soft state (unit) structure
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 *
 * Note: This may be redundant with cmlb_build_default_label.
 */
static void
cmlb_setup_default_geometry(struct cmlb_lun *cl, void *tg_cookie)
{
        struct cmlb_geom        pgeom;
        struct cmlb_geom        *pgeomp = &pgeom;
        int                     ret;
        int                     geom_base_cap = 1;


        ASSERT(mutex_owned(CMLB_MUTEX(cl)));

        /* zero out the soft state geometry and partition table. */
        bzero(&cl->cl_g, sizeof (struct dk_geom));
        bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
        bzero(cl->cl_map, NDKMAP * (sizeof (struct dk_map)));

        /*
         * For the rpm, we use the minimum for the disk.
         * For the head, cyl and number of sector per track,
         * if the capacity <= 1GB, head = 64, sect = 32.
         * else head = 255, sect 63
         * Note: the capacity should be equal to C*H*S values.
         * This will cause some truncation of size due to
         * round off errors. For CD-ROMs, this truncation can
         * have adverse side effects, so returning ncyl and
         * nhead as 1. The nsect will overflow for most of
         * CD-ROMs as nsect is of type ushort.
         */
        if (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) {
                /*
                 * newfs currently can not handle 255 ntracks for SPARC
                 * so get the geometry from target driver instead of coming up
                 * with one based on capacity.
                 */
                mutex_exit(CMLB_MUTEX(cl));
                ret = DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie);
                mutex_enter(CMLB_MUTEX(cl));

                if (ret == 0) {
                        geom_base_cap = 0;
                } else {
                        cmlb_dbg(CMLB_ERROR,  cl,
                            "cmlb_setup_default_geometry: "
                            "tg_getphygeom failed %d\n", ret);

                        /* do default setting, geometry based on capacity */
                }
        }

        if (geom_base_cap) {
                if (ISCD(cl)) {
                        cl->cl_g.dkg_ncyl = 1;
                        cl->cl_g.dkg_nhead = 1;
                        cl->cl_g.dkg_nsect = cl->cl_blockcount;
                } else if (cl->cl_blockcount < 160) {
                        /* Less than 80K */
                        cl->cl_g.dkg_nhead = 1;
                        cl->cl_g.dkg_ncyl = cl->cl_blockcount;
                        cl->cl_g.dkg_nsect = 1;
                } else if (cl->cl_blockcount <= 0x1000) {
                        /* Needed for unlabeled SCSI floppies. */
                        cl->cl_g.dkg_nhead = 2;
                        cl->cl_g.dkg_ncyl = 80;
                        cl->cl_g.dkg_pcyl = 80;
                        cl->cl_g.dkg_nsect = cl->cl_blockcount / (2 * 80);
                } else if (cl->cl_blockcount <= 0x200000) {
                        cl->cl_g.dkg_nhead = 64;
                        cl->cl_g.dkg_nsect = 32;
                        cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32);
                } else {
                        cl->cl_g.dkg_nhead = 255;

                        cl->cl_g.dkg_nsect = ((cl->cl_blockcount +
                            (UINT16_MAX * 255 * 63) - 1) /
                            (UINT16_MAX * 255 * 63)) * 63;

                        if (cl->cl_g.dkg_nsect == 0)
                                cl->cl_g.dkg_nsect = (UINT16_MAX / 63) * 63;

                        cl->cl_g.dkg_ncyl = cl->cl_blockcount /
                            (255 * cl->cl_g.dkg_nsect);
                }

                cl->cl_g.dkg_acyl = 0;
                cl->cl_g.dkg_bcyl = 0;
                cl->cl_g.dkg_intrlv = 1;
                cl->cl_g.dkg_rpm = 200;
                if (cl->cl_g.dkg_pcyl == 0)
                        cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl +
                            cl->cl_g.dkg_acyl;
        } else {
                cl->cl_g.dkg_ncyl = (short)pgeomp->g_ncyl;
                cl->cl_g.dkg_acyl = pgeomp->g_acyl;
                cl->cl_g.dkg_nhead = pgeomp->g_nhead;
                cl->cl_g.dkg_nsect = pgeomp->g_nsect;
                cl->cl_g.dkg_intrlv = pgeomp->g_intrlv;
                cl->cl_g.dkg_rpm = pgeomp->g_rpm;
                cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl;
        }

        cl->cl_g.dkg_read_reinstruct = 0;
        cl->cl_g.dkg_write_reinstruct = 0;
        cl->cl_solaris_size = cl->cl_g.dkg_ncyl *
            cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;

        cl->cl_map['a'-'a'].dkl_cylno = 0;
        cl->cl_map['a'-'a'].dkl_nblk = cl->cl_solaris_size;

        cl->cl_map['c'-'a'].dkl_cylno = 0;
        cl->cl_map['c'-'a'].dkl_nblk = cl->cl_solaris_size;

        cl->cl_vtoc.v_part[2].p_tag   = V_BACKUP;
        cl->cl_vtoc.v_part[2].p_flag  = V_UNMNT;
        cl->cl_vtoc.v_nparts = V_NUMPAR;
        cl->cl_vtoc.v_version = V_VERSION;
        (void) sprintf((char *)cl->cl_asciilabel, "DEFAULT cyl %d alt %d"
            " hd %d sec %d", cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
            cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);

        cl->cl_f_geometry_is_valid = B_FALSE;
}


#if defined(__i386) || defined(__amd64)
/*
 *    Function: cmlb_update_fdisk_and_vtoc
 *
 * Description: This local utility routine updates the device fdisk and vtoc
 *              as part of setting the device mboot.
 *
 *   Arguments:
 *      cl              driver soft state (unit) structure
 *
 *      tg_cookie       cookie from target driver to be passed back to target
 *                      driver when we call back to it through tg_ops.
 *
 *
 * Return Code: 0 for success or errno-type return code.
 *
 *    Note:x86: This looks like a duplicate of cmlb_validate_geometry(), but
 *              these did exist separately in x86 sd.c.
 */
static int
cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie)
{
        int             count;
        int             label_rc = 0;
        int             fdisk_rval;
        diskaddr_t      capacity;

        ASSERT(mutex_owned(CMLB_MUTEX(cl)));

        if (cmlb_check_update_blockcount(cl, tg_cookie) != 0)
                return (EINVAL);

        /*
         * Set up the "whole disk" fdisk partition; this should always
         * exist, regardless of whether the disk contains an fdisk table
         * or vtoc.
         */
        cl->cl_map[P0_RAW_DISK].dkl_cylno = 0;
        cl->cl_map[P0_RAW_DISK].dkl_nblk = cl->cl_blockcount;

        /*
         * copy the lbasize and capacity so that if they're
         * reset while we're not holding the CMLB_MUTEX(cl), we will
         * continue to use valid values after the CMLB_MUTEX(cl) is
         * reacquired.
         */
        capacity = cl->cl_blockcount;

        /*
         * refresh the logical and physical geometry caches.
         * (data from mode sense format/rigid disk geometry pages,
         * and scsi_ifgetcap("geometry").
         */
        cmlb_resync_geom_caches(cl, capacity, tg_cookie);

        /*
         * Only DIRECT ACCESS devices will have Scl labels.
         * CD's supposedly have a Scl label, too
         */
        if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) {
                fdisk_rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
                if (fdisk_rval != 0) {
                        ASSERT(mutex_owned(CMLB_MUTEX(cl)));
                        return (fdisk_rval);
                }

                if (cl->cl_solaris_size <= DK_LABEL_LOC) {
                        /*
                         * Found fdisk table but no Solaris partition entry,
                         * so don't call cmlb_uselabel() and don't create
                         * a default label.
                         */
                        label_rc = 0;
                        cl->cl_f_geometry_is_valid = B_TRUE;
                        goto no_solaris_partition;
                }
        } else if (capacity < 0) {
                ASSERT(mutex_owned(CMLB_MUTEX(cl)));
                return (EINVAL);
        }

        /*
         * For Removable media We reach here if we have found a
         * SOLARIS PARTITION.
         * If cl_f_geometry_is_valid is B_FALSE it indicates that the SOLARIS
         * PARTITION has changed from the previous one, hence we will setup a
         * default VTOC in this case.
         */
        if (!cl->cl_f_geometry_is_valid) {
                /* if we get here it is writable */
                /* we are called from SMBOOT, and after a write of fdisk */
                cmlb_build_default_label(cl, tg_cookie);
                label_rc = 0;
        }

no_solaris_partition:

#if defined(_SUNOS_VTOC_16)
        /*
         * If we have valid geometry, set up the remaining fdisk partitions.
         * Note that dkl_cylno is not used for the fdisk map entries, so
         * we set it to an entirely bogus value.
         */
        for (count = 0; count < FDISK_PARTS; count++) {
                cl->cl_map[FDISK_P1 + count].dkl_cylno = UINT32_MAX;
                cl->cl_map[FDISK_P1 + count].dkl_nblk =
                    cl->cl_fmap[count].fmap_nblk;
                cl->cl_offset[FDISK_P1 + count] =
                    cl->cl_fmap[count].fmap_start;
        }
#endif

        for (count = 0; count < NDKMAP; count++) {
#if defined(_SUNOS_VTOC_8)
                struct dk_map *lp  = &cl->cl_map[count];
                cl->cl_offset[count] =
                    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
#elif defined(_SUNOS_VTOC_16)
                struct dkl_partition *vp = &cl->cl_vtoc.v_part[count];
                cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset;
#else
#error "No VTOC format defined."
#endif
        }

        ASSERT(mutex_owned(CMLB_MUTEX(cl)));
        return (label_rc);
}
#endif

#if defined(__i386) || defined(__amd64)
static int
cmlb_dkio_get_virtgeom(struct cmlb_lun *cl, caddr_t arg, int flag)
{
        int err = 0;

        /* Return the driver's notion of the media's logical geometry */
        struct dk_geom  disk_geom;
        struct dk_geom  *dkgp = &disk_geom;

        mutex_enter(CMLB_MUTEX(cl));
        /*
         * If there is no HBA geometry available, or
         * if the HBA 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 (cl->cl_lgeom.g_nhead == 0 ||
            cl->cl_lgeom.g_nsect == 0 ||
            cl->cl_lgeom.g_ncyl > 1024) {
                mutex_exit(CMLB_MUTEX(cl));
                err = EINVAL;
        } else {
                dkgp->dkg_ncyl  = cl->cl_lgeom.g_ncyl;
                dkgp->dkg_acyl  = cl->cl_lgeom.g_acyl;
                dkgp->dkg_pcyl  = dkgp->dkg_ncyl + dkgp->dkg_acyl;
                dkgp->dkg_nhead = cl->cl_lgeom.g_nhead;
                dkgp->dkg_nsect = cl->cl_lgeom.g_nsect;

                mutex_exit(CMLB_MUTEX(cl));
                if (ddi_copyout(dkgp, (void *)arg,
                    sizeof (struct dk_geom), flag)) {
                        err = EFAULT;
                } else {
                        err = 0;
                }
        }
        return (err);
}
#endif

#if defined(__i386) || defined(__amd64)
static int
cmlb_dkio_get_phygeom(struct cmlb_lun *cl, caddr_t  arg, int flag,
    void *tg_cookie)
{
        int err = 0;
        diskaddr_t capacity;


        /* Return the driver's notion of the media physical geometry */
        struct dk_geom  disk_geom;
        struct dk_geom  *dkgp = &disk_geom;

        mutex_enter(CMLB_MUTEX(cl));

        if (cl->cl_g.dkg_nhead != 0 &&
            cl->cl_g.dkg_nsect != 0) {
                /*
                 * We succeeded in getting a geometry, but
                 * right now it is being reported as just the
                 * Solaris fdisk partition, just like for
                 * DKIOCGGEOM. We need to change that to be
                 * correct for the entire disk now.
                 */
                bcopy(&cl->cl_g, dkgp, sizeof (*dkgp));
                dkgp->dkg_acyl = 0;
                dkgp->dkg_ncyl = cl->cl_blockcount /
                    (dkgp->dkg_nhead * dkgp->dkg_nsect);
        } else {
                bzero(dkgp, sizeof (struct dk_geom));
                /*
                 * This disk does not have a Solaris VTOC
                 * so we must present a physical geometry
                 * that will remain consistent regardless
                 * of how the disk is used. This will ensure
                 * that the geometry does not change regardless
                 * of the fdisk partition type (ie. EFI, FAT32,
                 * Solaris, etc).
                 */
                if (ISCD(cl)) {
                        dkgp->dkg_nhead = cl->cl_pgeom.g_nhead;
                        dkgp->dkg_nsect = cl->cl_pgeom.g_nsect;
                        dkgp->dkg_ncyl = cl->cl_pgeom.g_ncyl;
                        dkgp->dkg_acyl = cl->cl_pgeom.g_acyl;
                } else {
                        /*
                         * Invalid cl_blockcount can generate invalid
                         * dk_geom and may result in division by zero
                         * system failure. Should make sure blockcount
                         * is valid before using it here.
                         */
                        if (cl->cl_blockcount == 0) {
                                mutex_exit(CMLB_MUTEX(cl));
                                err = EIO;
                                return (err);
                        }
                        /*
                         * Refer to comments related to off-by-1 at the
                         * header of this file
                         */
                        if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE)
                                capacity = cl->cl_blockcount - 1;
                        else
                                capacity = cl->cl_blockcount;

                        cmlb_convert_geometry(cl, capacity, dkgp, tg_cookie);
                        dkgp->dkg_acyl = 0;
                        dkgp->dkg_ncyl = capacity /
                            (dkgp->dkg_nhead * dkgp->dkg_nsect);
                }
        }
        dkgp->dkg_pcyl = dkgp->dkg_ncyl + dkgp->dkg_acyl;

        mutex_exit(CMLB_MUTEX(cl));
        if (ddi_copyout(dkgp, (void *)arg, sizeof (struct dk_geom), flag))
                err = EFAULT;

        return (err);
}
#endif

#if defined(__i386) || defined(__amd64)
static int
cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t  arg, int flag)
{
        int err = 0;

        /*
         * Return parameters describing the selected disk slice.
         * Note: this ioctl is for the intel platform only
         */
        int part;

        if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
                part = getminor(dev) & ((1 << CMLBUNIT_FORCE_P0_SHIFT) - 1);
        else
                part = CMLBPART(dev);

        mutex_enter(CMLB_MUTEX(cl));
        /* don't check cl_solaris_size for pN */
        if (part < P0_RAW_DISK && cl->cl_solaris_size == 0) {
                err = EIO;
                mutex_exit(CMLB_MUTEX(cl));
        } else {
                struct part_info p;

                p.p_start = (daddr_t)cl->cl_offset[part];
                p.p_length = (int)cl->cl_map[part].dkl_nblk;
                mutex_exit(CMLB_MUTEX(cl));
#ifdef _MULTI_DATAMODEL
                switch (ddi_model_convert_from(flag & FMODELS)) {
                case DDI_MODEL_ILP32:
                {
                        struct part_info32 p32;

                        p32.p_start = (daddr32_t)p.p_start;
                        p32.p_length = p.p_length;
                        if (ddi_copyout(&p32, (void *)arg,
                            sizeof (p32), flag))
                                err = EFAULT;
                        break;
                }

                case DDI_MODEL_NONE:
                {
                        if (ddi_copyout(&p, (void *)arg, sizeof (p),
                            flag))
                                err = EFAULT;
                        break;
                }
                }
#else /* ! _MULTI_DATAMODEL */
                if (ddi_copyout(&p, (void *)arg, sizeof (p), flag))
                        err = EFAULT;
#endif /* _MULTI_DATAMODEL */
        }
        return (err);
}
static int
cmlb_dkio_extpartinfo(struct cmlb_lun *cl, dev_t dev, caddr_t  arg, int flag)
{
        int err = 0;

        /*
         * Return parameters describing the selected disk slice.
         * Note: this ioctl is for the intel platform only
         */
        int part;

        if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
                part = getminor(dev) & ((1 << CMLBUNIT_FORCE_P0_SHIFT) - 1);
        else
                part = CMLBPART(dev);

        mutex_enter(CMLB_MUTEX(cl));
        /* don't check cl_solaris_size for pN */
        if (part < P0_RAW_DISK && cl->cl_solaris_size == 0) {
                err = EIO;
                mutex_exit(CMLB_MUTEX(cl));
        } else {
                struct extpart_info p;

                p.p_start = (diskaddr_t)cl->cl_offset[part];
                p.p_length = (diskaddr_t)cl->cl_map[part].dkl_nblk;
                mutex_exit(CMLB_MUTEX(cl));
                if (ddi_copyout(&p, (void *)arg, sizeof (p), flag))
                        err = EFAULT;
        }
        return (err);
}
#endif

int
cmlb_prop_op(cmlb_handle_t cmlbhandle,
    dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
    char *name, caddr_t valuep, int *lengthp, int part, void *tg_cookie)
{
        struct cmlb_lun *cl;
        diskaddr_t      capacity;
        uint32_t        lbasize;
        enum            dp { DP_NBLOCKS, DP_BLKSIZE, DP_SSD, DP_ROT } dp;
        int             callers_length;
        caddr_t         buffer;
        uint64_t        nblocks64;
        uint_t          dblk;
        tg_attribute_t  tgattr;

        /* Always fallback to ddi_prop_op... */
        cl = (struct cmlb_lun *)cmlbhandle;
        if (cl == NULL) {
fallback:       return (ddi_prop_op(dev, dip, prop_op, mod_flags,
                    name, valuep, lengthp));
        }

        /* Pick up capacity and blocksize information. */
        capacity = cl->cl_blockcount;
        if (capacity == 0)
                goto fallback;
        lbasize = cl->cl_tgt_blocksize;
        if (lbasize == 0)
                lbasize = DEV_BSIZE;    /* 0 -> DEV_BSIZE units */

        /* Check for dynamic property of whole device. */
        if (dev == DDI_DEV_T_ANY) {
                /* Fallback to ddi_prop_op if we don't understand.  */
                if (strcmp(name, "device-nblocks") == 0)
                        dp = DP_NBLOCKS;
                else if (strcmp(name, "device-blksize") == 0)
                        dp = DP_BLKSIZE;
                else if (strcmp(name, "device-solid-state") == 0)
                        dp = DP_SSD;
                else if (strcmp(name, "device-rotational") == 0)
                        dp = DP_ROT;
                else
                        goto fallback;

                /* get callers length, establish length of our dynamic prop */
                callers_length = *lengthp;
                if (dp == DP_NBLOCKS)
                        *lengthp = sizeof (uint64_t);
                else if ((dp == DP_BLKSIZE) || (dp == DP_SSD))
                        *lengthp = sizeof (uint32_t);

                /* service request for the length of the property */
                if (prop_op == PROP_LEN)
                        return (DDI_PROP_SUCCESS);

                switch (prop_op) {
                case PROP_LEN_AND_VAL_ALLOC:
                        if ((buffer = kmem_alloc(*lengthp,
                            (mod_flags & DDI_PROP_CANSLEEP) ?
                            KM_SLEEP : KM_NOSLEEP)) == NULL)
                                return (DDI_PROP_NO_MEMORY);
                        *(caddr_t *)valuep = buffer;    /* set callers buf */
                        break;

                case PROP_LEN_AND_VAL_BUF:
                        /* the length of the prop and the request must match */
                        if (callers_length != *lengthp)
                                return (DDI_PROP_INVAL_ARG);
                        buffer = valuep;                /* get callers buf */
                        break;

                default:
                        return (DDI_PROP_INVAL_ARG);
                }

                /* transfer the value into the buffer */
                switch (dp) {
                case DP_NBLOCKS:
                        *((uint64_t *)buffer) = capacity;
                        break;
                case DP_BLKSIZE:
                        *((uint32_t *)buffer) = lbasize;
                        break;
                case DP_SSD:
                        if (DK_TG_GETATTRIBUTE(cl, &tgattr, tg_cookie) != 0)
                                tgattr.media_is_solid_state = B_FALSE;
                        *((uint32_t *)buffer) =
                            tgattr.media_is_solid_state ? 1 : 0;
                        break;
                case DP_ROT:
                        if (DK_TG_GETATTRIBUTE(cl, &tgattr, tg_cookie) != 0)
                                tgattr.media_is_rotational = B_TRUE;
                        *((uint32_t *)buffer) =
                            tgattr.media_is_rotational ? 1 : 0;
                        break;
                }
                return (DDI_PROP_SUCCESS);
        }

        /*
         * Support dynamic size oriented properties of partition. Requests
         * issued under conditions where size is valid are passed to
         * ddi_prop_op_nblocks with the size information, otherwise the
         * request is passed to ddi_prop_op. Size depends on valid geometry.
         */
        if (!cmlb_is_valid(cmlbhandle))
                goto fallback;

        /* Get partition nblocks value. */
        (void) cmlb_partinfo(cmlbhandle, part,
            (diskaddr_t *)&nblocks64, NULL, NULL, NULL, tg_cookie);

        /*
         * Assume partition information is in sys_blocksize units, compute
         * divisor for size(9P) property representation.
         */
        dblk = lbasize / cl->cl_sys_blocksize;

        /* Now let ddi_prop_op_nblocks_blksize() handle the request. */
        return (ddi_prop_op_nblocks_blksize(dev, dip, prop_op, mod_flags,
            name, valuep, lengthp, nblocks64 / dblk, lbasize));
}