xref: /illumos-gate/usr/src/uts/common/io/cmlb.c (revision 531d0b66)

/*
 * 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;

	ASSERT(VALID_BOOLEAN(is_removable));
	ASSERT(VALID_BOOLEAN(is_hotpluggable));

	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)
{
	ASSERT(VALID_BOOLEAN(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 = VOID2BOOLEAN(
	    (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)));
	ASSERT(VALID_BOOLEAN(forcerevalid));

	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(1M) 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 = VOID2BOOLEAN(
	    (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", (caddr_t)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) {
#if defined(__sparc)
		if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
			if (!(flags & CMLB_SILENT))
				cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
				    CE_WARN,
				    "Corrupt label; wrong magic number\n");
		}
#endif
		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 = VOID2BOOLEAN(
	    (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 = VOID2BOOLEAN(
	    (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 = VOID2BOOLEAN(
	    (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));
}