xref: /illumos-gate/usr/src/uts/common/io/cmlb.c (revision e8fb11a1)
13ccda647Slclee /*
23ccda647Slclee  * CDDL HEADER START
33ccda647Slclee  *
43ccda647Slclee  * The contents of this file are subject to the terms of the
5*e8fb11a1Sshidokht  * Common Development and Distribution License (the "License").
6*e8fb11a1Sshidokht  * You may not use this file except in compliance with the License.
73ccda647Slclee  *
83ccda647Slclee  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
93ccda647Slclee  * or http://www.opensolaris.org/os/licensing.
103ccda647Slclee  * See the License for the specific language governing permissions
113ccda647Slclee  * and limitations under the License.
123ccda647Slclee  *
133ccda647Slclee  * When distributing Covered Code, include this CDDL HEADER in each
143ccda647Slclee  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
153ccda647Slclee  * If applicable, add the following below this CDDL HEADER, with the
163ccda647Slclee  * fields enclosed by brackets "[]" replaced with your own identifying
173ccda647Slclee  * information: Portions Copyright [yyyy] [name of copyright owner]
183ccda647Slclee  *
193ccda647Slclee  * CDDL HEADER END
203ccda647Slclee  */
213ccda647Slclee 
223ccda647Slclee /*
23*e8fb11a1Sshidokht  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
243ccda647Slclee  * Use is subject to license terms.
253ccda647Slclee  */
263ccda647Slclee 
273ccda647Slclee #pragma ident	"%Z%%M%	%I%	%E% SMI"
283ccda647Slclee 
293ccda647Slclee /*
303ccda647Slclee  * This module provides support for labeling operations for target
313ccda647Slclee  * drivers.
323ccda647Slclee  */
333ccda647Slclee 
343ccda647Slclee #include <sys/scsi/scsi.h>
353ccda647Slclee #include <sys/sunddi.h>
363ccda647Slclee #include <sys/dklabel.h>
373ccda647Slclee #include <sys/dkio.h>
383ccda647Slclee #include <sys/vtoc.h>
393ccda647Slclee #include <sys/dktp/fdisk.h>
403ccda647Slclee #include <sys/vtrace.h>
413ccda647Slclee #include <sys/efi_partition.h>
423ccda647Slclee #include <sys/cmlb.h>
433ccda647Slclee #include <sys/cmlb_impl.h>
443ccda647Slclee 
453ccda647Slclee /*
463ccda647Slclee  * Driver minor node structure and data table
473ccda647Slclee  */
483ccda647Slclee struct driver_minor_data {
493ccda647Slclee 	char	*name;
503ccda647Slclee 	minor_t	minor;
513ccda647Slclee 	int	type;
523ccda647Slclee };
533ccda647Slclee 
543ccda647Slclee static struct driver_minor_data dk_minor_data[] = {
553ccda647Slclee 	{"a", 0, S_IFBLK},
563ccda647Slclee 	{"b", 1, S_IFBLK},
573ccda647Slclee 	{"c", 2, S_IFBLK},
583ccda647Slclee 	{"d", 3, S_IFBLK},
593ccda647Slclee 	{"e", 4, S_IFBLK},
603ccda647Slclee 	{"f", 5, S_IFBLK},
613ccda647Slclee 	{"g", 6, S_IFBLK},
623ccda647Slclee 	{"h", 7, S_IFBLK},
633ccda647Slclee #if defined(_SUNOS_VTOC_16)
643ccda647Slclee 	{"i", 8, S_IFBLK},
653ccda647Slclee 	{"j", 9, S_IFBLK},
663ccda647Slclee 	{"k", 10, S_IFBLK},
673ccda647Slclee 	{"l", 11, S_IFBLK},
683ccda647Slclee 	{"m", 12, S_IFBLK},
693ccda647Slclee 	{"n", 13, S_IFBLK},
703ccda647Slclee 	{"o", 14, S_IFBLK},
713ccda647Slclee 	{"p", 15, S_IFBLK},
723ccda647Slclee #endif			/* defined(_SUNOS_VTOC_16) */
733ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
743ccda647Slclee 	{"q", 16, S_IFBLK},
753ccda647Slclee 	{"r", 17, S_IFBLK},
763ccda647Slclee 	{"s", 18, S_IFBLK},
773ccda647Slclee 	{"t", 19, S_IFBLK},
783ccda647Slclee 	{"u", 20, S_IFBLK},
793ccda647Slclee #endif			/* defined(_FIRMWARE_NEEDS_FDISK) */
803ccda647Slclee 	{"a,raw", 0, S_IFCHR},
813ccda647Slclee 	{"b,raw", 1, S_IFCHR},
823ccda647Slclee 	{"c,raw", 2, S_IFCHR},
833ccda647Slclee 	{"d,raw", 3, S_IFCHR},
843ccda647Slclee 	{"e,raw", 4, S_IFCHR},
853ccda647Slclee 	{"f,raw", 5, S_IFCHR},
863ccda647Slclee 	{"g,raw", 6, S_IFCHR},
873ccda647Slclee 	{"h,raw", 7, S_IFCHR},
883ccda647Slclee #if defined(_SUNOS_VTOC_16)
893ccda647Slclee 	{"i,raw", 8, S_IFCHR},
903ccda647Slclee 	{"j,raw", 9, S_IFCHR},
913ccda647Slclee 	{"k,raw", 10, S_IFCHR},
923ccda647Slclee 	{"l,raw", 11, S_IFCHR},
933ccda647Slclee 	{"m,raw", 12, S_IFCHR},
943ccda647Slclee 	{"n,raw", 13, S_IFCHR},
953ccda647Slclee 	{"o,raw", 14, S_IFCHR},
963ccda647Slclee 	{"p,raw", 15, S_IFCHR},
973ccda647Slclee #endif			/* defined(_SUNOS_VTOC_16) */
983ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
993ccda647Slclee 	{"q,raw", 16, S_IFCHR},
1003ccda647Slclee 	{"r,raw", 17, S_IFCHR},
1013ccda647Slclee 	{"s,raw", 18, S_IFCHR},
1023ccda647Slclee 	{"t,raw", 19, S_IFCHR},
1033ccda647Slclee 	{"u,raw", 20, S_IFCHR},
1043ccda647Slclee #endif			/* defined(_FIRMWARE_NEEDS_FDISK) */
1053ccda647Slclee 	{0}
1063ccda647Slclee };
1073ccda647Slclee 
1083ccda647Slclee static struct driver_minor_data dk_minor_data_efi[] = {
1093ccda647Slclee 	{"a", 0, S_IFBLK},
1103ccda647Slclee 	{"b", 1, S_IFBLK},
1113ccda647Slclee 	{"c", 2, S_IFBLK},
1123ccda647Slclee 	{"d", 3, S_IFBLK},
1133ccda647Slclee 	{"e", 4, S_IFBLK},
1143ccda647Slclee 	{"f", 5, S_IFBLK},
1153ccda647Slclee 	{"g", 6, S_IFBLK},
1163ccda647Slclee 	{"wd", 7, S_IFBLK},
1173ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
1183ccda647Slclee 	{"q", 16, S_IFBLK},
1193ccda647Slclee 	{"r", 17, S_IFBLK},
1203ccda647Slclee 	{"s", 18, S_IFBLK},
1213ccda647Slclee 	{"t", 19, S_IFBLK},
1223ccda647Slclee 	{"u", 20, S_IFBLK},
1233ccda647Slclee #endif			/* defined(_FIRMWARE_NEEDS_FDISK) */
1243ccda647Slclee 	{"a,raw", 0, S_IFCHR},
1253ccda647Slclee 	{"b,raw", 1, S_IFCHR},
1263ccda647Slclee 	{"c,raw", 2, S_IFCHR},
1273ccda647Slclee 	{"d,raw", 3, S_IFCHR},
1283ccda647Slclee 	{"e,raw", 4, S_IFCHR},
1293ccda647Slclee 	{"f,raw", 5, S_IFCHR},
1303ccda647Slclee 	{"g,raw", 6, S_IFCHR},
1313ccda647Slclee 	{"wd,raw", 7, S_IFCHR},
1323ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
1333ccda647Slclee 	{"q,raw", 16, S_IFCHR},
1343ccda647Slclee 	{"r,raw", 17, S_IFCHR},
1353ccda647Slclee 	{"s,raw", 18, S_IFCHR},
1363ccda647Slclee 	{"t,raw", 19, S_IFCHR},
1373ccda647Slclee 	{"u,raw", 20, S_IFCHR},
1383ccda647Slclee #endif			/* defined(_FIRMWARE_NEEDS_FDISK) */
1393ccda647Slclee 	{0}
1403ccda647Slclee };
1413ccda647Slclee 
1423ccda647Slclee 
1433ccda647Slclee 
1443ccda647Slclee extern struct mod_ops mod_miscops;
1453ccda647Slclee 
1463ccda647Slclee /*
1473ccda647Slclee  * Global buffer and mutex for debug logging
1483ccda647Slclee  */
1493ccda647Slclee static char	cmlb_log_buffer[1024];
1503ccda647Slclee static kmutex_t	cmlb_log_mutex;
1513ccda647Slclee 
1523ccda647Slclee 
153*e8fb11a1Sshidokht struct cmlb_lun *cmlb_debug_cl = NULL;
1543ccda647Slclee uint_t cmlb_level_mask = 0x0;
1553ccda647Slclee 
1563ccda647Slclee int cmlb_rot_delay = 4;	/* default rotational delay */
1573ccda647Slclee 
1583ccda647Slclee static struct modlmisc modlmisc = {
1593ccda647Slclee 	&mod_miscops,   /* Type of module */
1603ccda647Slclee 	"Common Labeling module %I%"
1613ccda647Slclee };
1623ccda647Slclee 
1633ccda647Slclee static struct modlinkage modlinkage = {
1643ccda647Slclee 	MODREV_1, (void *)&modlmisc, NULL
1653ccda647Slclee };
1663ccda647Slclee 
1673ccda647Slclee /* Local function prototypes */
168*e8fb11a1Sshidokht static dev_t cmlb_make_device(struct cmlb_lun *cl);
169*e8fb11a1Sshidokht static int cmlb_validate_geometry(struct cmlb_lun *cl, int forcerevalid,
170*e8fb11a1Sshidokht     int flags, void *tg_cookie);
171*e8fb11a1Sshidokht static void cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity,
172*e8fb11a1Sshidokht     void *tg_cookie);
173*e8fb11a1Sshidokht static int cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity,
174*e8fb11a1Sshidokht     void *tg_cookie);
1753ccda647Slclee static void cmlb_swap_efi_gpt(efi_gpt_t *e);
1763ccda647Slclee static void cmlb_swap_efi_gpe(int nparts, efi_gpe_t *p);
1773ccda647Slclee static int cmlb_validate_efi(efi_gpt_t *labp);
178*e8fb11a1Sshidokht static int cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags,
179*e8fb11a1Sshidokht     void *tg_cookie);
180*e8fb11a1Sshidokht static void cmlb_build_default_label(struct cmlb_lun *cl, void *tg_cookie);
181*e8fb11a1Sshidokht static int  cmlb_uselabel(struct cmlb_lun *cl,  struct dk_label *l, int flags);
182*e8fb11a1Sshidokht #if defined(_SUNOS_VTOC_8)
183*e8fb11a1Sshidokht static void cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc);
184*e8fb11a1Sshidokht #endif
185*e8fb11a1Sshidokht static int cmlb_build_label_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc);
186*e8fb11a1Sshidokht static int cmlb_write_label(struct cmlb_lun *cl, void *tg_cookie);
187*e8fb11a1Sshidokht static int cmlb_set_vtoc(struct cmlb_lun *cl, struct dk_label *dkl,
188*e8fb11a1Sshidokht     void *tg_cookie);
189*e8fb11a1Sshidokht static void cmlb_clear_efi(struct cmlb_lun *cl, void *tg_cookie);
190*e8fb11a1Sshidokht static void cmlb_clear_vtoc(struct cmlb_lun *cl, void *tg_cookie);
191*e8fb11a1Sshidokht static void cmlb_setup_default_geometry(struct cmlb_lun *cl, void *tg_cookie);
192*e8fb11a1Sshidokht static int cmlb_create_minor_nodes(struct cmlb_lun *cl);
193*e8fb11a1Sshidokht static int cmlb_check_update_blockcount(struct cmlb_lun *cl, void *tg_cookie);
1943ccda647Slclee 
1953ccda647Slclee #if defined(__i386) || defined(__amd64)
196*e8fb11a1Sshidokht static int cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie);
1973ccda647Slclee #endif
1983ccda647Slclee 
1993ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
2003ccda647Slclee static int  cmlb_has_max_chs_vals(struct ipart *fdp);
2013ccda647Slclee #endif
2023ccda647Slclee 
2033ccda647Slclee #if defined(_SUNOS_VTOC_16)
204*e8fb11a1Sshidokht static void cmlb_convert_geometry(diskaddr_t capacity, struct dk_geom *cl_g);
2053ccda647Slclee #endif
2063ccda647Slclee 
207*e8fb11a1Sshidokht static int cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag,
208*e8fb11a1Sshidokht     void *tg_cookie);
209*e8fb11a1Sshidokht static int cmlb_dkio_set_geometry(struct cmlb_lun *cl, caddr_t arg, int flag);
210*e8fb11a1Sshidokht static int cmlb_dkio_get_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
211*e8fb11a1Sshidokht     void *tg_cookie);
212*e8fb11a1Sshidokht static int cmlb_dkio_set_partition(struct cmlb_lun *cl, caddr_t arg, int flag);
213*e8fb11a1Sshidokht static int cmlb_dkio_get_efi(struct cmlb_lun *cl, caddr_t arg, int flag,
214*e8fb11a1Sshidokht     void *tg_cookie);
215*e8fb11a1Sshidokht static int cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
216*e8fb11a1Sshidokht     int flag, void *tg_cookie);
217*e8fb11a1Sshidokht static int cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
218*e8fb11a1Sshidokht     void *tg_cookie);
219*e8fb11a1Sshidokht static int cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
220*e8fb11a1Sshidokht     int flag, void *tg_cookie);
221*e8fb11a1Sshidokht static int cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag,
222*e8fb11a1Sshidokht     void *tg_cookie);
223*e8fb11a1Sshidokht static int cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag,
224*e8fb11a1Sshidokht     void *tg_cookie);
225*e8fb11a1Sshidokht static int cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
226*e8fb11a1Sshidokht     void *tg_cookie);
2273ccda647Slclee 
2283ccda647Slclee #if defined(__i386) || defined(__amd64)
229*e8fb11a1Sshidokht static int cmlb_dkio_get_virtgeom(struct cmlb_lun *cl, caddr_t arg, int flag);
230*e8fb11a1Sshidokht static int cmlb_dkio_get_phygeom(struct cmlb_lun *cl, caddr_t  arg, int flag);
231*e8fb11a1Sshidokht static int cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
2323ccda647Slclee     int flag);
2333ccda647Slclee #endif
2343ccda647Slclee 
235*e8fb11a1Sshidokht static void cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...);
2363ccda647Slclee static void cmlb_v_log(dev_info_t *dev, char *label, uint_t level,
2373ccda647Slclee     const char *fmt, va_list ap);
2383ccda647Slclee static void cmlb_log(dev_info_t *dev, char *label, uint_t level,
2393ccda647Slclee     const char *fmt, ...);
2403ccda647Slclee 
2413ccda647Slclee int
2423ccda647Slclee _init(void)
2433ccda647Slclee {
2443ccda647Slclee 	mutex_init(&cmlb_log_mutex, NULL, MUTEX_DRIVER, NULL);
2453ccda647Slclee 	return (mod_install(&modlinkage));
2463ccda647Slclee }
2473ccda647Slclee 
2483ccda647Slclee int
2493ccda647Slclee _info(struct modinfo *modinfop)
2503ccda647Slclee {
2513ccda647Slclee 	return (mod_info(&modlinkage, modinfop));
2523ccda647Slclee }
2533ccda647Slclee 
2543ccda647Slclee int
2553ccda647Slclee _fini(void)
2563ccda647Slclee {
2573ccda647Slclee 	int err;
2583ccda647Slclee 
2593ccda647Slclee 	if ((err = mod_remove(&modlinkage)) != 0) {
2603ccda647Slclee 		return (err);
2613ccda647Slclee 	}
2623ccda647Slclee 
2633ccda647Slclee 	mutex_destroy(&cmlb_log_mutex);
2643ccda647Slclee 	return (err);
2653ccda647Slclee }
2663ccda647Slclee 
2673ccda647Slclee /*
2683ccda647Slclee  * cmlb_dbg is used for debugging to log additional info
2693ccda647Slclee  * Level of output is controlled via cmlb_level_mask setting.
2703ccda647Slclee  */
2713ccda647Slclee static void
272*e8fb11a1Sshidokht cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...)
2733ccda647Slclee {
2743ccda647Slclee 	va_list		ap;
2753ccda647Slclee 	dev_info_t	*dev;
2763ccda647Slclee 	uint_t		level_mask = 0;
2773ccda647Slclee 
278*e8fb11a1Sshidokht 	ASSERT(cl != NULL);
279*e8fb11a1Sshidokht 	dev = CMLB_DEVINFO(cl);
2803ccda647Slclee 	ASSERT(dev != NULL);
2813ccda647Slclee 	/*
2823ccda647Slclee 	 * Filter messages based on the global component and level masks,
283*e8fb11a1Sshidokht 	 * also print if cl matches the value of cmlb_debug_cl, or if
284*e8fb11a1Sshidokht 	 * cmlb_debug_cl is set to NULL.
2853ccda647Slclee 	 */
2863ccda647Slclee 	if (comp & CMLB_TRACE)
2873ccda647Slclee 		level_mask |= CMLB_LOGMASK_TRACE;
2883ccda647Slclee 
2893ccda647Slclee 	if (comp & CMLB_INFO)
2903ccda647Slclee 		level_mask |= CMLB_LOGMASK_INFO;
2913ccda647Slclee 
2923ccda647Slclee 	if (comp & CMLB_ERROR)
2933ccda647Slclee 		level_mask |= CMLB_LOGMASK_ERROR;
2943ccda647Slclee 
2953ccda647Slclee 	if ((cmlb_level_mask & level_mask) &&
296*e8fb11a1Sshidokht 	    ((cmlb_debug_cl == NULL) || (cmlb_debug_cl == cl))) {
2973ccda647Slclee 		va_start(ap, fmt);
298*e8fb11a1Sshidokht 		cmlb_v_log(dev, CMLB_LABEL(cl), CE_CONT, fmt, ap);
2993ccda647Slclee 		va_end(ap);
3003ccda647Slclee 	}
3013ccda647Slclee }
3023ccda647Slclee 
3033ccda647Slclee /*
3043ccda647Slclee  * cmlb_log is basically a duplicate of scsi_log. It is redefined here
3053ccda647Slclee  * so that this module does not depend on scsi module.
3063ccda647Slclee  */
3073ccda647Slclee static void
3083ccda647Slclee cmlb_log(dev_info_t *dev, char *label, uint_t level, const char *fmt, ...)
3093ccda647Slclee {
3103ccda647Slclee 	va_list		ap;
3113ccda647Slclee 
3123ccda647Slclee 	va_start(ap, fmt);
3133ccda647Slclee 	cmlb_v_log(dev, label, level, fmt, ap);
3143ccda647Slclee 	va_end(ap);
3153ccda647Slclee }
3163ccda647Slclee 
3173ccda647Slclee static void
3183ccda647Slclee cmlb_v_log(dev_info_t *dev, char *label, uint_t level, const char *fmt,
3193ccda647Slclee     va_list ap)
3203ccda647Slclee {
3213ccda647Slclee 	static char 	name[256];
3223ccda647Slclee 	int 		log_only = 0;
3233ccda647Slclee 	int 		boot_only = 0;
3243ccda647Slclee 	int 		console_only = 0;
3253ccda647Slclee 
3263ccda647Slclee 	mutex_enter(&cmlb_log_mutex);
3273ccda647Slclee 
3283ccda647Slclee 	if (dev) {
3293ccda647Slclee 		if (level == CE_PANIC || level == CE_WARN ||
3303ccda647Slclee 		    level == CE_NOTE) {
3313ccda647Slclee 			(void) sprintf(name, "%s (%s%d):\n",
3323ccda647Slclee 			    ddi_pathname(dev, cmlb_log_buffer),
3333ccda647Slclee 			    label, ddi_get_instance(dev));
3343ccda647Slclee 		} else {
3353ccda647Slclee 			name[0] = '\0';
3363ccda647Slclee 		}
3373ccda647Slclee 	} else {
3383ccda647Slclee 		(void) sprintf(name, "%s:", label);
3393ccda647Slclee 	}
3403ccda647Slclee 
3413ccda647Slclee 	(void) vsprintf(cmlb_log_buffer, fmt, ap);
3423ccda647Slclee 
3433ccda647Slclee 	switch (cmlb_log_buffer[0]) {
3443ccda647Slclee 	case '!':
3453ccda647Slclee 		log_only = 1;
3463ccda647Slclee 		break;
3473ccda647Slclee 	case '?':
3483ccda647Slclee 		boot_only = 1;
3493ccda647Slclee 		break;
3503ccda647Slclee 	case '^':
3513ccda647Slclee 		console_only = 1;
3523ccda647Slclee 		break;
3533ccda647Slclee 	}
3543ccda647Slclee 
3553ccda647Slclee 	switch (level) {
3563ccda647Slclee 	case CE_NOTE:
3573ccda647Slclee 		level = CE_CONT;
3583ccda647Slclee 		/* FALLTHROUGH */
3593ccda647Slclee 	case CE_CONT:
3603ccda647Slclee 	case CE_WARN:
3613ccda647Slclee 	case CE_PANIC:
3623ccda647Slclee 		if (boot_only) {
3633ccda647Slclee 			cmn_err(level, "?%s\t%s", name, &cmlb_log_buffer[1]);
3643ccda647Slclee 		} else if (console_only) {
3653ccda647Slclee 			cmn_err(level, "^%s\t%s", name, &cmlb_log_buffer[1]);
3663ccda647Slclee 		} else if (log_only) {
3673ccda647Slclee 			cmn_err(level, "!%s\t%s", name, &cmlb_log_buffer[1]);
3683ccda647Slclee 		} else {
3693ccda647Slclee 			cmn_err(level, "%s\t%s", name, cmlb_log_buffer);
3703ccda647Slclee 		}
3713ccda647Slclee 		break;
3723ccda647Slclee 	case CE_IGNORE:
3733ccda647Slclee 		break;
3743ccda647Slclee 	default:
3753ccda647Slclee 		cmn_err(CE_CONT, "^DEBUG: %s\t%s", name, cmlb_log_buffer);
3763ccda647Slclee 		break;
3773ccda647Slclee 	}
3783ccda647Slclee 	mutex_exit(&cmlb_log_mutex);
3793ccda647Slclee }
3803ccda647Slclee 
3813ccda647Slclee 
3823ccda647Slclee /*
3833ccda647Slclee  * cmlb_alloc_handle:
3843ccda647Slclee  *
3853ccda647Slclee  *	Allocates a handle.
3863ccda647Slclee  *
3873ccda647Slclee  * Arguments:
3883ccda647Slclee  *	cmlbhandlep	pointer to handle
3893ccda647Slclee  *
3903ccda647Slclee  * Notes:
3913ccda647Slclee  *	Allocates a handle and stores the allocated handle in the area
3923ccda647Slclee  *	pointed to by cmlbhandlep
3933ccda647Slclee  *
3943ccda647Slclee  * Context:
3953ccda647Slclee  *	Kernel thread only (can sleep).
3963ccda647Slclee  */
3973ccda647Slclee void
3983ccda647Slclee cmlb_alloc_handle(cmlb_handle_t *cmlbhandlep)
3993ccda647Slclee {
400*e8fb11a1Sshidokht 	struct cmlb_lun 	*cl;
4013ccda647Slclee 
402*e8fb11a1Sshidokht 	cl = kmem_zalloc(sizeof (struct cmlb_lun), KM_SLEEP);
4033ccda647Slclee 	ASSERT(cmlbhandlep != NULL);
4043ccda647Slclee 
405*e8fb11a1Sshidokht 	cl->cl_state = CMLB_INITED;
406*e8fb11a1Sshidokht 	cl->cl_def_labeltype = CMLB_LABEL_UNDEF;
407*e8fb11a1Sshidokht 	mutex_init(CMLB_MUTEX(cl), NULL, MUTEX_DRIVER, NULL);
4083ccda647Slclee 
409*e8fb11a1Sshidokht 	*cmlbhandlep = (cmlb_handle_t)(cl);
4103ccda647Slclee }
4113ccda647Slclee 
4123ccda647Slclee /*
4133ccda647Slclee  * cmlb_free_handle
4143ccda647Slclee  *
4153ccda647Slclee  *	Frees handle.
4163ccda647Slclee  *
4173ccda647Slclee  * Arguments:
4183ccda647Slclee  *	cmlbhandlep	pointer to handle
4193ccda647Slclee  */
4203ccda647Slclee void
4213ccda647Slclee cmlb_free_handle(cmlb_handle_t *cmlbhandlep)
4223ccda647Slclee {
423*e8fb11a1Sshidokht 	struct cmlb_lun 	*cl;
4243ccda647Slclee 
425*e8fb11a1Sshidokht 	cl = (struct cmlb_lun *)*cmlbhandlep;
426*e8fb11a1Sshidokht 	if (cl != NULL) {
427*e8fb11a1Sshidokht 		mutex_destroy(CMLB_MUTEX(cl));
428*e8fb11a1Sshidokht 		kmem_free(cl, sizeof (struct cmlb_lun));
4293ccda647Slclee 	}
4303ccda647Slclee 
4313ccda647Slclee }
4323ccda647Slclee 
4333ccda647Slclee /*
4343ccda647Slclee  * cmlb_attach:
4353ccda647Slclee  *
4363ccda647Slclee  *	Attach handle to device, create minor nodes for device.
4373ccda647Slclee  *
4383ccda647Slclee  * Arguments:
4393ccda647Slclee  * 	devi		pointer to device's dev_info structure.
4403ccda647Slclee  * 	tgopsp		pointer to array of functions cmlb can use to callback
4413ccda647Slclee  *			to target driver.
4423ccda647Slclee  *
4433ccda647Slclee  *	device_type	Peripheral device type as defined in
4443ccda647Slclee  *			scsi/generic/inquiry.h
4453ccda647Slclee  *
4463ccda647Slclee  *	is_removable	whether or not device is removable.
4473ccda647Slclee  *			0 non-removable, 1 removable.
4483ccda647Slclee  *
449*e8fb11a1Sshidokht  *	is_hotpluggable	whether or not device is hotpluggable.
450*e8fb11a1Sshidokht  *			0 non-hotpluggable, 1 hotpluggable.
451*e8fb11a1Sshidokht  *
4523ccda647Slclee  *	node_type	minor node type (as used by ddi_create_minor_node)
4533ccda647Slclee  *
4543ccda647Slclee  *	alter_behavior
4553ccda647Slclee  *			bit flags:
4563ccda647Slclee  *
4573ccda647Slclee  *			CMLB_CREATE_ALTSLICE_VTOC_16_DTYPE_DIRECT: create
4583ccda647Slclee  *			an alternate slice for the default label, if
4593ccda647Slclee  *			device type is DTYPE_DIRECT an architectures default
4603ccda647Slclee  *			label type is VTOC16.
4613ccda647Slclee  *			Otherwise alternate slice will no be created.
4623ccda647Slclee  *
4633ccda647Slclee  *
4643ccda647Slclee  *			CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8: report a default
4653ccda647Slclee  *			geometry and label for DKIOCGGEOM and DKIOCGVTOC
4663ccda647Slclee  *			on architecture with VTOC8 label types.
4673ccda647Slclee  *
468*e8fb11a1Sshidokht  * 			CMLB_OFF_BY_ONE: do the workaround for legacy off-by-
469*e8fb11a1Sshidokht  *                      one bug in obtaining capacity (in sd):
470*e8fb11a1Sshidokht  *			SCSI READ_CAPACITY command returns the LBA number of the
471*e8fb11a1Sshidokht  *			last logical block, but sd once treated this number as
472*e8fb11a1Sshidokht  *			disks' capacity on x86 platform. And LBAs are addressed
473*e8fb11a1Sshidokht  *			based 0. So the last block was lost on x86 platform.
474*e8fb11a1Sshidokht  *
475*e8fb11a1Sshidokht  *			Now, we remove this workaround. In order for present sd
476*e8fb11a1Sshidokht  *			driver to work with disks which are labeled/partitioned
477*e8fb11a1Sshidokht  *			via previous sd, we add workaround as follows:
478*e8fb11a1Sshidokht  *
479*e8fb11a1Sshidokht  *			1) Locate backup EFI label: cmlb searches the next to
480*e8fb11a1Sshidokht  *			   last
481*e8fb11a1Sshidokht  *			   block for backup EFI label. If fails, it will
482*e8fb11a1Sshidokht  *			   turn to the last block for backup EFI label;
483*e8fb11a1Sshidokht  *
484*e8fb11a1Sshidokht  *			2) Clear backup EFI label: cmlb first search the last
485*e8fb11a1Sshidokht  *			   block for backup EFI label, and will search the
486*e8fb11a1Sshidokht  *			   next to last block only if failed for the last
487*e8fb11a1Sshidokht  *			   block.
488*e8fb11a1Sshidokht  *
489*e8fb11a1Sshidokht  *			3) Calculate geometry:refer to cmlb_convert_geometry()
490*e8fb11a1Sshidokht  *			   If capacity increasing by 1 causes disks' capacity
491*e8fb11a1Sshidokht  *			   to cross over the limits in table CHS_values,
492*e8fb11a1Sshidokht  *			   geometry info will change. This will raise an issue:
493*e8fb11a1Sshidokht  *			   In case that primary VTOC label is destroyed, format
494*e8fb11a1Sshidokht  *			   commandline can restore it via backup VTOC labels.
495*e8fb11a1Sshidokht  *			   And format locates backup VTOC labels by use of
496*e8fb11a1Sshidokht  *			   geometry. So changing geometry will
497*e8fb11a1Sshidokht  *			   prevent format from finding backup VTOC labels. To
498*e8fb11a1Sshidokht  *			   eliminate this side effect for compatibility,
499*e8fb11a1Sshidokht  *			   sd uses (capacity -1) to calculate geometry;
500*e8fb11a1Sshidokht  *
501*e8fb11a1Sshidokht  *			4) 1TB disks: some important data structures use
502*e8fb11a1Sshidokht  *			   32-bit signed long/int (for example, daddr_t),
503*e8fb11a1Sshidokht  *			   so that sd doesn't support a disk with capacity
504*e8fb11a1Sshidokht  *			   larger than 1TB on 32-bit platform. However,
505*e8fb11a1Sshidokht  *			   for exactly 1TB disk, it was treated as (1T - 512)B
506*e8fb11a1Sshidokht  *			   in the past, and could have valid Solaris
507*e8fb11a1Sshidokht  *			   partitions. To workaround this, if an exactly 1TB
508*e8fb11a1Sshidokht  *			   disk has Solaris fdisk partition, it will be allowed
509*e8fb11a1Sshidokht  *			   to work with sd.
510*e8fb11a1Sshidokht  *
511*e8fb11a1Sshidokht  *
5123ccda647Slclee  *
5133ccda647Slclee  *	cmlbhandle	cmlb handle associated with device
5143ccda647Slclee  *
515*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
516*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
517*e8fb11a1Sshidokht  *
5183ccda647Slclee  * Notes:
5193ccda647Slclee  *	Assumes a default label based on capacity for non-removable devices.
5203ccda647Slclee  *	If capacity > 1TB, EFI is assumed otherwise VTOC (default VTOC
5213ccda647Slclee  *	for the architecture).
5223ccda647Slclee  *
5233ccda647Slclee  *	For removable devices, default label type is assumed to be VTOC
5243ccda647Slclee  *	type. Create minor nodes based on a default label type.
5253ccda647Slclee  *	Label on the media is not validated.
5263ccda647Slclee  *	minor number consists of:
5273ccda647Slclee  *		if _SUNOS_VTOC_8 is defined
5283ccda647Slclee  *			lowest 3 bits is taken as partition number
5293ccda647Slclee  *			the rest is instance number
5303ccda647Slclee  *		if _SUNOS_VTOC_16 is defined
5313ccda647Slclee  *			lowest 6 bits is taken as partition number
5323ccda647Slclee  *			the rest is instance number
5333ccda647Slclee  *
5343ccda647Slclee  *
5353ccda647Slclee  * Return values:
5363ccda647Slclee  *	0 	Success
5373ccda647Slclee  * 	ENXIO 	creating minor nodes failed.
538*e8fb11a1Sshidokht  *	EINVAL  invalid arg, unsupported tg_ops version
5393ccda647Slclee  */
5403ccda647Slclee int
5413ccda647Slclee cmlb_attach(dev_info_t *devi, cmlb_tg_ops_t *tgopsp, int device_type,
542*e8fb11a1Sshidokht     int is_removable, int is_hotpluggable, char *node_type,
543*e8fb11a1Sshidokht     int alter_behavior, cmlb_handle_t cmlbhandle, void *tg_cookie)
5443ccda647Slclee {
5453ccda647Slclee 
546*e8fb11a1Sshidokht 	struct cmlb_lun	*cl = (struct cmlb_lun *)cmlbhandle;
5473ccda647Slclee 	diskaddr_t	cap;
5483ccda647Slclee 	int		status;
5493ccda647Slclee 
550*e8fb11a1Sshidokht 	if (tgopsp->tg_version < TG_DK_OPS_VERSION_1)
551*e8fb11a1Sshidokht 		return (EINVAL);
5523ccda647Slclee 
553*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
554*e8fb11a1Sshidokht 
555*e8fb11a1Sshidokht 	CMLB_DEVINFO(cl) = devi;
556*e8fb11a1Sshidokht 	cl->cmlb_tg_ops = tgopsp;
557*e8fb11a1Sshidokht 	cl->cl_device_type = device_type;
558*e8fb11a1Sshidokht 	cl->cl_is_removable = is_removable;
559*e8fb11a1Sshidokht 	cl->cl_is_hotpluggable = is_hotpluggable;
560*e8fb11a1Sshidokht 	cl->cl_node_type = node_type;
561*e8fb11a1Sshidokht 	cl->cl_sys_blocksize = DEV_BSIZE;
562*e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = FALSE;
563*e8fb11a1Sshidokht 	cl->cl_def_labeltype = CMLB_LABEL_VTOC;
564*e8fb11a1Sshidokht 	cl->cl_alter_behavior = alter_behavior;
565*e8fb11a1Sshidokht 	cl->cl_reserved = -1;
5663ccda647Slclee 
5673ccda647Slclee 	if (is_removable != 0) {
568*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
569*e8fb11a1Sshidokht 		status = DK_TG_GETCAP(cl, &cap, tg_cookie);
570*e8fb11a1Sshidokht 		mutex_enter(CMLB_MUTEX(cl));
5713ccda647Slclee 		if (status == 0 && cap > DK_MAX_BLOCKS) {
5723ccda647Slclee 			/* set default EFI if > 1TB */
573*e8fb11a1Sshidokht 			cl->cl_def_labeltype = CMLB_LABEL_EFI;
5743ccda647Slclee 		}
5753ccda647Slclee 	}
5763ccda647Slclee 
5773ccda647Slclee 	/* create minor nodes based on default label type */
578*e8fb11a1Sshidokht 	cl->cl_last_labeltype = CMLB_LABEL_UNDEF;
579*e8fb11a1Sshidokht 	cl->cl_cur_labeltype = CMLB_LABEL_UNDEF;
5803ccda647Slclee 
581*e8fb11a1Sshidokht 	if (cmlb_create_minor_nodes(cl) != 0) {
582*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
5833ccda647Slclee 		return (ENXIO);
5843ccda647Slclee 	}
5853ccda647Slclee 
586*e8fb11a1Sshidokht 	cl->cl_state = CMLB_ATTACHED;
5873ccda647Slclee 
588*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
5893ccda647Slclee 	return (0);
5903ccda647Slclee }
5913ccda647Slclee 
5923ccda647Slclee /*
5933ccda647Slclee  * cmlb_detach:
5943ccda647Slclee  *
5953ccda647Slclee  * Invalidate in-core labeling data and remove all minor nodes for
5963ccda647Slclee  * the device associate with handle.
5973ccda647Slclee  *
5983ccda647Slclee  * Arguments:
5993ccda647Slclee  *	cmlbhandle	cmlb handle associated with device.
6003ccda647Slclee  *
601*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
602*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
603*e8fb11a1Sshidokht  *
6043ccda647Slclee  */
605*e8fb11a1Sshidokht /*ARGSUSED1*/
6063ccda647Slclee void
607*e8fb11a1Sshidokht cmlb_detach(cmlb_handle_t cmlbhandle, void *tg_cookie)
6083ccda647Slclee {
609*e8fb11a1Sshidokht 	struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
610*e8fb11a1Sshidokht 
611*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
612*e8fb11a1Sshidokht 	cl->cl_def_labeltype = CMLB_LABEL_UNDEF;
613*e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = FALSE;
614*e8fb11a1Sshidokht 	ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
615*e8fb11a1Sshidokht 	cl->cl_state = CMLB_INITED;
616*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
6173ccda647Slclee }
6183ccda647Slclee 
6193ccda647Slclee /*
6203ccda647Slclee  * cmlb_validate:
6213ccda647Slclee  *
6223ccda647Slclee  *	Validates label.
6233ccda647Slclee  *
6243ccda647Slclee  * Arguments
6253ccda647Slclee  *	cmlbhandle	cmlb handle associated with device.
6263ccda647Slclee  *
627*e8fb11a1Sshidokht  *	flags		operation flags. used for verbosity control
628*e8fb11a1Sshidokht  *
629*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
630*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
631*e8fb11a1Sshidokht  *
632*e8fb11a1Sshidokht  *
6333ccda647Slclee  * Notes:
6343ccda647Slclee  *	If new label type is different from the current, adjust minor nodes
6353ccda647Slclee  *	accordingly.
6363ccda647Slclee  *
6373ccda647Slclee  * Return values:
6383ccda647Slclee  *	0		success
6393ccda647Slclee  *			Note: having fdisk but no solaris partition is assumed
6403ccda647Slclee  *			success.
6413ccda647Slclee  *
6423ccda647Slclee  *	ENOMEM		memory allocation failed
6433ccda647Slclee  *	EIO		i/o errors during read or get capacity
6443ccda647Slclee  * 	EACCESS		reservation conflicts
6453ccda647Slclee  * 	EINVAL		label was corrupt, or no default label was assumed
6463ccda647Slclee  *	ENXIO		invalid handle
6473ccda647Slclee  */
6483ccda647Slclee int
649*e8fb11a1Sshidokht cmlb_validate(cmlb_handle_t cmlbhandle, int flags, void *tg_cookie)
6503ccda647Slclee {
651*e8fb11a1Sshidokht 	struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
6523ccda647Slclee 	int 		rval;
6533ccda647Slclee 	int  		ret = 0;
6543ccda647Slclee 
6553ccda647Slclee 	/*
656*e8fb11a1Sshidokht 	 * Temp work-around checking cl for NULL since there is a bug
6573ccda647Slclee 	 * in sd_detach calling this routine from taskq_dispatch
6583ccda647Slclee 	 * inited function.
6593ccda647Slclee 	 */
660*e8fb11a1Sshidokht 	if (cl == NULL)
6613ccda647Slclee 		return (ENXIO);
6623ccda647Slclee 
663*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
664*e8fb11a1Sshidokht 	if (cl->cl_state < CMLB_ATTACHED) {
665*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
6663ccda647Slclee 		return (ENXIO);
6673ccda647Slclee 	}
6683ccda647Slclee 
669*e8fb11a1Sshidokht 	rval = cmlb_validate_geometry((struct cmlb_lun *)cmlbhandle, 1,
670*e8fb11a1Sshidokht 	    flags, tg_cookie);
6713ccda647Slclee 
6723ccda647Slclee 	if (rval == ENOTSUP) {
673*e8fb11a1Sshidokht 		if (cl->cl_f_geometry_is_valid == TRUE) {
674*e8fb11a1Sshidokht 			cl->cl_cur_labeltype = CMLB_LABEL_EFI;
6753ccda647Slclee 			ret = 0;
6763ccda647Slclee 		} else {
6773ccda647Slclee 			ret = EINVAL;
6783ccda647Slclee 		}
6793ccda647Slclee 	} else {
6803ccda647Slclee 		ret = rval;
6813ccda647Slclee 		if (ret == 0)
682*e8fb11a1Sshidokht 			cl->cl_cur_labeltype = CMLB_LABEL_VTOC;
6833ccda647Slclee 	}
6843ccda647Slclee 
6853ccda647Slclee 	if (ret == 0)
686*e8fb11a1Sshidokht 		(void) cmlb_create_minor_nodes(cl);
6873ccda647Slclee 
688*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
6893ccda647Slclee 	return (ret);
6903ccda647Slclee }
6913ccda647Slclee 
6923ccda647Slclee /*
6933ccda647Slclee  * cmlb_invalidate:
6943ccda647Slclee  *	Invalidate in core label data
6953ccda647Slclee  *
6963ccda647Slclee  * Arguments:
6973ccda647Slclee  *	cmlbhandle	cmlb handle associated with device.
698*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
699*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
7003ccda647Slclee  */
701*e8fb11a1Sshidokht /*ARGSUSED1*/
7023ccda647Slclee void
703*e8fb11a1Sshidokht cmlb_invalidate(cmlb_handle_t cmlbhandle, void *tg_cookie)
7043ccda647Slclee {
705*e8fb11a1Sshidokht 	struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
7063ccda647Slclee 
707*e8fb11a1Sshidokht 	if (cl == NULL)
7083ccda647Slclee 		return;
7093ccda647Slclee 
710*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
711*e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = FALSE;
712*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
713*e8fb11a1Sshidokht }
714*e8fb11a1Sshidokht 
715*e8fb11a1Sshidokht /*
716*e8fb11a1Sshidokht  * cmlb_is_valid
717*e8fb11a1Sshidokht  * 	Get status on whether the incore label/geom data is valid
718*e8fb11a1Sshidokht  *
719*e8fb11a1Sshidokht  * Arguments:
720*e8fb11a1Sshidokht  *	cmlbhandle      cmlb handle associated with device.
721*e8fb11a1Sshidokht  *
722*e8fb11a1Sshidokht  * Return values:
723*e8fb11a1Sshidokht  *	TRUE if incore label/geom data is valid.
724*e8fb11a1Sshidokht  *	FALSE otherwise.
725*e8fb11a1Sshidokht  *
726*e8fb11a1Sshidokht  */
727*e8fb11a1Sshidokht 
728*e8fb11a1Sshidokht 
729*e8fb11a1Sshidokht int
730*e8fb11a1Sshidokht cmlb_is_valid(cmlb_handle_t cmlbhandle)
731*e8fb11a1Sshidokht {
732*e8fb11a1Sshidokht 	struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
733*e8fb11a1Sshidokht 
734*e8fb11a1Sshidokht 	if (cmlbhandle == NULL)
735*e8fb11a1Sshidokht 		return (FALSE);
736*e8fb11a1Sshidokht 
737*e8fb11a1Sshidokht 	return (cl->cl_f_geometry_is_valid);
738*e8fb11a1Sshidokht 
7393ccda647Slclee }
7403ccda647Slclee 
741*e8fb11a1Sshidokht 
742*e8fb11a1Sshidokht 
7433ccda647Slclee /*
7443ccda647Slclee  * cmlb_close:
7453ccda647Slclee  *
7463ccda647Slclee  * Close the device, revert to a default label minor node for the device,
7473ccda647Slclee  * if it is removable.
7483ccda647Slclee  *
7493ccda647Slclee  * Arguments:
7503ccda647Slclee  *	cmlbhandle	cmlb handle associated with device.
7513ccda647Slclee  *
752*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
753*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
7543ccda647Slclee  * Return values:
7553ccda647Slclee  *	0	Success
7563ccda647Slclee  * 	ENXIO	Re-creating minor node failed.
7573ccda647Slclee  */
758*e8fb11a1Sshidokht /*ARGSUSED1*/
7593ccda647Slclee int
760*e8fb11a1Sshidokht cmlb_close(cmlb_handle_t cmlbhandle, void *tg_cookie)
7613ccda647Slclee {
762*e8fb11a1Sshidokht 	struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
7633ccda647Slclee 
764*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
765*e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = FALSE;
7663ccda647Slclee 
7673ccda647Slclee 	/* revert to default minor node for this device */
768*e8fb11a1Sshidokht 	if (ISREMOVABLE(cl)) {
769*e8fb11a1Sshidokht 		cl->cl_cur_labeltype = CMLB_LABEL_UNDEF;
770*e8fb11a1Sshidokht 		(void) cmlb_create_minor_nodes(cl);
7713ccda647Slclee 	}
7723ccda647Slclee 
773*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
7743ccda647Slclee 	return (0);
7753ccda647Slclee }
7763ccda647Slclee 
7773ccda647Slclee /*
7783ccda647Slclee  * cmlb_get_devid_block:
7793ccda647Slclee  *	 get the block number where device id is stored.
7803ccda647Slclee  *
7813ccda647Slclee  * Arguments:
7823ccda647Slclee  *	cmlbhandle	cmlb handle associated with device.
7833ccda647Slclee  *	devidblockp	pointer to block number.
784*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
785*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
7863ccda647Slclee  *
7873ccda647Slclee  * Notes:
7883ccda647Slclee  *	It stores the block number of device id in the area pointed to
7893ccda647Slclee  *	by devidblockp.
7903ccda647Slclee  * 	with the block number of device id.
7913ccda647Slclee  *
7923ccda647Slclee  * Return values:
7933ccda647Slclee  *	0	success
7943ccda647Slclee  *	EINVAL 	device id does not apply to current label type.
7953ccda647Slclee  */
796*e8fb11a1Sshidokht /*ARGSUSED2*/
7973ccda647Slclee int
798*e8fb11a1Sshidokht cmlb_get_devid_block(cmlb_handle_t cmlbhandle, diskaddr_t *devidblockp,
799*e8fb11a1Sshidokht     void *tg_cookie)
8003ccda647Slclee {
8013ccda647Slclee 	daddr_t			spc, blk, head, cyl;
802*e8fb11a1Sshidokht 	struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
8033ccda647Slclee 
804*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
805*e8fb11a1Sshidokht 	if (cl->cl_state < CMLB_ATTACHED) {
806*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
8073ccda647Slclee 		return (EINVAL);
8083ccda647Slclee 	}
8093ccda647Slclee 
810*e8fb11a1Sshidokht 	if ((cl->cl_f_geometry_is_valid == FALSE) ||
811*e8fb11a1Sshidokht 	    (cl->cl_solaris_size < DK_LABEL_LOC)) {
812*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
813*e8fb11a1Sshidokht 		return (EINVAL);
814*e8fb11a1Sshidokht 	}
815*e8fb11a1Sshidokht 
816*e8fb11a1Sshidokht 
817*e8fb11a1Sshidokht 	if (cl->cl_cur_labeltype == CMLB_LABEL_EFI) {
818*e8fb11a1Sshidokht 		if (cl->cl_reserved != -1) {
819*e8fb11a1Sshidokht 			blk = cl->cl_map[cl->cl_reserved].dkl_cylno;
820*e8fb11a1Sshidokht 		} else {
821*e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
822*e8fb11a1Sshidokht 			return (EINVAL);
823*e8fb11a1Sshidokht 		}
824*e8fb11a1Sshidokht 	} else {
8253ccda647Slclee 		/* this geometry doesn't allow us to write a devid */
826*e8fb11a1Sshidokht 		if (cl->cl_g.dkg_acyl < 2) {
827*e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
8283ccda647Slclee 			return (EINVAL);
8293ccda647Slclee 		}
8303ccda647Slclee 
8313ccda647Slclee 		/*
8323ccda647Slclee 		 * Subtract 2 guarantees that the next to last cylinder
8333ccda647Slclee 		 * is used
8343ccda647Slclee 		 */
835*e8fb11a1Sshidokht 		cyl  = cl->cl_g.dkg_ncyl  + cl->cl_g.dkg_acyl - 2;
836*e8fb11a1Sshidokht 		spc  = cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
837*e8fb11a1Sshidokht 		head = cl->cl_g.dkg_nhead - 1;
838*e8fb11a1Sshidokht 		blk  = (cyl * (spc - cl->cl_g.dkg_apc)) +
839*e8fb11a1Sshidokht 		    (head * cl->cl_g.dkg_nsect) + 1;
8403ccda647Slclee 	}
841*e8fb11a1Sshidokht 
8423ccda647Slclee 	*devidblockp = blk;
843*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
8443ccda647Slclee 	return (0);
8453ccda647Slclee }
8463ccda647Slclee 
8473ccda647Slclee /*
8483ccda647Slclee  * cmlb_partinfo:
8493ccda647Slclee  *	Get partition info for specified partition number.
8503ccda647Slclee  *
8513ccda647Slclee  * Arguments:
8523ccda647Slclee  *	cmlbhandle	cmlb handle associated with device.
8533ccda647Slclee  *	part		partition number
8543ccda647Slclee  *	nblocksp	pointer to number of blocks
8553ccda647Slclee  *	startblockp	pointer to starting block
8563ccda647Slclee  *	partnamep	pointer to name of partition
8573ccda647Slclee  *	tagp		pointer to tag info
858*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
859*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
8603ccda647Slclee  *
8613ccda647Slclee  *
8623ccda647Slclee  * Notes:
8633ccda647Slclee  *	If in-core label is not valid, this functions tries to revalidate
8643ccda647Slclee  *	the label. If label is valid, it stores the total number of blocks
8653ccda647Slclee  *	in this partition in the area pointed to by nblocksp, starting
8663ccda647Slclee  *	block number in area pointed to by startblockp,  pointer to partition
8673ccda647Slclee  *	name in area pointed to by partnamep, and tag value in area
8683ccda647Slclee  *	pointed by tagp.
8693ccda647Slclee  *	For EFI labels, tag value will be set to 0.
8703ccda647Slclee  *
8713ccda647Slclee  *	For all nblocksp, startblockp and partnamep, tagp, a value of NULL
8723ccda647Slclee  *	indicates the corresponding info is not requested.
8733ccda647Slclee  *
8743ccda647Slclee  *
8753ccda647Slclee  * Return values:
8763ccda647Slclee  *	0	success
8773ccda647Slclee  *	EINVAL  no valid label or requested partition number is invalid.
8783ccda647Slclee  *
8793ccda647Slclee  */
8803ccda647Slclee int
8813ccda647Slclee cmlb_partinfo(cmlb_handle_t cmlbhandle, int part, diskaddr_t *nblocksp,
882*e8fb11a1Sshidokht     diskaddr_t *startblockp, char **partnamep, uint16_t *tagp, void *tg_cookie)
8833ccda647Slclee {
8843ccda647Slclee 
885*e8fb11a1Sshidokht 	struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
8863ccda647Slclee 	int rval;
8873ccda647Slclee 
888*e8fb11a1Sshidokht 	ASSERT(cl != NULL);
889*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
890*e8fb11a1Sshidokht 	if (cl->cl_state < CMLB_ATTACHED) {
891*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
8923ccda647Slclee 		return (EINVAL);
8933ccda647Slclee 	}
8943ccda647Slclee 
8953ccda647Slclee 	if (part  < 0 || part >= MAXPART) {
8963ccda647Slclee 		rval = EINVAL;
8973ccda647Slclee 	} else {
898*e8fb11a1Sshidokht 		if (cl->cl_f_geometry_is_valid == FALSE)
899*e8fb11a1Sshidokht 			(void) cmlb_validate_geometry((struct cmlb_lun *)cl, 0,
900*e8fb11a1Sshidokht 			    0, tg_cookie);
901*e8fb11a1Sshidokht 
902*e8fb11a1Sshidokht 		if ((cl->cl_f_geometry_is_valid == FALSE) ||
903*e8fb11a1Sshidokht 		    (part < NDKMAP && cl->cl_solaris_size == 0)) {
9043ccda647Slclee 			rval = EINVAL;
9053ccda647Slclee 		} else {
9063ccda647Slclee 			if (startblockp != NULL)
907*e8fb11a1Sshidokht 				*startblockp = (diskaddr_t)cl->cl_offset[part];
9083ccda647Slclee 
9093ccda647Slclee 			if (nblocksp != NULL)
9103ccda647Slclee 				*nblocksp = (diskaddr_t)
911*e8fb11a1Sshidokht 				    cl->cl_map[part].dkl_nblk;
9123ccda647Slclee 
9133ccda647Slclee 			if (tagp != NULL)
914*e8fb11a1Sshidokht 				if (cl->cl_cur_labeltype == CMLB_LABEL_EFI)
9153ccda647Slclee 					*tagp = V_UNASSIGNED;
9163ccda647Slclee 				else
917*e8fb11a1Sshidokht 					*tagp = cl->cl_vtoc.v_part[part].p_tag;
9183ccda647Slclee 			rval = 0;
9193ccda647Slclee 		}
9203ccda647Slclee 
9213ccda647Slclee 		/* consistent with behavior of sd for getting minor name */
9223ccda647Slclee 		if (partnamep != NULL)
9233ccda647Slclee 			*partnamep = dk_minor_data[part].name;
9243ccda647Slclee 
9253ccda647Slclee 	}
9263ccda647Slclee 
927*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
9283ccda647Slclee 	return (rval);
9293ccda647Slclee }
9303ccda647Slclee 
931*e8fb11a1Sshidokht /* Caller should make sure Test Unit Ready succeeds before calling this. */
932*e8fb11a1Sshidokht /*ARGSUSED*/
9333ccda647Slclee int
9343ccda647Slclee cmlb_ioctl(cmlb_handle_t cmlbhandle, dev_t dev, int cmd, intptr_t arg,
935*e8fb11a1Sshidokht     int flag, cred_t *cred_p, int *rval_p, void *tg_cookie)
9363ccda647Slclee {
9373ccda647Slclee 
9383ccda647Slclee 	int err;
939*e8fb11a1Sshidokht 	struct cmlb_lun *cl;
940*e8fb11a1Sshidokht 	int status;
9413ccda647Slclee 
942*e8fb11a1Sshidokht 	cl = (struct cmlb_lun *)cmlbhandle;
9433ccda647Slclee 
944*e8fb11a1Sshidokht 	ASSERT(cl != NULL);
9453ccda647Slclee 
946*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
947*e8fb11a1Sshidokht 	if (cl->cl_state < CMLB_ATTACHED) {
948*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
9493ccda647Slclee 		return (EIO);
9503ccda647Slclee 	}
9513ccda647Slclee 
9523ccda647Slclee 	switch (cmd) {
9533ccda647Slclee 		case DKIOCSVTOC:
954*e8fb11a1Sshidokht 		case DKIOCSGEOM:
9553ccda647Slclee 		case DKIOCSETEFI:
9563ccda647Slclee 		case DKIOCSMBOOT:
9573ccda647Slclee 			break;
9583ccda647Slclee 		default:
959*e8fb11a1Sshidokht 			status = cmlb_validate_geometry(cl, 0, 0, tg_cookie);
960*e8fb11a1Sshidokht 
9613ccda647Slclee 			/*
962*e8fb11a1Sshidokht 			 * VTOC related ioctls except SVTOC/SGEOM should
963*e8fb11a1Sshidokht 			 * fail if > 1TB disk and there is not already a VTOC
964*e8fb11a1Sshidokht 			 * on the disk.i.e either EFI or blank
965*e8fb11a1Sshidokht 			 *
966*e8fb11a1Sshidokht 			 * PHYGEOM AND VIRTGEOM succeeds when disk is
967*e8fb11a1Sshidokht 			 * EFI labeled but <1TB
9683ccda647Slclee 			 */
969*e8fb11a1Sshidokht 
970*e8fb11a1Sshidokht 			if (status == ENOTSUP &&
971*e8fb11a1Sshidokht 			    cl->cl_f_geometry_is_valid == FALSE) {
9723ccda647Slclee 				switch (cmd) {
9733ccda647Slclee 				case DKIOCGAPART:
9743ccda647Slclee 				case DKIOCGGEOM:
9753ccda647Slclee 				case DKIOCGVTOC:
9763ccda647Slclee 				case DKIOCSAPART:
977*e8fb11a1Sshidokht 				case DKIOCG_PHYGEOM:
978*e8fb11a1Sshidokht 				case DKIOCG_VIRTGEOM:
979*e8fb11a1Sshidokht 
980*e8fb11a1Sshidokht 					mutex_exit(CMLB_MUTEX(cl));
9813ccda647Slclee 					return (ENOTSUP);
9823ccda647Slclee 				}
983*e8fb11a1Sshidokht 			} else {
984*e8fb11a1Sshidokht 				if ((cl->cl_f_geometry_is_valid == TRUE) &&
985*e8fb11a1Sshidokht 				    (cl->cl_solaris_size > 0)) {
986*e8fb11a1Sshidokht 					if (cl->cl_vtoc.v_sanity != VTOC_SANE) {
987*e8fb11a1Sshidokht 					/*
988*e8fb11a1Sshidokht 					 * it is EFI, so return ENOTSUP for
989*e8fb11a1Sshidokht 					 * these
990*e8fb11a1Sshidokht 					 */
991*e8fb11a1Sshidokht 					switch (cmd) {
992*e8fb11a1Sshidokht 					case DKIOCGAPART:
993*e8fb11a1Sshidokht 					case DKIOCGGEOM:
994*e8fb11a1Sshidokht 					case DKIOCGVTOC:
995*e8fb11a1Sshidokht 					case DKIOCSVTOC:
996*e8fb11a1Sshidokht 					case DKIOCSAPART:
997*e8fb11a1Sshidokht 
998*e8fb11a1Sshidokht 						mutex_exit(CMLB_MUTEX(cl));
999*e8fb11a1Sshidokht 						return (ENOTSUP);
1000*e8fb11a1Sshidokht 					}
1001*e8fb11a1Sshidokht 				}
10023ccda647Slclee 			}
10033ccda647Slclee 		}
10043ccda647Slclee 	}
10053ccda647Slclee 
1006*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
10073ccda647Slclee 
10083ccda647Slclee 	switch (cmd) {
10093ccda647Slclee 	case DKIOCGGEOM:
1010*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCGGEOM\n");
1011*e8fb11a1Sshidokht 		err = cmlb_dkio_get_geometry(cl, (caddr_t)arg, flag, tg_cookie);
10123ccda647Slclee 		break;
10133ccda647Slclee 
10143ccda647Slclee 	case DKIOCSGEOM:
1015*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCSGEOM\n");
1016*e8fb11a1Sshidokht 		err = cmlb_dkio_set_geometry(cl, (caddr_t)arg, flag);
10173ccda647Slclee 		break;
10183ccda647Slclee 
10193ccda647Slclee 	case DKIOCGAPART:
1020*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCGAPART\n");
1021*e8fb11a1Sshidokht 		err = cmlb_dkio_get_partition(cl, (caddr_t)arg,
1022*e8fb11a1Sshidokht 		    flag, tg_cookie);
10233ccda647Slclee 		break;
10243ccda647Slclee 
10253ccda647Slclee 	case DKIOCSAPART:
1026*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCSAPART\n");
1027*e8fb11a1Sshidokht 		err = cmlb_dkio_set_partition(cl, (caddr_t)arg, flag);
10283ccda647Slclee 		break;
10293ccda647Slclee 
10303ccda647Slclee 	case DKIOCGVTOC:
1031*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCGVTOC\n");
1032*e8fb11a1Sshidokht 		err = cmlb_dkio_get_vtoc(cl, (caddr_t)arg, flag, tg_cookie);
10333ccda647Slclee 		break;
10343ccda647Slclee 
10353ccda647Slclee 	case DKIOCGETEFI:
1036*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCGETEFI\n");
1037*e8fb11a1Sshidokht 		err = cmlb_dkio_get_efi(cl, (caddr_t)arg, flag, tg_cookie);
10383ccda647Slclee 		break;
10393ccda647Slclee 
10403ccda647Slclee 	case DKIOCPARTITION:
1041*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTITION\n");
1042*e8fb11a1Sshidokht 		err = cmlb_dkio_partition(cl, (caddr_t)arg, flag, tg_cookie);
10433ccda647Slclee 		break;
10443ccda647Slclee 
10453ccda647Slclee 	case DKIOCSVTOC:
1046*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCSVTOC\n");
1047*e8fb11a1Sshidokht 		err = cmlb_dkio_set_vtoc(cl, dev, (caddr_t)arg, flag,
1048*e8fb11a1Sshidokht 		    tg_cookie);
10493ccda647Slclee 		break;
10503ccda647Slclee 
10513ccda647Slclee 	case DKIOCSETEFI:
1052*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCSETEFI\n");
1053*e8fb11a1Sshidokht 		err = cmlb_dkio_set_efi(cl, dev, (caddr_t)arg, flag, tg_cookie);
10543ccda647Slclee 		break;
10553ccda647Slclee 
10563ccda647Slclee 	case DKIOCGMBOOT:
1057*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCGMBOOT\n");
1058*e8fb11a1Sshidokht 		err = cmlb_dkio_get_mboot(cl, (caddr_t)arg, flag, tg_cookie);
10593ccda647Slclee 		break;
10603ccda647Slclee 
10613ccda647Slclee 	case DKIOCSMBOOT:
1062*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCSMBOOT\n");
1063*e8fb11a1Sshidokht 		err = cmlb_dkio_set_mboot(cl, (caddr_t)arg, flag, tg_cookie);
10643ccda647Slclee 		break;
10653ccda647Slclee 	case DKIOCG_PHYGEOM:
1066*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_PHYGEOM\n");
10673ccda647Slclee #if defined(__i386) || defined(__amd64)
1068*e8fb11a1Sshidokht 		err = cmlb_dkio_get_phygeom(cl, (caddr_t)arg, flag);
10693ccda647Slclee #else
10703ccda647Slclee 		err = ENOTTY;
10713ccda647Slclee #endif
10723ccda647Slclee 		break;
10733ccda647Slclee 	case DKIOCG_VIRTGEOM:
1074*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_VIRTGEOM\n");
10753ccda647Slclee #if defined(__i386) || defined(__amd64)
1076*e8fb11a1Sshidokht 		err = cmlb_dkio_get_virtgeom(cl, (caddr_t)arg, flag);
10773ccda647Slclee #else
10783ccda647Slclee 		err = ENOTTY;
10793ccda647Slclee #endif
10803ccda647Slclee 		break;
10813ccda647Slclee 	case DKIOCPARTINFO:
1082*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTINFO");
10833ccda647Slclee #if defined(__i386) || defined(__amd64)
1084*e8fb11a1Sshidokht 		err = cmlb_dkio_partinfo(cl, dev, (caddr_t)arg, flag);
10853ccda647Slclee #else
10863ccda647Slclee 		err = ENOTTY;
10873ccda647Slclee #endif
10883ccda647Slclee 		break;
10893ccda647Slclee 
10903ccda647Slclee 	default:
10913ccda647Slclee 		err = ENOTTY;
10923ccda647Slclee 
10933ccda647Slclee 	}
10943ccda647Slclee 	return (err);
10953ccda647Slclee }
10963ccda647Slclee 
10973ccda647Slclee dev_t
1098*e8fb11a1Sshidokht cmlb_make_device(struct cmlb_lun *cl)
10993ccda647Slclee {
1100*e8fb11a1Sshidokht 	return (makedevice(ddi_name_to_major(ddi_get_name(CMLB_DEVINFO(cl))),
1101*e8fb11a1Sshidokht 	    ddi_get_instance(CMLB_DEVINFO(cl)) << CMLBUNIT_SHIFT));
11023ccda647Slclee }
11033ccda647Slclee 
11043ccda647Slclee /*
11053ccda647Slclee  * Function: cmlb_check_update_blockcount
11063ccda647Slclee  *
11073ccda647Slclee  * Description: If current capacity value is invalid, obtains the
11083ccda647Slclee  *		current capacity from target driver.
11093ccda647Slclee  *
11103ccda647Slclee  * Return Code: 0	success
11113ccda647Slclee  *		EIO	failure
11123ccda647Slclee  */
11133ccda647Slclee static int
1114*e8fb11a1Sshidokht cmlb_check_update_blockcount(struct cmlb_lun *cl, void *tg_cookie)
11153ccda647Slclee {
11163ccda647Slclee 	int status;
11173ccda647Slclee 	diskaddr_t capacity;
1118*e8fb11a1Sshidokht 	uint32_t lbasize;
11193ccda647Slclee 
1120*e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
11213ccda647Slclee 
1122*e8fb11a1Sshidokht 	if (cl->cl_f_geometry_is_valid == FALSE)  {
1123*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
1124*e8fb11a1Sshidokht 		status = DK_TG_GETCAP(cl, &capacity, tg_cookie);
1125*e8fb11a1Sshidokht 		if (status != 0) {
1126*e8fb11a1Sshidokht 			mutex_enter(CMLB_MUTEX(cl));
1127*e8fb11a1Sshidokht 			return (EIO);
1128*e8fb11a1Sshidokht 		}
1129*e8fb11a1Sshidokht 
1130*e8fb11a1Sshidokht 		status = DK_TG_GETBLOCKSIZE(cl, &lbasize, tg_cookie);
1131*e8fb11a1Sshidokht 		mutex_enter(CMLB_MUTEX(cl));
1132*e8fb11a1Sshidokht 		if (status != 0)
1133*e8fb11a1Sshidokht 			return (EIO);
1134*e8fb11a1Sshidokht 
1135*e8fb11a1Sshidokht 		if ((capacity != 0) && (lbasize != 0)) {
1136*e8fb11a1Sshidokht 			cl->cl_blockcount = capacity;
1137*e8fb11a1Sshidokht 			cl->cl_tgt_blocksize = lbasize;
11383ccda647Slclee 			return (0);
11393ccda647Slclee 		} else
11403ccda647Slclee 			return (EIO);
11413ccda647Slclee 	} else
11423ccda647Slclee 		return (0);
11433ccda647Slclee }
11443ccda647Slclee 
11453ccda647Slclee /*
11463ccda647Slclee  *    Function: cmlb_create_minor_nodes
11473ccda647Slclee  *
11483ccda647Slclee  * Description: Create or adjust the minor device nodes for the instance.
11493ccda647Slclee  * 		Minor nodes are created based on default label type,
11503ccda647Slclee  *		current label type and last label type we created
11513ccda647Slclee  *		minor nodes based on.
11523ccda647Slclee  *
11533ccda647Slclee  *
1154*e8fb11a1Sshidokht  *   Arguments: cl - driver soft state (unit) structure
11553ccda647Slclee  *
11563ccda647Slclee  * Return Code: 0 success
11573ccda647Slclee  *		ENXIO	failure.
11583ccda647Slclee  *
11593ccda647Slclee  *     Context: Kernel thread context
11603ccda647Slclee  */
11613ccda647Slclee static int
1162*e8fb11a1Sshidokht cmlb_create_minor_nodes(struct cmlb_lun *cl)
11633ccda647Slclee {
11643ccda647Slclee 	struct driver_minor_data	*dmdp;
11653ccda647Slclee 	int				instance;
11663ccda647Slclee 	char				name[48];
11673ccda647Slclee 	cmlb_label_t			newlabeltype;
11683ccda647Slclee 
1169*e8fb11a1Sshidokht 	ASSERT(cl != NULL);
1170*e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
11713ccda647Slclee 
11723ccda647Slclee 
11733ccda647Slclee 	/* check the most common case */
1174*e8fb11a1Sshidokht 	if (cl->cl_cur_labeltype != CMLB_LABEL_UNDEF &&
1175*e8fb11a1Sshidokht 	    cl->cl_last_labeltype == cl->cl_cur_labeltype) {
11763ccda647Slclee 		/* do nothing */
11773ccda647Slclee 		return (0);
11783ccda647Slclee 	}
11793ccda647Slclee 
1180*e8fb11a1Sshidokht 	if (cl->cl_def_labeltype == CMLB_LABEL_UNDEF) {
11813ccda647Slclee 		/* we should never get here */
11823ccda647Slclee 		return (ENXIO);
11833ccda647Slclee 	}
11843ccda647Slclee 
1185*e8fb11a1Sshidokht 	if (cl->cl_last_labeltype == CMLB_LABEL_UNDEF) {
11863ccda647Slclee 		/* first time during attach */
1187*e8fb11a1Sshidokht 		newlabeltype = cl->cl_def_labeltype;
11883ccda647Slclee 
1189*e8fb11a1Sshidokht 		instance = ddi_get_instance(CMLB_DEVINFO(cl));
11903ccda647Slclee 
11913ccda647Slclee 		/* Create all the minor nodes for this target. */
11923ccda647Slclee 		dmdp = (newlabeltype == CMLB_LABEL_EFI) ? dk_minor_data_efi :
11933ccda647Slclee 		    dk_minor_data;
11943ccda647Slclee 		while (dmdp->name != NULL) {
11953ccda647Slclee 
11963ccda647Slclee 			(void) sprintf(name, "%s", dmdp->name);
11973ccda647Slclee 
1198*e8fb11a1Sshidokht 			if (ddi_create_minor_node(CMLB_DEVINFO(cl), name,
11993ccda647Slclee 			    dmdp->type,
12003ccda647Slclee 			    (instance << CMLBUNIT_SHIFT) | dmdp->minor,
1201*e8fb11a1Sshidokht 			    cl->cl_node_type, NULL) == DDI_FAILURE) {
12023ccda647Slclee 				/*
12033ccda647Slclee 				 * Clean up any nodes that may have been
12043ccda647Slclee 				 * created, in case this fails in the middle
12053ccda647Slclee 				 * of the loop.
12063ccda647Slclee 				 */
1207*e8fb11a1Sshidokht 				ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
12083ccda647Slclee 				return (ENXIO);
12093ccda647Slclee 			}
12103ccda647Slclee 			dmdp++;
12113ccda647Slclee 		}
1212*e8fb11a1Sshidokht 		cl->cl_last_labeltype = newlabeltype;
12133ccda647Slclee 		return (0);
12143ccda647Slclee 	}
12153ccda647Slclee 
12163ccda647Slclee 	/* Not first time  */
1217*e8fb11a1Sshidokht 	if (cl->cl_cur_labeltype == CMLB_LABEL_UNDEF) {
1218*e8fb11a1Sshidokht 		if (cl->cl_last_labeltype != cl->cl_def_labeltype) {
12193ccda647Slclee 			/* close time, revert to default. */
1220*e8fb11a1Sshidokht 			newlabeltype = cl->cl_def_labeltype;
12213ccda647Slclee 		} else {
12223ccda647Slclee 			/*
12233ccda647Slclee 			 * do nothing since the type for which we last created
12243ccda647Slclee 			 * nodes matches the default
12253ccda647Slclee 			 */
12263ccda647Slclee 			return (0);
12273ccda647Slclee 		}
12283ccda647Slclee 	} else {
1229*e8fb11a1Sshidokht 		if (cl->cl_cur_labeltype != cl->cl_last_labeltype) {
12303ccda647Slclee 			/* We are not closing, use current label type */
1231*e8fb11a1Sshidokht 			newlabeltype = cl->cl_cur_labeltype;
12323ccda647Slclee 		} else {
12333ccda647Slclee 			/*
12343ccda647Slclee 			 * do nothing since the type for which we last created
12353ccda647Slclee 			 * nodes matches the current label type
12363ccda647Slclee 			 */
12373ccda647Slclee 			return (0);
12383ccda647Slclee 		}
12393ccda647Slclee 	}
12403ccda647Slclee 
1241*e8fb11a1Sshidokht 	instance = ddi_get_instance(CMLB_DEVINFO(cl));
12423ccda647Slclee 
12433ccda647Slclee 	/*
12443ccda647Slclee 	 * Currently we only fix up the s7 node when we are switching
12453ccda647Slclee 	 * label types from or to EFI. This is consistent with
12463ccda647Slclee 	 * current behavior of sd.
12473ccda647Slclee 	 */
12483ccda647Slclee 	if (newlabeltype == CMLB_LABEL_EFI &&
1249*e8fb11a1Sshidokht 	    cl->cl_last_labeltype != CMLB_LABEL_EFI) {
12503ccda647Slclee 		/* from vtoc to EFI */
1251*e8fb11a1Sshidokht 		ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
1252*e8fb11a1Sshidokht 		ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
1253*e8fb11a1Sshidokht 		(void) ddi_create_minor_node(CMLB_DEVINFO(cl), "wd",
12543ccda647Slclee 		    S_IFBLK, (instance << CMLBUNIT_SHIFT) | WD_NODE,
1255*e8fb11a1Sshidokht 		    cl->cl_node_type, NULL);
1256*e8fb11a1Sshidokht 		(void) ddi_create_minor_node(CMLB_DEVINFO(cl), "wd,raw",
12573ccda647Slclee 		    S_IFCHR, (instance << CMLBUNIT_SHIFT) | WD_NODE,
1258*e8fb11a1Sshidokht 		    cl->cl_node_type, NULL);
12593ccda647Slclee 	} else {
12603ccda647Slclee 		/* from efi to vtoc */
1261*e8fb11a1Sshidokht 		ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
1262*e8fb11a1Sshidokht 		ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
1263*e8fb11a1Sshidokht 		(void) ddi_create_minor_node(CMLB_DEVINFO(cl), "h",
12643ccda647Slclee 		    S_IFBLK, (instance << CMLBUNIT_SHIFT) | WD_NODE,
1265*e8fb11a1Sshidokht 		    cl->cl_node_type, NULL);
1266*e8fb11a1Sshidokht 		(void) ddi_create_minor_node(CMLB_DEVINFO(cl), "h,raw",
12673ccda647Slclee 		    S_IFCHR, (instance << CMLBUNIT_SHIFT) | WD_NODE,
1268*e8fb11a1Sshidokht 		    cl->cl_node_type, NULL);
12693ccda647Slclee 	}
12703ccda647Slclee 
1271*e8fb11a1Sshidokht 	cl->cl_last_labeltype = newlabeltype;
12723ccda647Slclee 	return (0);
12733ccda647Slclee }
12743ccda647Slclee 
12753ccda647Slclee /*
12763ccda647Slclee  *    Function: cmlb_validate_geometry
12773ccda647Slclee  *
12783ccda647Slclee  * Description: Read the label from the disk (if present). Update the unit's
12793ccda647Slclee  *		geometry and vtoc information from the data in the label.
12803ccda647Slclee  *		Verify that the label is valid.
12813ccda647Slclee  *
1282*e8fb11a1Sshidokht  *   Arguments:
1283*e8fb11a1Sshidokht  *	cl		driver soft state (unit) structure
1284*e8fb11a1Sshidokht  *
1285*e8fb11a1Sshidokht  *	forcerevalid	force revalidation even if we are already valid.
1286*e8fb11a1Sshidokht  *	flags		operation flags from target driver. Used for verbosity
1287*e8fb11a1Sshidokht  *			control	at this time.
1288*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
1289*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
12903ccda647Slclee  *
12913ccda647Slclee  * Return Code: 0 - Successful completion
1292*e8fb11a1Sshidokht  *		EINVAL  - Invalid value in cl->cl_tgt_blocksize or
1293*e8fb11a1Sshidokht  *			  cl->cl_blockcount; or label on disk is corrupted
12943ccda647Slclee  *			  or unreadable.
12953ccda647Slclee  *		EACCES  - Reservation conflict at the device.
12963ccda647Slclee  *		ENOMEM  - Resource allocation error
12973ccda647Slclee  *		ENOTSUP - geometry not applicable
12983ccda647Slclee  *
12993ccda647Slclee  *     Context: Kernel thread only (can sleep).
13003ccda647Slclee  */
13013ccda647Slclee static int
1302*e8fb11a1Sshidokht cmlb_validate_geometry(struct cmlb_lun *cl, int forcerevalid, int flags,
1303*e8fb11a1Sshidokht     void *tg_cookie)
13043ccda647Slclee {
13053ccda647Slclee 	int		label_error = 0;
13063ccda647Slclee 	diskaddr_t	capacity;
13073ccda647Slclee 	int		count;
1308*e8fb11a1Sshidokht #if defined(__i386) || defined(__amd64)
1309*e8fb11a1Sshidokht 	int forced_under_1t = 0;
1310*e8fb11a1Sshidokht #endif
13113ccda647Slclee 
1312*e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
13133ccda647Slclee 
1314*e8fb11a1Sshidokht 	if ((cl->cl_f_geometry_is_valid == TRUE) && (forcerevalid == 0)) {
1315*e8fb11a1Sshidokht 		if (cl->cl_cur_labeltype == CMLB_LABEL_EFI)
13163ccda647Slclee 			return (ENOTSUP);
13173ccda647Slclee 		return (0);
13183ccda647Slclee 	}
13193ccda647Slclee 
1320*e8fb11a1Sshidokht 	if (cmlb_check_update_blockcount(cl, tg_cookie) != 0)
13213ccda647Slclee 		return (EIO);
13223ccda647Slclee 
1323*e8fb11a1Sshidokht 	capacity = cl->cl_blockcount;
13243ccda647Slclee 
13253ccda647Slclee #if defined(_SUNOS_VTOC_16)
13263ccda647Slclee 	/*
13273ccda647Slclee 	 * Set up the "whole disk" fdisk partition; this should always
13283ccda647Slclee 	 * exist, regardless of whether the disk contains an fdisk table
13293ccda647Slclee 	 * or vtoc.
13303ccda647Slclee 	 */
1331*e8fb11a1Sshidokht 	cl->cl_map[P0_RAW_DISK].dkl_cylno = 0;
13323ccda647Slclee 	/*
13333ccda647Slclee 	 * note if capacity > uint32_max we should be using efi,
13343ccda647Slclee 	 * and not use p0, so the truncation does not matter.
13353ccda647Slclee 	 */
1336*e8fb11a1Sshidokht 	cl->cl_map[P0_RAW_DISK].dkl_nblk  = capacity;
13373ccda647Slclee #endif
13383ccda647Slclee 	/*
13393ccda647Slclee 	 * Refresh the logical and physical geometry caches.
13403ccda647Slclee 	 * (data from MODE SENSE format/rigid disk geometry pages,
13413ccda647Slclee 	 * and scsi_ifgetcap("geometry").
13423ccda647Slclee 	 */
1343*e8fb11a1Sshidokht 	cmlb_resync_geom_caches(cl, capacity, tg_cookie);
13443ccda647Slclee 
1345*e8fb11a1Sshidokht 	label_error = cmlb_use_efi(cl, capacity, flags, tg_cookie);
13463ccda647Slclee 	if (label_error == 0) {
13473ccda647Slclee 
13483ccda647Slclee 		/* found a valid EFI label */
1349*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl,
13503ccda647Slclee 		    "cmlb_validate_geometry: found EFI label\n");
13513ccda647Slclee 		/*
13523ccda647Slclee 		 * solaris_size and geometry_is_valid are set in
13533ccda647Slclee 		 * cmlb_use_efi
13543ccda647Slclee 		 */
13553ccda647Slclee 		return (ENOTSUP);
13563ccda647Slclee 	}
13573ccda647Slclee 
13583ccda647Slclee 	/* NO EFI label found */
13593ccda647Slclee 
13603ccda647Slclee 	if (capacity > DK_MAX_BLOCKS) {
13613ccda647Slclee 		if (label_error == ESRCH) {
13623ccda647Slclee 			/*
13633ccda647Slclee 			 * they've configured a LUN over 1TB, but used
13643ccda647Slclee 			 * format.dat to restrict format's view of the
13653ccda647Slclee 			 * capacity to be under 1TB
13663ccda647Slclee 			 */
13673ccda647Slclee 			/* i.e > 1Tb with a VTOC < 1TB */
1368*e8fb11a1Sshidokht 			if (!(flags & CMLB_SILENT)) {
1369*e8fb11a1Sshidokht 				cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
1370*e8fb11a1Sshidokht 				    CE_WARN, "is >1TB and has a VTOC label: "
1371*e8fb11a1Sshidokht 				    "use format(1M) to either decrease the");
1372*e8fb11a1Sshidokht 
1373*e8fb11a1Sshidokht 				cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
1374*e8fb11a1Sshidokht 				    CE_NOTE, "size to be < 1TB or relabel the "
1375*e8fb11a1Sshidokht 				    "disk with an EFI label");
1376*e8fb11a1Sshidokht #if defined(__i386) || defined(__amd64)
1377*e8fb11a1Sshidokht 				forced_under_1t = 1;
1378*e8fb11a1Sshidokht #endif
1379*e8fb11a1Sshidokht 			}
13803ccda647Slclee 		} else {
13813ccda647Slclee 			/* unlabeled disk over 1TB */
1382*e8fb11a1Sshidokht #if defined(__i386) || defined(__amd64)
1383*e8fb11a1Sshidokht 
1384*e8fb11a1Sshidokht 			/*
1385*e8fb11a1Sshidokht 			 * Refer to comments on off-by-1 at the head of the file
1386*e8fb11a1Sshidokht 			 * A 1TB disk was treated as (1T - 512)B in the past,
1387*e8fb11a1Sshidokht 			 * thus, it might have valid solaris partition. We
1388*e8fb11a1Sshidokht 			 * will return ENOTSUP later only if this disk has no
1389*e8fb11a1Sshidokht 			 * valid solaris partition.
1390*e8fb11a1Sshidokht 			 */
1391*e8fb11a1Sshidokht 			if (!(cl->cl_alter_behavior & CMLB_OFF_BY_ONE) ||
1392*e8fb11a1Sshidokht 			    (cl->cl_sys_blocksize != cl->cl_tgt_blocksize) ||
1393*e8fb11a1Sshidokht 			    (capacity - 1 > DK_MAX_BLOCKS))
1394*e8fb11a1Sshidokht #endif
1395*e8fb11a1Sshidokht 				return (ENOTSUP);
13963ccda647Slclee 		}
13973ccda647Slclee 	}
13983ccda647Slclee 
13993ccda647Slclee 	label_error = 0;
14003ccda647Slclee 
14013ccda647Slclee 	/*
14023ccda647Slclee 	 * at this point it is either labeled with a VTOC or it is
1403*e8fb11a1Sshidokht 	 * under 1TB (<= 1TB actually for off-by-1)
14043ccda647Slclee 	 */
14053ccda647Slclee 
14063ccda647Slclee 	/*
1407*e8fb11a1Sshidokht 	 * Only DIRECT ACCESS devices will have Scl labels.
1408*e8fb11a1Sshidokht 	 * CD's supposedly have a Scl label, too
14093ccda647Slclee 	 */
1410*e8fb11a1Sshidokht 	if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) {
14113ccda647Slclee 		struct	dk_label *dkl;
14123ccda647Slclee 		offset_t label_addr;
14133ccda647Slclee 		int	rval;
14143ccda647Slclee 		size_t	buffer_size;
14153ccda647Slclee 
14163ccda647Slclee 		/*
1417*e8fb11a1Sshidokht 		 * Note: This will set up cl->cl_solaris_size and
1418*e8fb11a1Sshidokht 		 * cl->cl_solaris_offset.
14193ccda647Slclee 		 */
1420*e8fb11a1Sshidokht 		rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
1421*e8fb11a1Sshidokht 		if ((rval != 0) && !ISCD(cl)) {
1422*e8fb11a1Sshidokht 			ASSERT(mutex_owned(CMLB_MUTEX(cl)));
14233ccda647Slclee 			return (rval);
14243ccda647Slclee 		}
14253ccda647Slclee 
1426*e8fb11a1Sshidokht 		if (cl->cl_solaris_size <= DK_LABEL_LOC) {
1427*e8fb11a1Sshidokht 
1428*e8fb11a1Sshidokht #if defined(__i386) || defined(__amd64)
1429*e8fb11a1Sshidokht 			/*
1430*e8fb11a1Sshidokht 			 * Refer to comments on off-by-1 at the head of the file
1431*e8fb11a1Sshidokht 			 * This is for 1TB disk only. Since that there is no
1432*e8fb11a1Sshidokht 			 * solaris partitions, return ENOTSUP as we do for
1433*e8fb11a1Sshidokht 			 * >1TB disk.
1434*e8fb11a1Sshidokht 			 */
1435*e8fb11a1Sshidokht 			if (cl->cl_blockcount > DK_MAX_BLOCKS)
1436*e8fb11a1Sshidokht 				return (ENOTSUP);
1437*e8fb11a1Sshidokht #endif
14383ccda647Slclee 			/*
14393ccda647Slclee 			 * Found fdisk table but no Solaris partition entry,
14403ccda647Slclee 			 * so don't call cmlb_uselabel() and don't create
14413ccda647Slclee 			 * a default label.
14423ccda647Slclee 			 */
14433ccda647Slclee 			label_error = 0;
1444*e8fb11a1Sshidokht 			cl->cl_f_geometry_is_valid = TRUE;
14453ccda647Slclee 			goto no_solaris_partition;
14463ccda647Slclee 		}
14473ccda647Slclee 
1448*e8fb11a1Sshidokht 		label_addr = (daddr_t)(cl->cl_solaris_offset + DK_LABEL_LOC);
1449*e8fb11a1Sshidokht 
1450*e8fb11a1Sshidokht #if defined(__i386) || defined(__amd64)
1451*e8fb11a1Sshidokht 		/*
1452*e8fb11a1Sshidokht 		 * Refer to comments on off-by-1 at the head of the file
1453*e8fb11a1Sshidokht 		 * Now, this 1TB disk has valid solaris partition. It
1454*e8fb11a1Sshidokht 		 * must be created by previous sd driver, we have to
1455*e8fb11a1Sshidokht 		 * treat it as (1T-512)B.
1456*e8fb11a1Sshidokht 		 */
1457*e8fb11a1Sshidokht 		if ((cl->cl_blockcount > DK_MAX_BLOCKS) &&
1458*e8fb11a1Sshidokht 		    (forced_under_1t != 1)) {
1459*e8fb11a1Sshidokht 			/*
1460*e8fb11a1Sshidokht 			 * Refer to cmlb_read_fdisk, when there is no
1461*e8fb11a1Sshidokht 			 * fdisk partition table, cl_solaris_size is
1462*e8fb11a1Sshidokht 			 * set to disk's capacity. In this case, we
1463*e8fb11a1Sshidokht 			 * need to adjust it
1464*e8fb11a1Sshidokht 			 */
1465*e8fb11a1Sshidokht 			if (cl->cl_solaris_size > DK_MAX_BLOCKS)
1466*e8fb11a1Sshidokht 				cl->cl_solaris_size = DK_MAX_BLOCKS;
1467*e8fb11a1Sshidokht 			cmlb_resync_geom_caches(cl, DK_MAX_BLOCKS, tg_cookie);
1468*e8fb11a1Sshidokht 		}
1469*e8fb11a1Sshidokht #endif
14703ccda647Slclee 
14713ccda647Slclee 		buffer_size = sizeof (struct dk_label);
14723ccda647Slclee 
1473*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "cmlb_validate_geometry: "
14743ccda647Slclee 		    "label_addr: 0x%x allocation size: 0x%x\n",
14753ccda647Slclee 		    label_addr, buffer_size);
14763ccda647Slclee 
14773ccda647Slclee 		if ((dkl = kmem_zalloc(buffer_size, KM_NOSLEEP)) == NULL)
14783ccda647Slclee 			return (ENOMEM);
14793ccda647Slclee 
1480*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
1481*e8fb11a1Sshidokht 		rval = DK_TG_READ(cl, dkl, label_addr, buffer_size, tg_cookie);
1482*e8fb11a1Sshidokht 		mutex_enter(CMLB_MUTEX(cl));
14833ccda647Slclee 
14843ccda647Slclee 		switch (rval) {
14853ccda647Slclee 		case 0:
14863ccda647Slclee 			/*
14873ccda647Slclee 			 * cmlb_uselabel will establish that the geometry
14883ccda647Slclee 			 * is valid.
14893ccda647Slclee 			 */
1490*e8fb11a1Sshidokht 			if (cmlb_uselabel(cl,
1491*e8fb11a1Sshidokht 			    (struct dk_label *)(uintptr_t)dkl, flags) !=
14923ccda647Slclee 			    CMLB_LABEL_IS_VALID) {
14933ccda647Slclee 				label_error = EINVAL;
14943ccda647Slclee 			} else
1495*e8fb11a1Sshidokht 				cl->cl_vtoc_label_is_from_media = 1;
14963ccda647Slclee 			break;
14973ccda647Slclee 		case EACCES:
14983ccda647Slclee 			label_error = EACCES;
14993ccda647Slclee 			break;
15003ccda647Slclee 		default:
15013ccda647Slclee 			label_error = EINVAL;
15023ccda647Slclee 			break;
15033ccda647Slclee 		}
15043ccda647Slclee 
15053ccda647Slclee 		kmem_free(dkl, buffer_size);
15063ccda647Slclee 	}
15073ccda647Slclee 
15083ccda647Slclee 	/*
15093ccda647Slclee 	 * If a valid label was not found, AND if no reservation conflict
15103ccda647Slclee 	 * was detected, then go ahead and create a default label (4069506).
15113ccda647Slclee 	 *
15123ccda647Slclee 	 * Note: currently, for VTOC_8 devices, the default label is created
1513*e8fb11a1Sshidokht 	 * for removables and hotpluggables only.  For VTOC_16 devices, the
1514*e8fb11a1Sshidokht 	 * default label will be created for all devices.
15153ccda647Slclee 	 * (see cmlb_build_default_label)
15163ccda647Slclee 	 */
15173ccda647Slclee #if defined(_SUNOS_VTOC_8)
1518*e8fb11a1Sshidokht 	if ((ISREMOVABLE(cl) || ISHOTPLUGGABLE(cl)) &&
1519*e8fb11a1Sshidokht 	    (label_error != EACCES)) {
15203ccda647Slclee #elif defined(_SUNOS_VTOC_16)
15213ccda647Slclee 	if (label_error != EACCES) {
15223ccda647Slclee #endif
1523*e8fb11a1Sshidokht 		if (cl->cl_f_geometry_is_valid == FALSE) {
1524*e8fb11a1Sshidokht 			cmlb_build_default_label(cl, tg_cookie);
15253ccda647Slclee 		}
15263ccda647Slclee 		label_error = 0;
15273ccda647Slclee 	}
15283ccda647Slclee 
15293ccda647Slclee no_solaris_partition:
15303ccda647Slclee 
15313ccda647Slclee #if defined(_SUNOS_VTOC_16)
15323ccda647Slclee 	/*
15333ccda647Slclee 	 * If we have valid geometry, set up the remaining fdisk partitions.
15343ccda647Slclee 	 * Note that dkl_cylno is not used for the fdisk map entries, so
15353ccda647Slclee 	 * we set it to an entirely bogus value.
15363ccda647Slclee 	 */
15373ccda647Slclee 	for (count = 0; count < FD_NUMPART; count++) {
1538*e8fb11a1Sshidokht 		cl->cl_map[FDISK_P1 + count].dkl_cylno = -1;
1539*e8fb11a1Sshidokht 		cl->cl_map[FDISK_P1 + count].dkl_nblk =
1540*e8fb11a1Sshidokht 		    cl->cl_fmap[count].fmap_nblk;
15413ccda647Slclee 
1542*e8fb11a1Sshidokht 		cl->cl_offset[FDISK_P1 + count] =
1543*e8fb11a1Sshidokht 		    cl->cl_fmap[count].fmap_start;
15443ccda647Slclee 	}
15453ccda647Slclee #endif
15463ccda647Slclee 
15473ccda647Slclee 	for (count = 0; count < NDKMAP; count++) {
15483ccda647Slclee #if defined(_SUNOS_VTOC_8)
1549*e8fb11a1Sshidokht 		struct dk_map *lp  = &cl->cl_map[count];
1550*e8fb11a1Sshidokht 		cl->cl_offset[count] =
1551*e8fb11a1Sshidokht 		    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
15523ccda647Slclee #elif defined(_SUNOS_VTOC_16)
1553*e8fb11a1Sshidokht 		struct dkl_partition *vp = &cl->cl_vtoc.v_part[count];
15543ccda647Slclee 
1555*e8fb11a1Sshidokht 		cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset;
15563ccda647Slclee #else
15573ccda647Slclee #error "No VTOC format defined."
15583ccda647Slclee #endif
15593ccda647Slclee 	}
15603ccda647Slclee 
15613ccda647Slclee 	return (label_error);
15623ccda647Slclee }
15633ccda647Slclee 
15643ccda647Slclee #if defined(_SUNOS_VTOC_16)
15653ccda647Slclee /*
15663ccda647Slclee  * Macro: MAX_BLKS
15673ccda647Slclee  *
15683ccda647Slclee  *	This macro is used for table entries where we need to have the largest
15693ccda647Slclee  *	possible sector value for that head & SPT (sectors per track)
15703ccda647Slclee  *	combination.  Other entries for some smaller disk sizes are set by
15713ccda647Slclee  *	convention to match those used by X86 BIOS usage.
15723ccda647Slclee  */
15733ccda647Slclee #define	MAX_BLKS(heads, spt)	UINT16_MAX * heads * spt, heads, spt
15743ccda647Slclee 
15753ccda647Slclee /*
15763ccda647Slclee  *    Function: cmlb_convert_geometry
15773ccda647Slclee  *
15783ccda647Slclee  * Description: Convert physical geometry into a dk_geom structure. In
15793ccda647Slclee  *		other words, make sure we don't wrap 16-bit values.
15803ccda647Slclee  *		e.g. converting from geom_cache to dk_geom
15813ccda647Slclee  *
15823ccda647Slclee  *     Context: Kernel thread only
15833ccda647Slclee  */
15843ccda647Slclee static void
1585*e8fb11a1Sshidokht cmlb_convert_geometry(diskaddr_t capacity, struct dk_geom *cl_g)
15863ccda647Slclee {
15873ccda647Slclee 	int i;
15883ccda647Slclee 	static const struct chs_values {
15893ccda647Slclee 		uint_t max_cap;		/* Max Capacity for this HS. */
15903ccda647Slclee 		uint_t nhead;		/* Heads to use. */
15913ccda647Slclee 		uint_t nsect;		/* SPT to use. */
15923ccda647Slclee 	} CHS_values[] = {
15933ccda647Slclee 		{0x00200000,  64, 32},		/* 1GB or smaller disk. */
15943ccda647Slclee 		{0x01000000, 128, 32},		/* 8GB or smaller disk. */
15953ccda647Slclee 		{MAX_BLKS(255,  63)},		/* 502.02GB or smaller disk. */
15963ccda647Slclee 		{MAX_BLKS(255, 126)},		/* .98TB or smaller disk. */
15973ccda647Slclee 		{DK_MAX_BLOCKS, 255, 189}	/* Max size is just under 1TB */
15983ccda647Slclee 	};
15993ccda647Slclee 
16003ccda647Slclee 	/* Unlabeled SCSI floppy device */
16013ccda647Slclee 	if (capacity <= 0x1000) {
1602*e8fb11a1Sshidokht 		cl_g->dkg_nhead = 2;
1603*e8fb11a1Sshidokht 		cl_g->dkg_ncyl = 80;
1604*e8fb11a1Sshidokht 		cl_g->dkg_nsect = capacity / (cl_g->dkg_nhead * cl_g->dkg_ncyl);
16053ccda647Slclee 		return;
16063ccda647Slclee 	}
16073ccda647Slclee 
16083ccda647Slclee 	/*
16093ccda647Slclee 	 * For all devices we calculate cylinders using the
16103ccda647Slclee 	 * heads and sectors we assign based on capacity of the
16113ccda647Slclee 	 * device.  The table is designed to be compatible with the
16123ccda647Slclee 	 * way other operating systems lay out fdisk tables for X86
16133ccda647Slclee 	 * and to insure that the cylinders never exceed 65535 to
16143ccda647Slclee 	 * prevent problems with X86 ioctls that report geometry.
16153ccda647Slclee 	 * We use SPT that are multiples of 63, since other OSes that
16163ccda647Slclee 	 * are not limited to 16-bits for cylinders stop at 63 SPT
16173ccda647Slclee 	 * we make do by using multiples of 63 SPT.
16183ccda647Slclee 	 *
16193ccda647Slclee 	 * Note than capacities greater than or equal to 1TB will simply
16203ccda647Slclee 	 * get the largest geometry from the table. This should be okay
16213ccda647Slclee 	 * since disks this large shouldn't be using CHS values anyway.
16223ccda647Slclee 	 */
16233ccda647Slclee 	for (i = 0; CHS_values[i].max_cap < capacity &&
16243ccda647Slclee 	    CHS_values[i].max_cap != DK_MAX_BLOCKS; i++)
16253ccda647Slclee 		;
16263ccda647Slclee 
1627*e8fb11a1Sshidokht 	cl_g->dkg_nhead = CHS_values[i].nhead;
1628*e8fb11a1Sshidokht 	cl_g->dkg_nsect = CHS_values[i].nsect;
16293ccda647Slclee }
16303ccda647Slclee #endif
16313ccda647Slclee 
16323ccda647Slclee /*
16333ccda647Slclee  *    Function: cmlb_resync_geom_caches
16343ccda647Slclee  *
16353ccda647Slclee  * Description: (Re)initialize both geometry caches: the virtual geometry
16363ccda647Slclee  *            information is extracted from the HBA (the "geometry"
16373ccda647Slclee  *            capability), and the physical geometry cache data is
16383ccda647Slclee  *            generated by issuing MODE SENSE commands.
16393ccda647Slclee  *
1640*e8fb11a1Sshidokht  *   Arguments:
1641*e8fb11a1Sshidokht  *	cl 		driver soft state (unit) structure
1642*e8fb11a1Sshidokht  *	capacity	disk capacity in #blocks
1643*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
1644*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
16453ccda647Slclee  *
16463ccda647Slclee  *     Context: Kernel thread only (can sleep).
16473ccda647Slclee  */
16483ccda647Slclee static void
1649*e8fb11a1Sshidokht cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity,
1650*e8fb11a1Sshidokht     void *tg_cookie)
16513ccda647Slclee {
16523ccda647Slclee 	struct	cmlb_geom 	pgeom;
16533ccda647Slclee 	struct	cmlb_geom	lgeom;
16543ccda647Slclee 	struct 	cmlb_geom	*pgeomp = &pgeom;
16553ccda647Slclee 	unsigned short 		nhead;
16563ccda647Slclee 	unsigned short 		nsect;
16573ccda647Slclee 	int 			spc;
16583ccda647Slclee 	int			ret;
16593ccda647Slclee 
1660*e8fb11a1Sshidokht 	ASSERT(cl != NULL);
1661*e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
16623ccda647Slclee 
16633ccda647Slclee 	/*
16643ccda647Slclee 	 * Ask the controller for its logical geometry.
16653ccda647Slclee 	 * Note: if the HBA does not support scsi_ifgetcap("geometry"),
16663ccda647Slclee 	 * then the lgeom cache will be invalid.
16673ccda647Slclee 	 */
1668*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
16693ccda647Slclee 	bzero(&lgeom, sizeof (struct cmlb_geom));
1670*e8fb11a1Sshidokht 	ret = DK_TG_GETVIRTGEOM(cl, &lgeom, tg_cookie);
1671*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
16723ccda647Slclee 
1673*e8fb11a1Sshidokht 	bcopy(&lgeom, &cl->cl_lgeom, sizeof (cl->cl_lgeom));
16743ccda647Slclee 
16753ccda647Slclee 	/*
16763ccda647Slclee 	 * Initialize the pgeom cache from lgeom, so that if MODE SENSE
16773ccda647Slclee 	 * doesn't work, DKIOCG_PHYSGEOM can return reasonable values.
16783ccda647Slclee 	 */
1679*e8fb11a1Sshidokht 	if (ret != 0 || cl->cl_lgeom.g_nsect == 0 ||
1680*e8fb11a1Sshidokht 	    cl->cl_lgeom.g_nhead == 0) {
16813ccda647Slclee 		/*
16823ccda647Slclee 		 * Note: Perhaps this needs to be more adaptive? The rationale
16833ccda647Slclee 		 * is that, if there's no HBA geometry from the HBA driver, any
16843ccda647Slclee 		 * guess is good, since this is the physical geometry. If MODE
16853ccda647Slclee 		 * SENSE fails this gives a max cylinder size for non-LBA access
16863ccda647Slclee 		 */
16873ccda647Slclee 		nhead = 255;
16883ccda647Slclee 		nsect = 63;
16893ccda647Slclee 	} else {
1690*e8fb11a1Sshidokht 		nhead = cl->cl_lgeom.g_nhead;
1691*e8fb11a1Sshidokht 		nsect = cl->cl_lgeom.g_nsect;
16923ccda647Slclee 	}
16933ccda647Slclee 
1694*e8fb11a1Sshidokht 	if (ISCD(cl)) {
16953ccda647Slclee 		pgeomp->g_nhead = 1;
16963ccda647Slclee 		pgeomp->g_nsect = nsect * nhead;
16973ccda647Slclee 	} else {
16983ccda647Slclee 		pgeomp->g_nhead = nhead;
16993ccda647Slclee 		pgeomp->g_nsect = nsect;
17003ccda647Slclee 	}
17013ccda647Slclee 
17023ccda647Slclee 	spc = pgeomp->g_nhead * pgeomp->g_nsect;
17033ccda647Slclee 	pgeomp->g_capacity = capacity;
17043ccda647Slclee 	pgeomp->g_ncyl = pgeomp->g_capacity / spc;
17053ccda647Slclee 	pgeomp->g_acyl = 0;
17063ccda647Slclee 
17073ccda647Slclee 	/*
17083ccda647Slclee 	 * Retrieve fresh geometry data from the hardware, stash it
17093ccda647Slclee 	 * here temporarily before we rebuild the incore label.
17103ccda647Slclee 	 *
17113ccda647Slclee 	 * We want to use the MODE SENSE commands to derive the
17123ccda647Slclee 	 * physical geometry of the device, but if either command
17133ccda647Slclee 	 * fails, the logical geometry is used as the fallback for
17143ccda647Slclee 	 * disk label geometry.
17153ccda647Slclee 	 */
17163ccda647Slclee 
1717*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
1718*e8fb11a1Sshidokht 	(void) DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie);
1719*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
17203ccda647Slclee 
17213ccda647Slclee 	/*
17223ccda647Slclee 	 * Now update the real copy while holding the mutex. This
17233ccda647Slclee 	 * way the global copy is never in an inconsistent state.
17243ccda647Slclee 	 */
1725*e8fb11a1Sshidokht 	bcopy(pgeomp, &cl->cl_pgeom,  sizeof (cl->cl_pgeom));
17263ccda647Slclee 
1727*e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO, cl, "cmlb_resync_geom_caches: "
17283ccda647Slclee 	    "(cached from lgeom)\n");
1729*e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl,
17303ccda647Slclee 	    "   ncyl: %ld; acyl: %d; nhead: %d; nsect: %d\n",
1731*e8fb11a1Sshidokht 	    cl->cl_pgeom.g_ncyl, cl->cl_pgeom.g_acyl,
1732*e8fb11a1Sshidokht 	    cl->cl_pgeom.g_nhead, cl->cl_pgeom.g_nsect);
1733*e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl, "   lbasize: %d; capacity: %ld; "
1734*e8fb11a1Sshidokht 	    "intrlv: %d; rpm: %d\n", cl->cl_pgeom.g_secsize,
1735*e8fb11a1Sshidokht 	    cl->cl_pgeom.g_capacity, cl->cl_pgeom.g_intrlv,
1736*e8fb11a1Sshidokht 	    cl->cl_pgeom.g_rpm);
17373ccda647Slclee }
17383ccda647Slclee 
17393ccda647Slclee 
17403ccda647Slclee /*
17413ccda647Slclee  *    Function: cmlb_read_fdisk
17423ccda647Slclee  *
17433ccda647Slclee  * Description: utility routine to read the fdisk table.
17443ccda647Slclee  *
1745*e8fb11a1Sshidokht  *   Arguments:
1746*e8fb11a1Sshidokht  *	cl		driver soft state (unit) structure
1747*e8fb11a1Sshidokht  *	capacity	disk capacity in #blocks
1748*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
1749*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
17503ccda647Slclee  *
17513ccda647Slclee  * Return Code: 0 for success (includes not reading for no_fdisk_present case
17523ccda647Slclee  *		errnos from tg_rw if failed to read the first block.
17533ccda647Slclee  *
17543ccda647Slclee  *     Context: Kernel thread only (can sleep).
17553ccda647Slclee  */
1756*e8fb11a1Sshidokht /*ARGSUSED*/
17573ccda647Slclee static int
1758*e8fb11a1Sshidokht cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity, void *tg_cookie)
17593ccda647Slclee {
17603ccda647Slclee #if defined(_NO_FDISK_PRESENT)
17613ccda647Slclee 
1762*e8fb11a1Sshidokht 	cl->cl_solaris_offset = 0;
1763*e8fb11a1Sshidokht 	cl->cl_solaris_size = capacity;
1764*e8fb11a1Sshidokht 	bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
17653ccda647Slclee 	return (0);
17663ccda647Slclee 
17673ccda647Slclee #elif defined(_FIRMWARE_NEEDS_FDISK)
17683ccda647Slclee 
17693ccda647Slclee 	struct ipart	*fdp;
17703ccda647Slclee 	struct mboot	*mbp;
17713ccda647Slclee 	struct ipart	fdisk[FD_NUMPART];
17723ccda647Slclee 	int		i;
17733ccda647Slclee 	char		sigbuf[2];
17743ccda647Slclee 	caddr_t		bufp;
17753ccda647Slclee 	int		uidx;
17763ccda647Slclee 	int 		rval;
17773ccda647Slclee 	int		lba = 0;
17783ccda647Slclee 	uint_t		solaris_offset;	/* offset to solaris part. */
17793ccda647Slclee 	daddr_t		solaris_size;	/* size of solaris partition */
17803ccda647Slclee 	uint32_t	blocksize;
17813ccda647Slclee 
1782*e8fb11a1Sshidokht 	ASSERT(cl != NULL);
1783*e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
17843ccda647Slclee 
17853ccda647Slclee 	/*
17863ccda647Slclee 	 * Start off assuming no fdisk table
17873ccda647Slclee 	 */
17883ccda647Slclee 	solaris_offset = 0;
17893ccda647Slclee 	solaris_size   = capacity;
17903ccda647Slclee 
1791*e8fb11a1Sshidokht 	blocksize = cl->cl_tgt_blocksize;
17923ccda647Slclee 
17933ccda647Slclee 	bufp = kmem_zalloc(blocksize, KM_SLEEP);
17943ccda647Slclee 
1795*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
1796*e8fb11a1Sshidokht 	rval = DK_TG_READ(cl, bufp, 0, blocksize, tg_cookie);
1797*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
17983ccda647Slclee 
17993ccda647Slclee 	if (rval != 0) {
1800*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_ERROR,  cl,
18013ccda647Slclee 		    "cmlb_read_fdisk: fdisk read err\n");
1802*e8fb11a1Sshidokht 		bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
1803*e8fb11a1Sshidokht 		goto done;
18043ccda647Slclee 	}
18053ccda647Slclee 
18063ccda647Slclee 	mbp = (struct mboot *)bufp;
18073ccda647Slclee 
18083ccda647Slclee 	/*
18093ccda647Slclee 	 * The fdisk table does not begin on a 4-byte boundary within the
18103ccda647Slclee 	 * master boot record, so we copy it to an aligned structure to avoid
18113ccda647Slclee 	 * alignment exceptions on some processors.
18123ccda647Slclee 	 */
18133ccda647Slclee 	bcopy(&mbp->parts[0], fdisk, sizeof (fdisk));
18143ccda647Slclee 
18153ccda647Slclee 	/*
18163ccda647Slclee 	 * Check for lba support before verifying sig; sig might not be
18173ccda647Slclee 	 * there, say on a blank disk, but the max_chs mark may still
18183ccda647Slclee 	 * be present.
18193ccda647Slclee 	 *
18203ccda647Slclee 	 * Note: LBA support and BEFs are an x86-only concept but this
18213ccda647Slclee 	 * code should work OK on SPARC as well.
18223ccda647Slclee 	 */
18233ccda647Slclee 
18243ccda647Slclee 	/*
18253ccda647Slclee 	 * First, check for lba-access-ok on root node (or prom root node)
18263ccda647Slclee 	 * if present there, don't need to search fdisk table.
18273ccda647Slclee 	 */
18283ccda647Slclee 	if (ddi_getprop(DDI_DEV_T_ANY, ddi_root_node(), 0,
18293ccda647Slclee 	    "lba-access-ok", 0) != 0) {
18303ccda647Slclee 		/* All drives do LBA; don't search fdisk table */
18313ccda647Slclee 		lba = 1;
18323ccda647Slclee 	} else {
18333ccda647Slclee 		/* Okay, look for mark in fdisk table */
18343ccda647Slclee 		for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) {
18353ccda647Slclee 			/* accumulate "lba" value from all partitions */
18363ccda647Slclee 			lba = (lba || cmlb_has_max_chs_vals(fdp));
18373ccda647Slclee 		}
18383ccda647Slclee 	}
18393ccda647Slclee 
18403ccda647Slclee 	if (lba != 0) {
1841*e8fb11a1Sshidokht 		dev_t dev = cmlb_make_device(cl);
18423ccda647Slclee 
1843*e8fb11a1Sshidokht 		if (ddi_getprop(dev, CMLB_DEVINFO(cl), DDI_PROP_DONTPASS,
18443ccda647Slclee 		    "lba-access-ok", 0) == 0) {
18453ccda647Slclee 			/* not found; create it */
1846*e8fb11a1Sshidokht 			if (ddi_prop_create(dev, CMLB_DEVINFO(cl), 0,
18473ccda647Slclee 			    "lba-access-ok", (caddr_t)NULL, 0) !=
18483ccda647Slclee 			    DDI_PROP_SUCCESS) {
1849*e8fb11a1Sshidokht 				cmlb_dbg(CMLB_ERROR,  cl,
18503ccda647Slclee 				    "cmlb_read_fdisk: Can't create lba "
18513ccda647Slclee 				    "property for instance %d\n",
1852*e8fb11a1Sshidokht 				    ddi_get_instance(CMLB_DEVINFO(cl)));
18533ccda647Slclee 			}
18543ccda647Slclee 		}
18553ccda647Slclee 	}
18563ccda647Slclee 
18573ccda647Slclee 	bcopy(&mbp->signature, sigbuf, sizeof (sigbuf));
18583ccda647Slclee 
18593ccda647Slclee 	/*
18603ccda647Slclee 	 * Endian-independent signature check
18613ccda647Slclee 	 */
18623ccda647Slclee 	if (((sigbuf[1] & 0xFF) != ((MBB_MAGIC >> 8) & 0xFF)) ||
18633ccda647Slclee 	    (sigbuf[0] != (MBB_MAGIC & 0xFF))) {
1864*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_ERROR,  cl,
18653ccda647Slclee 		    "cmlb_read_fdisk: no fdisk\n");
1866*e8fb11a1Sshidokht 		bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
18673ccda647Slclee 		goto done;
18683ccda647Slclee 	}
18693ccda647Slclee 
18703ccda647Slclee #ifdef CMLBDEBUG
1871*e8fb11a1Sshidokht 	if (cmlb_level_mask & CMLB_LOGMASK_INFO) {
18723ccda647Slclee 		fdp = fdisk;
1873*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_INFO,  cl, "cmlb_read_fdisk:\n");
1874*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_INFO,  cl, "         relsect    "
18753ccda647Slclee 		    "numsect         sysid       bootid\n");
18763ccda647Slclee 		for (i = 0; i < FD_NUMPART; i++, fdp++) {
1877*e8fb11a1Sshidokht 			cmlb_dbg(CMLB_INFO,  cl,
18783ccda647Slclee 			    "    %d:  %8d   %8d     0x%08x     0x%08x\n",
18793ccda647Slclee 			    i, fdp->relsect, fdp->numsect,
18803ccda647Slclee 			    fdp->systid, fdp->bootid);
18813ccda647Slclee 		}
18823ccda647Slclee 	}
18833ccda647Slclee #endif
18843ccda647Slclee 
18853ccda647Slclee 	/*
18863ccda647Slclee 	 * Try to find the unix partition
18873ccda647Slclee 	 */
18883ccda647Slclee 	uidx = -1;
18893ccda647Slclee 	solaris_offset = 0;
18903ccda647Slclee 	solaris_size   = 0;
18913ccda647Slclee 
18923ccda647Slclee 	for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) {
18933ccda647Slclee 		int	relsect;
18943ccda647Slclee 		int	numsect;
18953ccda647Slclee 
18963ccda647Slclee 		if (fdp->numsect == 0) {
1897*e8fb11a1Sshidokht 			cl->cl_fmap[i].fmap_start = 0;
1898*e8fb11a1Sshidokht 			cl->cl_fmap[i].fmap_nblk  = 0;
18993ccda647Slclee 			continue;
19003ccda647Slclee 		}
19013ccda647Slclee 
19023ccda647Slclee 		/*
19033ccda647Slclee 		 * Data in the fdisk table is little-endian.
19043ccda647Slclee 		 */
19053ccda647Slclee 		relsect = LE_32(fdp->relsect);
19063ccda647Slclee 		numsect = LE_32(fdp->numsect);
19073ccda647Slclee 
1908*e8fb11a1Sshidokht 		cl->cl_fmap[i].fmap_start = relsect;
1909*e8fb11a1Sshidokht 		cl->cl_fmap[i].fmap_nblk  = numsect;
19103ccda647Slclee 
19113ccda647Slclee 		if (fdp->systid != SUNIXOS &&
19123ccda647Slclee 		    fdp->systid != SUNIXOS2 &&
19133ccda647Slclee 		    fdp->systid != EFI_PMBR) {
19143ccda647Slclee 			continue;
19153ccda647Slclee 		}
19163ccda647Slclee 
19173ccda647Slclee 		/*
19183ccda647Slclee 		 * use the last active solaris partition id found
19193ccda647Slclee 		 * (there should only be 1 active partition id)
19203ccda647Slclee 		 *
19213ccda647Slclee 		 * if there are no active solaris partition id
19223ccda647Slclee 		 * then use the first inactive solaris partition id
19233ccda647Slclee 		 */
19243ccda647Slclee 		if ((uidx == -1) || (fdp->bootid == ACTIVE)) {
19253ccda647Slclee 			uidx = i;
19263ccda647Slclee 			solaris_offset = relsect;
19273ccda647Slclee 			solaris_size   = numsect;
19283ccda647Slclee 		}
19293ccda647Slclee 	}
19303ccda647Slclee 
1931*e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl, "fdisk 0x%x 0x%lx",
1932*e8fb11a1Sshidokht 	    cl->cl_solaris_offset, cl->cl_solaris_size);
19333ccda647Slclee done:
19343ccda647Slclee 
19353ccda647Slclee 	/*
19363ccda647Slclee 	 * Clear the VTOC info, only if the Solaris partition entry
19373ccda647Slclee 	 * has moved, changed size, been deleted, or if the size of
19383ccda647Slclee 	 * the partition is too small to even fit the label sector.
19393ccda647Slclee 	 */
1940*e8fb11a1Sshidokht 	if ((cl->cl_solaris_offset != solaris_offset) ||
1941*e8fb11a1Sshidokht 	    (cl->cl_solaris_size != solaris_size) ||
19423ccda647Slclee 	    solaris_size <= DK_LABEL_LOC) {
1943*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_INFO,  cl, "fdisk moved 0x%x 0x%lx",
1944*e8fb11a1Sshidokht 		    solaris_offset, solaris_size);
1945*e8fb11a1Sshidokht 		bzero(&cl->cl_g, sizeof (struct dk_geom));
1946*e8fb11a1Sshidokht 		bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
1947*e8fb11a1Sshidokht 		bzero(&cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
1948*e8fb11a1Sshidokht 		cl->cl_f_geometry_is_valid = FALSE;
1949*e8fb11a1Sshidokht 	}
1950*e8fb11a1Sshidokht 	cl->cl_solaris_offset = solaris_offset;
1951*e8fb11a1Sshidokht 	cl->cl_solaris_size = solaris_size;
19523ccda647Slclee 	kmem_free(bufp, blocksize);
19533ccda647Slclee 	return (rval);
19543ccda647Slclee 
19553ccda647Slclee #else	/* #elif defined(_FIRMWARE_NEEDS_FDISK) */
19563ccda647Slclee #error "fdisk table presence undetermined for this platform."
19573ccda647Slclee #endif	/* #if defined(_NO_FDISK_PRESENT) */
19583ccda647Slclee }
19593ccda647Slclee 
19603ccda647Slclee static void
19613ccda647Slclee cmlb_swap_efi_gpt(efi_gpt_t *e)
19623ccda647Slclee {
19633ccda647Slclee 	_NOTE(ASSUMING_PROTECTED(*e))
19643ccda647Slclee 	e->efi_gpt_Signature = LE_64(e->efi_gpt_Signature);
19653ccda647Slclee 	e->efi_gpt_Revision = LE_32(e->efi_gpt_Revision);
19663ccda647Slclee 	e->efi_gpt_HeaderSize = LE_32(e->efi_gpt_HeaderSize);
19673ccda647Slclee 	e->efi_gpt_HeaderCRC32 = LE_32(e->efi_gpt_HeaderCRC32);
19683ccda647Slclee 	e->efi_gpt_MyLBA = LE_64(e->efi_gpt_MyLBA);
19693ccda647Slclee 	e->efi_gpt_AlternateLBA = LE_64(e->efi_gpt_AlternateLBA);
19703ccda647Slclee 	e->efi_gpt_FirstUsableLBA = LE_64(e->efi_gpt_FirstUsableLBA);
19713ccda647Slclee 	e->efi_gpt_LastUsableLBA = LE_64(e->efi_gpt_LastUsableLBA);
19723ccda647Slclee 	UUID_LE_CONVERT(e->efi_gpt_DiskGUID, e->efi_gpt_DiskGUID);
19733ccda647Slclee 	e->efi_gpt_PartitionEntryLBA = LE_64(e->efi_gpt_PartitionEntryLBA);
19743ccda647Slclee 	e->efi_gpt_NumberOfPartitionEntries =
19753ccda647Slclee 	    LE_32(e->efi_gpt_NumberOfPartitionEntries);
19763ccda647Slclee 	e->efi_gpt_SizeOfPartitionEntry =
19773ccda647Slclee 	    LE_32(e->efi_gpt_SizeOfPartitionEntry);
19783ccda647Slclee 	e->efi_gpt_PartitionEntryArrayCRC32 =
19793ccda647Slclee 	    LE_32(e->efi_gpt_PartitionEntryArrayCRC32);
19803ccda647Slclee }
19813ccda647Slclee 
19823ccda647Slclee static void
19833ccda647Slclee cmlb_swap_efi_gpe(int nparts, efi_gpe_t *p)
19843ccda647Slclee {
19853ccda647Slclee 	int i;
19863ccda647Slclee 
19873ccda647Slclee 	_NOTE(ASSUMING_PROTECTED(*p))
19883ccda647Slclee 	for (i = 0; i < nparts; i++) {
19893ccda647Slclee 		UUID_LE_CONVERT(p[i].efi_gpe_PartitionTypeGUID,
19903ccda647Slclee 		    p[i].efi_gpe_PartitionTypeGUID);
19913ccda647Slclee 		p[i].efi_gpe_StartingLBA = LE_64(p[i].efi_gpe_StartingLBA);
19923ccda647Slclee 		p[i].efi_gpe_EndingLBA = LE_64(p[i].efi_gpe_EndingLBA);
19933ccda647Slclee 		/* PartitionAttrs */
19943ccda647Slclee 	}
19953ccda647Slclee }
19963ccda647Slclee 
19973ccda647Slclee static int
19983ccda647Slclee cmlb_validate_efi(efi_gpt_t *labp)
19993ccda647Slclee {
20003ccda647Slclee 	if (labp->efi_gpt_Signature != EFI_SIGNATURE)
20013ccda647Slclee 		return (EINVAL);
20023ccda647Slclee 	/* at least 96 bytes in this version of the spec. */
20033ccda647Slclee 	if (sizeof (efi_gpt_t) - sizeof (labp->efi_gpt_Reserved2) >
20043ccda647Slclee 	    labp->efi_gpt_HeaderSize)
20053ccda647Slclee 		return (EINVAL);
20063ccda647Slclee 	/* this should be 128 bytes */
20073ccda647Slclee 	if (labp->efi_gpt_SizeOfPartitionEntry != sizeof (efi_gpe_t))
20083ccda647Slclee 		return (EINVAL);
20093ccda647Slclee 	return (0);
20103ccda647Slclee }
20113ccda647Slclee 
20123ccda647Slclee static int
2013*e8fb11a1Sshidokht cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags,
2014*e8fb11a1Sshidokht     void *tg_cookie)
20153ccda647Slclee {
20163ccda647Slclee 	int		i;
20173ccda647Slclee 	int		rval = 0;
20183ccda647Slclee 	efi_gpe_t	*partitions;
20193ccda647Slclee 	uchar_t		*buf;
20203ccda647Slclee 	uint_t		lbasize;	/* is really how much to read */
2021*e8fb11a1Sshidokht 	diskaddr_t	cap = 0;
20223ccda647Slclee 	uint_t		nparts;
20233ccda647Slclee 	diskaddr_t	gpe_lba;
20241cec2d8cSshidokht 	int		iofailed = 0;
2025*e8fb11a1Sshidokht 	struct uuid	uuid_type_reserved = EFI_RESERVED;
20263ccda647Slclee 
2027*e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
20283ccda647Slclee 
2029*e8fb11a1Sshidokht 	if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) {
2030*e8fb11a1Sshidokht 		rval = EINVAL;
2031*e8fb11a1Sshidokht 		goto done_err1;
2032*e8fb11a1Sshidokht 	}
2033*e8fb11a1Sshidokht 
2034*e8fb11a1Sshidokht 
2035*e8fb11a1Sshidokht 	lbasize = cl->cl_sys_blocksize;
2036*e8fb11a1Sshidokht 
2037*e8fb11a1Sshidokht 	cl->cl_reserved = -1;
2038*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
20393ccda647Slclee 
20403ccda647Slclee 	buf = kmem_zalloc(EFI_MIN_ARRAY_SIZE, KM_SLEEP);
20413ccda647Slclee 
2042*e8fb11a1Sshidokht 	rval = DK_TG_READ(cl, buf, 0, lbasize, tg_cookie);
20433ccda647Slclee 	if (rval) {
20441cec2d8cSshidokht 		iofailed = 1;
20453ccda647Slclee 		goto done_err;
20463ccda647Slclee 	}
20473ccda647Slclee 	if (((struct dk_label *)buf)->dkl_magic == DKL_MAGIC) {
20483ccda647Slclee 		/* not ours */
20493ccda647Slclee 		rval = ESRCH;
20503ccda647Slclee 		goto done_err;
20513ccda647Slclee 	}
20523ccda647Slclee 
2053*e8fb11a1Sshidokht 	rval = DK_TG_READ(cl, buf, 1, lbasize, tg_cookie);
20543ccda647Slclee 	if (rval) {
20551cec2d8cSshidokht 		iofailed = 1;
20563ccda647Slclee 		goto done_err;
20573ccda647Slclee 	}
20583ccda647Slclee 	cmlb_swap_efi_gpt((efi_gpt_t *)buf);
20593ccda647Slclee 
20603ccda647Slclee 	if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0) {
20613ccda647Slclee 		/*
20623ccda647Slclee 		 * Couldn't read the primary, try the backup.  Our
20633ccda647Slclee 		 * capacity at this point could be based on CHS, so
20643ccda647Slclee 		 * check what the device reports.
20653ccda647Slclee 		 */
2066*e8fb11a1Sshidokht 		rval = DK_TG_GETCAP(cl, &cap, tg_cookie);
20673ccda647Slclee 		if (rval) {
20681cec2d8cSshidokht 			iofailed = 1;
20693ccda647Slclee 			goto done_err;
20703ccda647Slclee 		}
2071*e8fb11a1Sshidokht 
2072*e8fb11a1Sshidokht 		/*
2073*e8fb11a1Sshidokht 		 * CMLB_OFF_BY_ONE case, we check the next to last block first
2074*e8fb11a1Sshidokht 		 * for backup GPT header, otherwise check the last block.
2075*e8fb11a1Sshidokht 		 */
2076*e8fb11a1Sshidokht 
2077*e8fb11a1Sshidokht 		if ((rval = DK_TG_READ(cl, buf,
2078*e8fb11a1Sshidokht 		    cap - ((cl->cl_alter_behavior & CMLB_OFF_BY_ONE) ? 2 : 1),
2079*e8fb11a1Sshidokht 		    lbasize, tg_cookie))
2080*e8fb11a1Sshidokht 		    != 0) {
20811cec2d8cSshidokht 			iofailed = 1;
20823ccda647Slclee 			goto done_err;
20833ccda647Slclee 		}
20843ccda647Slclee 		cmlb_swap_efi_gpt((efi_gpt_t *)buf);
2085*e8fb11a1Sshidokht 
2086*e8fb11a1Sshidokht 		if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0) {
2087*e8fb11a1Sshidokht 
2088*e8fb11a1Sshidokht 			if (!(cl->cl_alter_behavior & CMLB_OFF_BY_ONE))
2089*e8fb11a1Sshidokht 				goto done_err;
2090*e8fb11a1Sshidokht 			if ((rval = DK_TG_READ(cl, buf, cap - 1, lbasize,
2091*e8fb11a1Sshidokht 			    tg_cookie)) != 0)
2092*e8fb11a1Sshidokht 				goto done_err;
2093*e8fb11a1Sshidokht 			cmlb_swap_efi_gpt((efi_gpt_t *)buf);
2094*e8fb11a1Sshidokht 			if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0)
2095*e8fb11a1Sshidokht 				goto done_err;
2096*e8fb11a1Sshidokht 		}
2097*e8fb11a1Sshidokht 		if (!(flags & CMLB_SILENT))
2098*e8fb11a1Sshidokht 			cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
2099*e8fb11a1Sshidokht 			    "primary label corrupt; using backup\n");
21003ccda647Slclee 	}
21013ccda647Slclee 
21023ccda647Slclee 	nparts = ((efi_gpt_t *)buf)->efi_gpt_NumberOfPartitionEntries;
21033ccda647Slclee 	gpe_lba = ((efi_gpt_t *)buf)->efi_gpt_PartitionEntryLBA;
21043ccda647Slclee 
2105*e8fb11a1Sshidokht 	rval = DK_TG_READ(cl, buf, gpe_lba, EFI_MIN_ARRAY_SIZE, tg_cookie);
21063ccda647Slclee 	if (rval) {
21071cec2d8cSshidokht 		iofailed = 1;
21083ccda647Slclee 		goto done_err;
21093ccda647Slclee 	}
21103ccda647Slclee 	partitions = (efi_gpe_t *)buf;
21113ccda647Slclee 
21123ccda647Slclee 	if (nparts > MAXPART) {
21133ccda647Slclee 		nparts = MAXPART;
21143ccda647Slclee 	}
21153ccda647Slclee 	cmlb_swap_efi_gpe(nparts, partitions);
21163ccda647Slclee 
2117*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
21183ccda647Slclee 
21193ccda647Slclee 	/* Fill in partition table. */
21203ccda647Slclee 	for (i = 0; i < nparts; i++) {
21213ccda647Slclee 		if (partitions->efi_gpe_StartingLBA != 0 ||
21223ccda647Slclee 		    partitions->efi_gpe_EndingLBA != 0) {
2123*e8fb11a1Sshidokht 			cl->cl_map[i].dkl_cylno =
21243ccda647Slclee 			    partitions->efi_gpe_StartingLBA;
2125*e8fb11a1Sshidokht 			cl->cl_map[i].dkl_nblk =
21263ccda647Slclee 			    partitions->efi_gpe_EndingLBA -
21273ccda647Slclee 			    partitions->efi_gpe_StartingLBA + 1;
2128*e8fb11a1Sshidokht 			cl->cl_offset[i] =
21293ccda647Slclee 			    partitions->efi_gpe_StartingLBA;
21303ccda647Slclee 		}
2131*e8fb11a1Sshidokht 
2132*e8fb11a1Sshidokht 		if (cl->cl_reserved == -1) {
2133*e8fb11a1Sshidokht 			if (bcmp(&partitions->efi_gpe_PartitionTypeGUID,
2134*e8fb11a1Sshidokht 			    &uuid_type_reserved, sizeof (struct uuid)) == 0) {
2135*e8fb11a1Sshidokht 				cl->cl_reserved = i;
2136*e8fb11a1Sshidokht 			}
2137*e8fb11a1Sshidokht 		}
21383ccda647Slclee 		if (i == WD_NODE) {
21393ccda647Slclee 			/*
21403ccda647Slclee 			 * minor number 7 corresponds to the whole disk
21413ccda647Slclee 			 */
2142*e8fb11a1Sshidokht 			cl->cl_map[i].dkl_cylno = 0;
2143*e8fb11a1Sshidokht 			cl->cl_map[i].dkl_nblk = capacity;
2144*e8fb11a1Sshidokht 			cl->cl_offset[i] = 0;
21453ccda647Slclee 		}
21463ccda647Slclee 		partitions++;
21473ccda647Slclee 	}
2148*e8fb11a1Sshidokht 	cl->cl_solaris_offset = 0;
2149*e8fb11a1Sshidokht 	cl->cl_solaris_size = capacity;
2150*e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = TRUE;
2151*e8fb11a1Sshidokht 
2152*e8fb11a1Sshidokht 	/* clear the vtoc label */
2153*e8fb11a1Sshidokht 	bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
2154*e8fb11a1Sshidokht 
21553ccda647Slclee 	kmem_free(buf, EFI_MIN_ARRAY_SIZE);
21563ccda647Slclee 	return (0);
21573ccda647Slclee 
21583ccda647Slclee done_err:
21593ccda647Slclee 	kmem_free(buf, EFI_MIN_ARRAY_SIZE);
2160*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
2161*e8fb11a1Sshidokht done_err1:
21623ccda647Slclee 	/*
21633ccda647Slclee 	 * if we didn't find something that could look like a VTOC
21643ccda647Slclee 	 * and the disk is over 1TB, we know there isn't a valid label.
21653ccda647Slclee 	 * Otherwise let cmlb_uselabel decide what to do.  We only
21663ccda647Slclee 	 * want to invalidate this if we're certain the label isn't
21673ccda647Slclee 	 * valid because cmlb_prop_op will now fail, which in turn
21683ccda647Slclee 	 * causes things like opens and stats on the partition to fail.
21693ccda647Slclee 	 */
21701cec2d8cSshidokht 	if ((capacity > DK_MAX_BLOCKS) && (rval != ESRCH) && !iofailed) {
2171*e8fb11a1Sshidokht 		cl->cl_f_geometry_is_valid = FALSE;
21723ccda647Slclee 	}
21733ccda647Slclee 	return (rval);
21743ccda647Slclee }
21753ccda647Slclee 
21763ccda647Slclee 
21773ccda647Slclee /*
21783ccda647Slclee  *    Function: cmlb_uselabel
21793ccda647Slclee  *
21803ccda647Slclee  * Description: Validate the disk label and update the relevant data (geometry,
21813ccda647Slclee  *		partition, vtoc, and capacity data) in the cmlb_lun struct.
21823ccda647Slclee  *		Marks the geometry of the unit as being valid.
21833ccda647Slclee  *
2184*e8fb11a1Sshidokht  *   Arguments: cl: unit struct.
21853ccda647Slclee  *		dk_label: disk label
21863ccda647Slclee  *
21873ccda647Slclee  * Return Code: CMLB_LABEL_IS_VALID: Label read from disk is OK; geometry,
21883ccda647Slclee  *		partition, vtoc, and capacity data are good.
21893ccda647Slclee  *
21903ccda647Slclee  *		CMLB_LABEL_IS_INVALID: Magic number or checksum error in the
21913ccda647Slclee  *		label; or computed capacity does not jibe with capacity
21923ccda647Slclee  *		reported from the READ CAPACITY command.
21933ccda647Slclee  *
21943ccda647Slclee  *     Context: Kernel thread only (can sleep).
21953ccda647Slclee  */
21963ccda647Slclee static int
2197*e8fb11a1Sshidokht cmlb_uselabel(struct cmlb_lun *cl, struct dk_label *labp, int flags)
21983ccda647Slclee {
21993ccda647Slclee 	short		*sp;
22003ccda647Slclee 	short		sum;
22013ccda647Slclee 	short		count;
22023ccda647Slclee 	int		label_error = CMLB_LABEL_IS_VALID;
22033ccda647Slclee 	int		i;
22043ccda647Slclee 	diskaddr_t	label_capacity;
22053ccda647Slclee 	int		part_end;
22063ccda647Slclee 	diskaddr_t	track_capacity;
22073ccda647Slclee #if defined(_SUNOS_VTOC_16)
22083ccda647Slclee 	struct	dkl_partition	*vpartp;
22093ccda647Slclee #endif
2210*e8fb11a1Sshidokht 	ASSERT(cl != NULL);
2211*e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
22123ccda647Slclee 
22133ccda647Slclee 	/* Validate the magic number of the label. */
22143ccda647Slclee 	if (labp->dkl_magic != DKL_MAGIC) {
22153ccda647Slclee #if defined(__sparc)
2216*e8fb11a1Sshidokht 		if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
2217*e8fb11a1Sshidokht 			if (!(flags & CMLB_SILENT))
2218*e8fb11a1Sshidokht 				cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
2219*e8fb11a1Sshidokht 				    CE_WARN,
2220*e8fb11a1Sshidokht 				    "Corrupt label; wrong magic number\n");
22213ccda647Slclee 		}
22223ccda647Slclee #endif
22233ccda647Slclee 		return (CMLB_LABEL_IS_INVALID);
22243ccda647Slclee 	}
22253ccda647Slclee 
22263ccda647Slclee 	/* Validate the checksum of the label. */
22273ccda647Slclee 	sp  = (short *)labp;
22283ccda647Slclee 	sum = 0;
22293ccda647Slclee 	count = sizeof (struct dk_label) / sizeof (short);
22303ccda647Slclee 	while (count--)	 {
22313ccda647Slclee 		sum ^= *sp++;
22323ccda647Slclee 	}
22333ccda647Slclee 
22343ccda647Slclee 	if (sum != 0) {
22353ccda647Slclee #if defined(_SUNOS_VTOC_16)
2236*e8fb11a1Sshidokht 		if (!ISCD(cl)) {
22373ccda647Slclee #elif defined(_SUNOS_VTOC_8)
2238*e8fb11a1Sshidokht 		if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
22393ccda647Slclee #endif
2240*e8fb11a1Sshidokht 			if (!(flags & CMLB_SILENT))
2241*e8fb11a1Sshidokht 				cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
2242*e8fb11a1Sshidokht 				    CE_WARN,
2243*e8fb11a1Sshidokht 				    "Corrupt label - label checksum failed\n");
22443ccda647Slclee 		}
22453ccda647Slclee 		return (CMLB_LABEL_IS_INVALID);
22463ccda647Slclee 	}
22473ccda647Slclee 
22483ccda647Slclee 
22493ccda647Slclee 	/*
22503ccda647Slclee 	 * Fill in geometry structure with data from label.
22513ccda647Slclee 	 */
2252*e8fb11a1Sshidokht 	bzero(&cl->cl_g, sizeof (struct dk_geom));
2253*e8fb11a1Sshidokht 	cl->cl_g.dkg_ncyl   = labp->dkl_ncyl;
2254*e8fb11a1Sshidokht 	cl->cl_g.dkg_acyl   = labp->dkl_acyl;
2255*e8fb11a1Sshidokht 	cl->cl_g.dkg_bcyl   = 0;
2256*e8fb11a1Sshidokht 	cl->cl_g.dkg_nhead  = labp->dkl_nhead;
2257*e8fb11a1Sshidokht 	cl->cl_g.dkg_nsect  = labp->dkl_nsect;
2258*e8fb11a1Sshidokht 	cl->cl_g.dkg_intrlv = labp->dkl_intrlv;
22593ccda647Slclee 
22603ccda647Slclee #if defined(_SUNOS_VTOC_8)
2261*e8fb11a1Sshidokht 	cl->cl_g.dkg_gap1   = labp->dkl_gap1;
2262*e8fb11a1Sshidokht 	cl->cl_g.dkg_gap2   = labp->dkl_gap2;
2263*e8fb11a1Sshidokht 	cl->cl_g.dkg_bhead  = labp->dkl_bhead;
22643ccda647Slclee #endif
22653ccda647Slclee #if defined(_SUNOS_VTOC_16)
2266*e8fb11a1Sshidokht 	cl->cl_dkg_skew = labp->dkl_skew;
22673ccda647Slclee #endif
22683ccda647Slclee 
22693ccda647Slclee #if defined(__i386) || defined(__amd64)
2270*e8fb11a1Sshidokht 	cl->cl_g.dkg_apc = labp->dkl_apc;
22713ccda647Slclee #endif
22723ccda647Slclee 
22733ccda647Slclee 	/*
22743ccda647Slclee 	 * Currently we rely on the values in the label being accurate. If
22753ccda647Slclee 	 * dkl_rpm or dkl_pcly are zero in the label, use a default value.
22763ccda647Slclee 	 *
22773ccda647Slclee 	 * Note: In the future a MODE SENSE may be used to retrieve this data,
22783ccda647Slclee 	 * although this command is optional in SCSI-2.
22793ccda647Slclee 	 */
2280*e8fb11a1Sshidokht 	cl->cl_g.dkg_rpm  = (labp->dkl_rpm  != 0) ? labp->dkl_rpm  : 3600;
2281*e8fb11a1Sshidokht 	cl->cl_g.dkg_pcyl = (labp->dkl_pcyl != 0) ? labp->dkl_pcyl :
2282*e8fb11a1Sshidokht 	    (cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl);
22833ccda647Slclee 
22843ccda647Slclee 	/*
22853ccda647Slclee 	 * The Read and Write reinstruct values may not be valid
22863ccda647Slclee 	 * for older disks.
22873ccda647Slclee 	 */
2288*e8fb11a1Sshidokht 	cl->cl_g.dkg_read_reinstruct  = labp->dkl_read_reinstruct;
2289*e8fb11a1Sshidokht 	cl->cl_g.dkg_write_reinstruct = labp->dkl_write_reinstruct;
22903ccda647Slclee 
22913ccda647Slclee 	/* Fill in partition table. */
22923ccda647Slclee #if defined(_SUNOS_VTOC_8)
22933ccda647Slclee 	for (i = 0; i < NDKMAP; i++) {
2294*e8fb11a1Sshidokht 		cl->cl_map[i].dkl_cylno = labp->dkl_map[i].dkl_cylno;
2295*e8fb11a1Sshidokht 		cl->cl_map[i].dkl_nblk  = labp->dkl_map[i].dkl_nblk;
22963ccda647Slclee 	}
22973ccda647Slclee #endif
22983ccda647Slclee #if  defined(_SUNOS_VTOC_16)
22993ccda647Slclee 	vpartp		= labp->dkl_vtoc.v_part;
23003ccda647Slclee 	track_capacity	= labp->dkl_nhead * labp->dkl_nsect;
23013ccda647Slclee 
2302*e8fb11a1Sshidokht 	/* Prevent divide by zero */
2303*e8fb11a1Sshidokht 	if (track_capacity == 0) {
2304*e8fb11a1Sshidokht 		if (!(flags & CMLB_SILENT))
2305*e8fb11a1Sshidokht 			cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
2306*e8fb11a1Sshidokht 			    "Corrupt label - zero nhead or nsect value\n");
2307*e8fb11a1Sshidokht 
2308*e8fb11a1Sshidokht 		return (CMLB_LABEL_IS_INVALID);
2309*e8fb11a1Sshidokht 	}
2310*e8fb11a1Sshidokht 
23113ccda647Slclee 	for (i = 0; i < NDKMAP; i++, vpartp++) {
2312*e8fb11a1Sshidokht 		cl->cl_map[i].dkl_cylno = vpartp->p_start / track_capacity;
2313*e8fb11a1Sshidokht 		cl->cl_map[i].dkl_nblk  = vpartp->p_size;
23143ccda647Slclee 	}
23153ccda647Slclee #endif
23163ccda647Slclee 
23173ccda647Slclee 	/* Fill in VTOC Structure. */
2318*e8fb11a1Sshidokht 	bcopy(&labp->dkl_vtoc, &cl->cl_vtoc, sizeof (struct dk_vtoc));
23193ccda647Slclee #if defined(_SUNOS_VTOC_8)
23203ccda647Slclee 	/*
23213ccda647Slclee 	 * The 8-slice vtoc does not include the ascii label; save it into
23223ccda647Slclee 	 * the device's soft state structure here.
23233ccda647Slclee 	 */
2324*e8fb11a1Sshidokht 	bcopy(labp->dkl_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII);
23253ccda647Slclee #endif
23263ccda647Slclee 
23273ccda647Slclee 	/* Now look for a valid capacity. */
2328*e8fb11a1Sshidokht 	track_capacity	= (cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect);
2329*e8fb11a1Sshidokht 	label_capacity	= (cl->cl_g.dkg_ncyl  * track_capacity);
23303ccda647Slclee 
2331*e8fb11a1Sshidokht 	if (cl->cl_g.dkg_acyl) {
23323ccda647Slclee #if defined(__i386) || defined(__amd64)
23333ccda647Slclee 		/* we may have > 1 alts cylinder */
2334*e8fb11a1Sshidokht 		label_capacity += (track_capacity * cl->cl_g.dkg_acyl);
23353ccda647Slclee #else
23363ccda647Slclee 		label_capacity += track_capacity;
23373ccda647Slclee #endif
23383ccda647Slclee 	}
23393ccda647Slclee 
2340*e8fb11a1Sshidokht 	/*
2341*e8fb11a1Sshidokht 	 * Force check here to ensure the computed capacity is valid.
2342*e8fb11a1Sshidokht 	 * If capacity is zero, it indicates an invalid label and
2343*e8fb11a1Sshidokht 	 * we should abort updating the relevant data then.
2344*e8fb11a1Sshidokht 	 */
2345*e8fb11a1Sshidokht 	if (label_capacity == 0) {
2346*e8fb11a1Sshidokht 		if (!(flags & CMLB_SILENT))
2347*e8fb11a1Sshidokht 			cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
2348*e8fb11a1Sshidokht 			    "Corrupt label - no valid capacity could be "
2349*e8fb11a1Sshidokht 			    "retrieved\n");
2350*e8fb11a1Sshidokht 
2351*e8fb11a1Sshidokht 		return (CMLB_LABEL_IS_INVALID);
2352*e8fb11a1Sshidokht 	}
2353*e8fb11a1Sshidokht 
2354*e8fb11a1Sshidokht 	/* Mark the geometry as valid. */
2355*e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = TRUE;
2356*e8fb11a1Sshidokht 
23573ccda647Slclee 	/*
23583ccda647Slclee 	 * if we got invalidated when mutex exit and entered again,
23593ccda647Slclee 	 * if blockcount different than when we came in, need to
23603ccda647Slclee 	 * retry from beginning of cmlb_validate_geometry.
23613ccda647Slclee 	 * revisit this on next phase of utilizing this for
23623ccda647Slclee 	 * sd.
23633ccda647Slclee 	 */
23643ccda647Slclee 
2365*e8fb11a1Sshidokht 	if (label_capacity <= cl->cl_blockcount) {
23663ccda647Slclee #if defined(_SUNOS_VTOC_8)
23673ccda647Slclee 		/*
23683ccda647Slclee 		 * We can't let this happen on drives that are subdivided
23693ccda647Slclee 		 * into logical disks (i.e., that have an fdisk table).
2370*e8fb11a1Sshidokht 		 * The cl_blockcount field should always hold the full media
23713ccda647Slclee 		 * size in sectors, period.  This code would overwrite
2372*e8fb11a1Sshidokht 		 * cl_blockcount with the size of the Solaris fdisk partition.
23733ccda647Slclee 		 */
2374*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_ERROR,  cl,
23753ccda647Slclee 		    "cmlb_uselabel: Label %d blocks; Drive %d blocks\n",
2376*e8fb11a1Sshidokht 		    label_capacity, cl->cl_blockcount);
2377*e8fb11a1Sshidokht 		cl->cl_solaris_size = label_capacity;
23783ccda647Slclee 
23793ccda647Slclee #endif	/* defined(_SUNOS_VTOC_8) */
23803ccda647Slclee 		goto done;
23813ccda647Slclee 	}
23823ccda647Slclee 
2383*e8fb11a1Sshidokht 	if (ISCD(cl)) {
23843ccda647Slclee 		/* For CDROMs, we trust that the data in the label is OK. */
23853ccda647Slclee #if defined(_SUNOS_VTOC_8)
23863ccda647Slclee 		for (i = 0; i < NDKMAP; i++) {
23873ccda647Slclee 			part_end = labp->dkl_nhead * labp->dkl_nsect *
23883ccda647Slclee 			    labp->dkl_map[i].dkl_cylno +
23893ccda647Slclee 			    labp->dkl_map[i].dkl_nblk  - 1;
23903ccda647Slclee 
23913ccda647Slclee 			if ((labp->dkl_map[i].dkl_nblk) &&
2392*e8fb11a1Sshidokht 			    (part_end > cl->cl_blockcount)) {
2393*e8fb11a1Sshidokht 				cl->cl_f_geometry_is_valid = FALSE;
23943ccda647Slclee 				break;
23953ccda647Slclee 			}
23963ccda647Slclee 		}
23973ccda647Slclee #endif
23983ccda647Slclee #if defined(_SUNOS_VTOC_16)
23993ccda647Slclee 		vpartp = &(labp->dkl_vtoc.v_part[0]);
24003ccda647Slclee 		for (i = 0; i < NDKMAP; i++, vpartp++) {
24013ccda647Slclee 			part_end = vpartp->p_start + vpartp->p_size;
24023ccda647Slclee 			if ((vpartp->p_size > 0) &&
2403*e8fb11a1Sshidokht 			    (part_end > cl->cl_blockcount)) {
2404*e8fb11a1Sshidokht 				cl->cl_f_geometry_is_valid = FALSE;
24053ccda647Slclee 				break;
24063ccda647Slclee 			}
24073ccda647Slclee 		}
24083ccda647Slclee #endif
24093ccda647Slclee 	} else {
2410*e8fb11a1Sshidokht 		/* label_capacity > cl->cl_blockcount */
2411*e8fb11a1Sshidokht 		if (!(flags & CMLB_SILENT)) {
2412*e8fb11a1Sshidokht 			cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
2413*e8fb11a1Sshidokht 			    "Corrupt label - bad geometry\n");
2414*e8fb11a1Sshidokht 			cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_CONT,
2415*e8fb11a1Sshidokht 			    "Label says %llu blocks; Drive says %llu blocks\n",
2416*e8fb11a1Sshidokht 			    label_capacity, cl->cl_blockcount);
2417*e8fb11a1Sshidokht 		}
2418*e8fb11a1Sshidokht 		cl->cl_f_geometry_is_valid = FALSE;
24193ccda647Slclee 		label_error = CMLB_LABEL_IS_INVALID;
24203ccda647Slclee 	}
24213ccda647Slclee 
24223ccda647Slclee done:
24233ccda647Slclee 
2424*e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl, "cmlb_uselabel: (label geometry)\n");
2425*e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl,
24263ccda647Slclee 	    "   ncyl: %d; acyl: %d; nhead: %d; nsect: %d\n",
2427*e8fb11a1Sshidokht 	    cl->cl_g.dkg_ncyl,  cl->cl_g.dkg_acyl,
2428*e8fb11a1Sshidokht 	    cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
24293ccda647Slclee 
2430*e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl,
24313ccda647Slclee 	    "   label_capacity: %d; intrlv: %d; rpm: %d\n",
2432*e8fb11a1Sshidokht 	    cl->cl_blockcount, cl->cl_g.dkg_intrlv, cl->cl_g.dkg_rpm);
2433*e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl, "   wrt_reinstr: %d; rd_reinstr: %d\n",
2434*e8fb11a1Sshidokht 	    cl->cl_g.dkg_write_reinstruct, cl->cl_g.dkg_read_reinstruct);
24353ccda647Slclee 
2436*e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
24373ccda647Slclee 
24383ccda647Slclee 	return (label_error);
24393ccda647Slclee }
24403ccda647Slclee 
24413ccda647Slclee 
24423ccda647Slclee /*
24433ccda647Slclee  *    Function: cmlb_build_default_label
24443ccda647Slclee  *
24453ccda647Slclee  * Description: Generate a default label for those devices that do not have
24463ccda647Slclee  *		one, e.g., new media, removable cartridges, etc..
24473ccda647Slclee  *
24483ccda647Slclee  *     Context: Kernel thread only
24493ccda647Slclee  */
2450*e8fb11a1Sshidokht /*ARGSUSED*/
24513ccda647Slclee static void
2452*e8fb11a1Sshidokht cmlb_build_default_label(struct cmlb_lun *cl, void *tg_cookie)
24533ccda647Slclee {
24543ccda647Slclee #if defined(_SUNOS_VTOC_16)
24553ccda647Slclee 	uint_t	phys_spc;
24563ccda647Slclee 	uint_t	disksize;
2457*e8fb11a1Sshidokht 	struct  dk_geom cl_g;
2458*e8fb11a1Sshidokht 	diskaddr_t capacity;
24593ccda647Slclee #endif
24603ccda647Slclee 
2461*e8fb11a1Sshidokht 	ASSERT(cl != NULL);
2462*e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
24633ccda647Slclee 
24643ccda647Slclee #if defined(_SUNOS_VTOC_8)
24653ccda647Slclee 	/*
24663ccda647Slclee 	 * Note: This is a legacy check for non-removable devices on VTOC_8
24673ccda647Slclee 	 * only. This may be a valid check for VTOC_16 as well.
2468*e8fb11a1Sshidokht 	 * Once we understand why there is this difference between SPARC and
2469*e8fb11a1Sshidokht 	 * x86 platform, we could remove this legacy check.
24703ccda647Slclee 	 */
2471*e8fb11a1Sshidokht 	if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
24723ccda647Slclee 		return;
24733ccda647Slclee 	}
24743ccda647Slclee #endif
24753ccda647Slclee 
2476*e8fb11a1Sshidokht 	bzero(&cl->cl_g, sizeof (struct dk_geom));
2477*e8fb11a1Sshidokht 	bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
2478*e8fb11a1Sshidokht 	bzero(&cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
24793ccda647Slclee 
24803ccda647Slclee #if defined(_SUNOS_VTOC_8)
24813ccda647Slclee 
24823ccda647Slclee 	/*
24833ccda647Slclee 	 * It's a REMOVABLE media, therefore no label (on sparc, anyway).
24843ccda647Slclee 	 * But it is still necessary to set up various geometry information,
24853ccda647Slclee 	 * and we are doing this here.
24863ccda647Slclee 	 */
24873ccda647Slclee 
24883ccda647Slclee 	/*
24893ccda647Slclee 	 * For the rpm, we use the minimum for the disk.  For the head, cyl,
24903ccda647Slclee 	 * and number of sector per track, if the capacity <= 1GB, head = 64,
24913ccda647Slclee 	 * sect = 32.  else head = 255, sect 63 Note: the capacity should be
24923ccda647Slclee 	 * equal to C*H*S values.  This will cause some truncation of size due
24933ccda647Slclee 	 * to round off errors. For CD-ROMs, this truncation can have adverse
24943ccda647Slclee 	 * side effects, so returning ncyl and nhead as 1. The nsect will
24953ccda647Slclee 	 * overflow for most of CD-ROMs as nsect is of type ushort. (4190569)
24963ccda647Slclee 	 */
2497*e8fb11a1Sshidokht 	cl->cl_solaris_size = cl->cl_blockcount;
2498*e8fb11a1Sshidokht 	if (ISCD(cl)) {
24993ccda647Slclee 		tg_attribute_t tgattribute;
25003ccda647Slclee 		int is_writable;
25013ccda647Slclee 		/*
25023ccda647Slclee 		 * Preserve the old behavior for non-writable
25033ccda647Slclee 		 * medias. Since dkg_nsect is a ushort, it
25043ccda647Slclee 		 * will lose bits as cdroms have more than
25053ccda647Slclee 		 * 65536 sectors. So if we recalculate
25063ccda647Slclee 		 * capacity, it will become much shorter.
25073ccda647Slclee 		 * But the dkg_* information is not
25083ccda647Slclee 		 * used for CDROMs so it is OK. But for
25093ccda647Slclee 		 * Writable CDs we need this information
25103ccda647Slclee 		 * to be valid (for newfs say). So we
25113ccda647Slclee 		 * make nsect and nhead > 1 that way
25123ccda647Slclee 		 * nsect can still stay within ushort limit
25133ccda647Slclee 		 * without losing any bits.
25143ccda647Slclee 		 */
25153ccda647Slclee 
25163ccda647Slclee 		bzero(&tgattribute, sizeof (tg_attribute_t));
25173ccda647Slclee 
2518*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
2519*e8fb11a1Sshidokht 		is_writable =
2520*e8fb11a1Sshidokht 		    (DK_TG_GETATTRIBUTE(cl, &tgattribute, tg_cookie) == 0) ?
25213ccda647Slclee 		    tgattribute.media_is_writable : 1;
2522*e8fb11a1Sshidokht 		mutex_enter(CMLB_MUTEX(cl));
25233ccda647Slclee 
25243ccda647Slclee 		if (is_writable) {
2525*e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 64;
2526*e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = 32;
2527*e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32);
2528*e8fb11a1Sshidokht 			cl->cl_solaris_size = cl->cl_g.dkg_ncyl *
2529*e8fb11a1Sshidokht 			    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
25303ccda647Slclee 		} else {
2531*e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl  = 1;
2532*e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 1;
2533*e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = cl->cl_blockcount;
25343ccda647Slclee 		}
25353ccda647Slclee 	} else {
2536*e8fb11a1Sshidokht 		if (cl->cl_blockcount <= 0x1000) {
25373ccda647Slclee 			/* unlabeled SCSI floppy device */
2538*e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 2;
2539*e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl = 80;
2540*e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = cl->cl_blockcount / (2 * 80);
2541*e8fb11a1Sshidokht 		} else if (cl->cl_blockcount <= 0x200000) {
2542*e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 64;
2543*e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = 32;
2544*e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl  = cl->cl_blockcount / (64 * 32);
25453ccda647Slclee 		} else {
2546*e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 255;
2547*e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = 63;
2548*e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl  = cl->cl_blockcount / (255 * 63);
25493ccda647Slclee 		}
2550*e8fb11a1Sshidokht 		cl->cl_solaris_size =
2551*e8fb11a1Sshidokht 		    cl->cl_g.dkg_ncyl * cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
25523ccda647Slclee 
25533ccda647Slclee 	}
25543ccda647Slclee 
2555*e8fb11a1Sshidokht 	cl->cl_g.dkg_acyl	= 0;
2556*e8fb11a1Sshidokht 	cl->cl_g.dkg_bcyl	= 0;
2557*e8fb11a1Sshidokht 	cl->cl_g.dkg_rpm	= 200;
2558*e8fb11a1Sshidokht 	cl->cl_asciilabel[0]	= '\0';
2559*e8fb11a1Sshidokht 	cl->cl_g.dkg_pcyl	= cl->cl_g.dkg_ncyl;
25603ccda647Slclee 
2561*e8fb11a1Sshidokht 	cl->cl_map[0].dkl_cylno = 0;
2562*e8fb11a1Sshidokht 	cl->cl_map[0].dkl_nblk  = cl->cl_solaris_size;
25633ccda647Slclee 
2564*e8fb11a1Sshidokht 	cl->cl_map[2].dkl_cylno = 0;
2565*e8fb11a1Sshidokht 	cl->cl_map[2].dkl_nblk  = cl->cl_solaris_size;
25663ccda647Slclee 
25673ccda647Slclee #elif defined(_SUNOS_VTOC_16)
25683ccda647Slclee 
2569*e8fb11a1Sshidokht 	if (cl->cl_solaris_size == 0) {
25703ccda647Slclee 		/*
25713ccda647Slclee 		 * Got fdisk table but no solaris entry therefore
25723ccda647Slclee 		 * don't create a default label
25733ccda647Slclee 		 */
2574*e8fb11a1Sshidokht 		cl->cl_f_geometry_is_valid = TRUE;
25753ccda647Slclee 		return;
25763ccda647Slclee 	}
25773ccda647Slclee 
25783ccda647Slclee 	/*
25793ccda647Slclee 	 * For CDs we continue to use the physical geometry to calculate
25803ccda647Slclee 	 * number of cylinders. All other devices must convert the
25813ccda647Slclee 	 * physical geometry (cmlb_geom) to values that will fit
25823ccda647Slclee 	 * in a dk_geom structure.
25833ccda647Slclee 	 */
2584*e8fb11a1Sshidokht 	if (ISCD(cl)) {
2585*e8fb11a1Sshidokht 		phys_spc = cl->cl_pgeom.g_nhead * cl->cl_pgeom.g_nsect;
25863ccda647Slclee 	} else {
25873ccda647Slclee 		/* Convert physical geometry to disk geometry */
2588*e8fb11a1Sshidokht 		bzero(&cl_g, sizeof (struct dk_geom));
2589*e8fb11a1Sshidokht 
2590*e8fb11a1Sshidokht 		/*
2591*e8fb11a1Sshidokht 		 * Refer to comments related to off-by-1 at the
2592*e8fb11a1Sshidokht 		 * header of this file.
2593*e8fb11a1Sshidokht 		 * Before caculating geometry, capacity should be
2594*e8fb11a1Sshidokht 		 * decreased by 1.
2595*e8fb11a1Sshidokht 		 */
2596*e8fb11a1Sshidokht 
2597*e8fb11a1Sshidokht 		if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE)
2598*e8fb11a1Sshidokht 			capacity = cl->cl_blockcount - 1;
2599*e8fb11a1Sshidokht 		else
2600*e8fb11a1Sshidokht 			capacity = cl->cl_blockcount;
2601*e8fb11a1Sshidokht 
2602*e8fb11a1Sshidokht 
2603*e8fb11a1Sshidokht 		cmlb_convert_geometry(capacity, &cl_g);
2604*e8fb11a1Sshidokht 		bcopy(&cl_g, &cl->cl_g, sizeof (cl->cl_g));
2605*e8fb11a1Sshidokht 		phys_spc = cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
26063ccda647Slclee 	}
26073ccda647Slclee 
2608*e8fb11a1Sshidokht 	ASSERT(phys_spc != 0);
2609*e8fb11a1Sshidokht 	cl->cl_g.dkg_pcyl = cl->cl_solaris_size / phys_spc;
2610*e8fb11a1Sshidokht 	cl->cl_g.dkg_acyl = DK_ACYL;
2611*e8fb11a1Sshidokht 	cl->cl_g.dkg_ncyl = cl->cl_g.dkg_pcyl - DK_ACYL;
2612*e8fb11a1Sshidokht 	disksize = cl->cl_g.dkg_ncyl * phys_spc;
26133ccda647Slclee 
2614*e8fb11a1Sshidokht 	if (ISCD(cl)) {
26153ccda647Slclee 		/*
26163ccda647Slclee 		 * CD's don't use the "heads * sectors * cyls"-type of
26173ccda647Slclee 		 * geometry, but instead use the entire capacity of the media.
26183ccda647Slclee 		 */
2619*e8fb11a1Sshidokht 		disksize = cl->cl_solaris_size;
2620*e8fb11a1Sshidokht 		cl->cl_g.dkg_nhead = 1;
2621*e8fb11a1Sshidokht 		cl->cl_g.dkg_nsect = 1;
2622*e8fb11a1Sshidokht 		cl->cl_g.dkg_rpm =
2623*e8fb11a1Sshidokht 		    (cl->cl_pgeom.g_rpm == 0) ? 200 : cl->cl_pgeom.g_rpm;
26243ccda647Slclee 
2625*e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[0].p_start = 0;
2626*e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[0].p_size  = disksize;
2627*e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[0].p_tag   = V_BACKUP;
2628*e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[0].p_flag  = V_UNMNT;
26293ccda647Slclee 
2630*e8fb11a1Sshidokht 		cl->cl_map[0].dkl_cylno = 0;
2631*e8fb11a1Sshidokht 		cl->cl_map[0].dkl_nblk  = disksize;
2632*e8fb11a1Sshidokht 		cl->cl_offset[0] = 0;
26333ccda647Slclee 
26343ccda647Slclee 	} else {
26353ccda647Slclee 		/*
26363ccda647Slclee 		 * Hard disks and removable media cartridges
26373ccda647Slclee 		 */
2638*e8fb11a1Sshidokht 		cl->cl_g.dkg_rpm =
2639*e8fb11a1Sshidokht 		    (cl->cl_pgeom.g_rpm == 0) ? 3600: cl->cl_pgeom.g_rpm;
2640*e8fb11a1Sshidokht 		cl->cl_vtoc.v_sectorsz = cl->cl_sys_blocksize;
26413ccda647Slclee 
26423ccda647Slclee 		/* Add boot slice */
2643*e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[8].p_start = 0;
2644*e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[8].p_size  = phys_spc;
2645*e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[8].p_tag   = V_BOOT;
2646*e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[8].p_flag  = V_UNMNT;
26473ccda647Slclee 
2648*e8fb11a1Sshidokht 		cl->cl_map[8].dkl_cylno = 0;
2649*e8fb11a1Sshidokht 		cl->cl_map[8].dkl_nblk  = phys_spc;
2650*e8fb11a1Sshidokht 		cl->cl_offset[8] = 0;
26513ccda647Slclee 
2652*e8fb11a1Sshidokht 		if ((cl->cl_alter_behavior &
26533ccda647Slclee 		    CMLB_CREATE_ALTSLICE_VTOC_16_DTYPE_DIRECT) &&
2654*e8fb11a1Sshidokht 		    cl->cl_device_type == DTYPE_DIRECT) {
2655*e8fb11a1Sshidokht 			cl->cl_vtoc.v_part[9].p_start = phys_spc;
2656*e8fb11a1Sshidokht 			cl->cl_vtoc.v_part[9].p_size  = 2 * phys_spc;
2657*e8fb11a1Sshidokht 			cl->cl_vtoc.v_part[9].p_tag   = V_ALTSCTR;
2658*e8fb11a1Sshidokht 			cl->cl_vtoc.v_part[9].p_flag  = 0;
2659*e8fb11a1Sshidokht 
2660*e8fb11a1Sshidokht 			cl->cl_map[9].dkl_cylno = 1;
2661*e8fb11a1Sshidokht 			cl->cl_map[9].dkl_nblk  = 2 * phys_spc;
2662*e8fb11a1Sshidokht 			cl->cl_offset[9] = phys_spc;
26633ccda647Slclee 		}
26643ccda647Slclee 	}
26653ccda647Slclee 
2666*e8fb11a1Sshidokht 	cl->cl_g.dkg_apc = 0;
2667*e8fb11a1Sshidokht 	cl->cl_vtoc.v_nparts = V_NUMPAR;
2668*e8fb11a1Sshidokht 	cl->cl_vtoc.v_version = V_VERSION;
26693ccda647Slclee 
26703ccda647Slclee 	/* Add backup slice */
2671*e8fb11a1Sshidokht 	cl->cl_vtoc.v_part[2].p_start = 0;
2672*e8fb11a1Sshidokht 	cl->cl_vtoc.v_part[2].p_size  = disksize;
2673*e8fb11a1Sshidokht 	cl->cl_vtoc.v_part[2].p_tag   = V_BACKUP;
2674*e8fb11a1Sshidokht 	cl->cl_vtoc.v_part[2].p_flag  = V_UNMNT;
26753ccda647Slclee 
2676*e8fb11a1Sshidokht 	cl->cl_map[2].dkl_cylno = 0;
2677*e8fb11a1Sshidokht 	cl->cl_map[2].dkl_nblk  = disksize;
2678*e8fb11a1Sshidokht 	cl->cl_offset[2] = 0;
26793ccda647Slclee 
2680*e8fb11a1Sshidokht 	(void) sprintf(cl->cl_vtoc.v_asciilabel, "DEFAULT cyl %d alt %d"
2681*e8fb11a1Sshidokht 	    " hd %d sec %d", cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
2682*e8fb11a1Sshidokht 	    cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
26833ccda647Slclee 
26843ccda647Slclee #else
26853ccda647Slclee #error "No VTOC format defined."
26863ccda647Slclee #endif
26873ccda647Slclee 
2688*e8fb11a1Sshidokht 	cl->cl_g.dkg_read_reinstruct  = 0;
2689*e8fb11a1Sshidokht 	cl->cl_g.dkg_write_reinstruct = 0;
26903ccda647Slclee 
2691*e8fb11a1Sshidokht 	cl->cl_g.dkg_intrlv = 1;
26923ccda647Slclee 
2693*e8fb11a1Sshidokht 	cl->cl_vtoc.v_sanity  = VTOC_SANE;
26943ccda647Slclee 
2695*e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = TRUE;
2696*e8fb11a1Sshidokht 	cl->cl_vtoc_label_is_from_media = 0;
26973ccda647Slclee 
2698*e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl,
26993ccda647Slclee 	    "cmlb_build_default_label: Default label created: "
27003ccda647Slclee 	    "cyl: %d\tacyl: %d\tnhead: %d\tnsect: %d\tcap: %d\n",
2701*e8fb11a1Sshidokht 	    cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl, cl->cl_g.dkg_nhead,
2702*e8fb11a1Sshidokht 	    cl->cl_g.dkg_nsect, cl->cl_blockcount);
27033ccda647Slclee }
27043ccda647Slclee 
27053ccda647Slclee 
27063ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
27073ccda647Slclee /*
27083ccda647Slclee  * Max CHS values, as they are encoded into bytes, for 1022/254/63
27093ccda647Slclee  */
27103ccda647Slclee #define	LBA_MAX_SECT	(63 | ((1022 & 0x300) >> 2))
27113ccda647Slclee #define	LBA_MAX_CYL	(1022 & 0xFF)
27123ccda647Slclee #define	LBA_MAX_HEAD	(254)
27133ccda647Slclee 
27143ccda647Slclee 
27153ccda647Slclee /*
27163ccda647Slclee  *    Function: cmlb_has_max_chs_vals
27173ccda647Slclee  *
27183ccda647Slclee  * Description: Return TRUE if Cylinder-Head-Sector values are all at maximum.
27193ccda647Slclee  *
27203ccda647Slclee  *   Arguments: fdp - ptr to CHS info
27213ccda647Slclee  *
27223ccda647Slclee  * Return Code: True or false
27233ccda647Slclee  *
27243ccda647Slclee  *     Context: Any.
27253ccda647Slclee  */
27263ccda647Slclee static int
27273ccda647Slclee cmlb_has_max_chs_vals(struct ipart *fdp)
27283ccda647Slclee {
27293ccda647Slclee 	return ((fdp->begcyl  == LBA_MAX_CYL)	&&
27303ccda647Slclee 	    (fdp->beghead == LBA_MAX_HEAD)	&&
27313ccda647Slclee 	    (fdp->begsect == LBA_MAX_SECT)	&&
27323ccda647Slclee 	    (fdp->endcyl  == LBA_MAX_CYL)	&&
27333ccda647Slclee 	    (fdp->endhead == LBA_MAX_HEAD)	&&
27343ccda647Slclee 	    (fdp->endsect == LBA_MAX_SECT));
27353ccda647Slclee }
27363ccda647Slclee #endif
27373ccda647Slclee 
27383ccda647Slclee /*
27393ccda647Slclee  *    Function: cmlb_dkio_get_geometry
27403ccda647Slclee  *
27413ccda647Slclee  * Description: This routine is the driver entry point for handling user
27423ccda647Slclee  *		requests to get the device geometry (DKIOCGGEOM).
27433ccda647Slclee  *
27443ccda647Slclee  *   Arguments:
2745*e8fb11a1Sshidokht  *	arg		pointer to user provided dk_geom structure specifying
27463ccda647Slclee  *			the controller's notion of the current geometry.
2747*e8fb11a1Sshidokht  *
2748*e8fb11a1Sshidokht  *	flag 		this argument is a pass through to ddi_copyxxx()
2749*e8fb11a1Sshidokht  *			directly from the mode argument of ioctl().
2750*e8fb11a1Sshidokht  *
2751*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
2752*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
27533ccda647Slclee  *
27543ccda647Slclee  * Return Code: 0
27553ccda647Slclee  *		EFAULT
27563ccda647Slclee  *		ENXIO
27573ccda647Slclee  *		EIO
27583ccda647Slclee  */
27593ccda647Slclee static int
2760*e8fb11a1Sshidokht cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag,
2761*e8fb11a1Sshidokht     void *tg_cookie)
27623ccda647Slclee {
27633ccda647Slclee 	struct dk_geom	*tmp_geom = NULL;
27643ccda647Slclee 	int		rval = 0;
27653ccda647Slclee 
27663ccda647Slclee 	/*
27673ccda647Slclee 	 * cmlb_validate_geometry does not spin a disk up
2768*e8fb11a1Sshidokht 	 * if it was spcl down. We need to make sure it
27693ccda647Slclee 	 * is ready.
27703ccda647Slclee 	 */
2771*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
2772*e8fb11a1Sshidokht 	rval = cmlb_validate_geometry(cl, 1, 0, tg_cookie);
27733ccda647Slclee #if defined(_SUNOS_VTOC_8)
27743ccda647Slclee 	if (rval == EINVAL &&
2775*e8fb11a1Sshidokht 	    cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) {
27763ccda647Slclee 		/*
27773ccda647Slclee 		 * This is to return a default label geometry even when we
27783ccda647Slclee 		 * do not really assume a default label for the device.
27793ccda647Slclee 		 * dad driver utilizes this.
27803ccda647Slclee 		 */
2781*e8fb11a1Sshidokht 		if (cl->cl_blockcount <= DK_MAX_BLOCKS) {
2782*e8fb11a1Sshidokht 			cmlb_setup_default_geometry(cl, tg_cookie);
27833ccda647Slclee 			rval = 0;
27843ccda647Slclee 		}
27853ccda647Slclee 	}
27863ccda647Slclee #endif
27873ccda647Slclee 	if (rval) {
2788*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
27893ccda647Slclee 		return (rval);
27903ccda647Slclee 	}
27913ccda647Slclee 
27923ccda647Slclee #if defined(__i386) || defined(__amd64)
2793*e8fb11a1Sshidokht 	if (cl->cl_solaris_size == 0) {
2794*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
27953ccda647Slclee 		return (EIO);
27963ccda647Slclee 	}
27973ccda647Slclee #endif
27983ccda647Slclee 
27993ccda647Slclee 	/*
28003ccda647Slclee 	 * Make a local copy of the soft state geometry to avoid some potential
28013ccda647Slclee 	 * race conditions associated with holding the mutex and updating the
28023ccda647Slclee 	 * write_reinstruct value
28033ccda647Slclee 	 */
28043ccda647Slclee 	tmp_geom = kmem_zalloc(sizeof (struct dk_geom), KM_SLEEP);
2805*e8fb11a1Sshidokht 	bcopy(&cl->cl_g, tmp_geom, sizeof (struct dk_geom));
28063ccda647Slclee 
28073ccda647Slclee 	if (tmp_geom->dkg_write_reinstruct == 0) {
28083ccda647Slclee 		tmp_geom->dkg_write_reinstruct =
28093ccda647Slclee 		    (int)((int)(tmp_geom->dkg_nsect * tmp_geom->dkg_rpm *
28103ccda647Slclee 		    cmlb_rot_delay) / (int)60000);
28113ccda647Slclee 	}
2812*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
28133ccda647Slclee 
28143ccda647Slclee 	rval = ddi_copyout(tmp_geom, (void *)arg, sizeof (struct dk_geom),
28153ccda647Slclee 	    flag);
28163ccda647Slclee 	if (rval != 0) {
28173ccda647Slclee 		rval = EFAULT;
28183ccda647Slclee 	}
28193ccda647Slclee 
28203ccda647Slclee 	kmem_free(tmp_geom, sizeof (struct dk_geom));
28213ccda647Slclee 	return (rval);
28223ccda647Slclee 
28233ccda647Slclee }
28243ccda647Slclee 
28253ccda647Slclee 
28263ccda647Slclee /*
28273ccda647Slclee  *    Function: cmlb_dkio_set_geometry
28283ccda647Slclee  *
28293ccda647Slclee  * Description: This routine is the driver entry point for handling user
28303ccda647Slclee  *		requests to set the device geometry (DKIOCSGEOM). The actual
28313ccda647Slclee  *		device geometry is not updated, just the driver "notion" of it.
28323ccda647Slclee  *
28333ccda647Slclee  *   Arguments:
2834*e8fb11a1Sshidokht  *	arg		pointer to user provided dk_geom structure used to set
28353ccda647Slclee  *			the controller's notion of the current geometry.
2836*e8fb11a1Sshidokht  *
2837*e8fb11a1Sshidokht  *	flag 		this argument is a pass through to ddi_copyxxx()
2838*e8fb11a1Sshidokht  *			directly from the mode argument of ioctl().
2839*e8fb11a1Sshidokht  *
2840*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
2841*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
28423ccda647Slclee  *
28433ccda647Slclee  * Return Code: 0
28443ccda647Slclee  *		EFAULT
28453ccda647Slclee  *		ENXIO
28463ccda647Slclee  *		EIO
28473ccda647Slclee  */
28483ccda647Slclee static int
2849*e8fb11a1Sshidokht cmlb_dkio_set_geometry(struct cmlb_lun *cl, caddr_t arg, int flag)
28503ccda647Slclee {
28513ccda647Slclee 	struct dk_geom	*tmp_geom;
28523ccda647Slclee 	struct dk_map	*lp;
28533ccda647Slclee 	int		rval = 0;
28543ccda647Slclee 	int		i;
28553ccda647Slclee 
28563ccda647Slclee 
28573ccda647Slclee #if defined(__i386) || defined(__amd64)
2858*e8fb11a1Sshidokht 	if (cl->cl_solaris_size == 0) {
28593ccda647Slclee 		return (EIO);
28603ccda647Slclee 	}
28613ccda647Slclee #endif
28623ccda647Slclee 	/*
28633ccda647Slclee 	 * We need to copy the user specified geometry into local
28643ccda647Slclee 	 * storage and then update the softstate. We don't want to hold
28653ccda647Slclee 	 * the mutex and copyin directly from the user to the soft state
28663ccda647Slclee 	 */
28673ccda647Slclee 	tmp_geom = (struct dk_geom *)
28683ccda647Slclee 	    kmem_zalloc(sizeof (struct dk_geom), KM_SLEEP);
28693ccda647Slclee 	rval = ddi_copyin(arg, tmp_geom, sizeof (struct dk_geom), flag);
28703ccda647Slclee 	if (rval != 0) {
28713ccda647Slclee 		kmem_free(tmp_geom, sizeof (struct dk_geom));
28723ccda647Slclee 		return (EFAULT);
28733ccda647Slclee 	}
28743ccda647Slclee 
2875*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
2876*e8fb11a1Sshidokht 	bcopy(tmp_geom, &cl->cl_g, sizeof (struct dk_geom));
28773ccda647Slclee 	for (i = 0; i < NDKMAP; i++) {
2878*e8fb11a1Sshidokht 		lp  = &cl->cl_map[i];
2879*e8fb11a1Sshidokht 		cl->cl_offset[i] =
2880*e8fb11a1Sshidokht 		    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
28813ccda647Slclee #if defined(__i386) || defined(__amd64)
2882*e8fb11a1Sshidokht 		cl->cl_offset[i] += cl->cl_solaris_offset;
28833ccda647Slclee #endif
28843ccda647Slclee 	}
2885*e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = FALSE;
2886*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
28873ccda647Slclee 	kmem_free(tmp_geom, sizeof (struct dk_geom));
28883ccda647Slclee 
28893ccda647Slclee 	return (rval);
28903ccda647Slclee }
28913ccda647Slclee 
28923ccda647Slclee /*
28933ccda647Slclee  *    Function: cmlb_dkio_get_partition
28943ccda647Slclee  *
28953ccda647Slclee  * Description: This routine is the driver entry point for handling user
28963ccda647Slclee  *		requests to get the partition table (DKIOCGAPART).
28973ccda647Slclee  *
28983ccda647Slclee  *   Arguments:
2899*e8fb11a1Sshidokht  *	arg		pointer to user provided dk_allmap structure specifying
29003ccda647Slclee  *			the controller's notion of the current partition table.
2901*e8fb11a1Sshidokht  *
2902*e8fb11a1Sshidokht  *	flag		this argument is a pass through to ddi_copyxxx()
2903*e8fb11a1Sshidokht  *			directly from the mode argument of ioctl().
2904*e8fb11a1Sshidokht  *
2905*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
2906*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
29073ccda647Slclee  *
29083ccda647Slclee  * Return Code: 0
29093ccda647Slclee  *		EFAULT
29103ccda647Slclee  *		ENXIO
29113ccda647Slclee  *		EIO
29123ccda647Slclee  */
29133ccda647Slclee static int
2914*e8fb11a1Sshidokht cmlb_dkio_get_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
2915*e8fb11a1Sshidokht     void *tg_cookie)
29163ccda647Slclee {
29173ccda647Slclee 	int		rval = 0;
29183ccda647Slclee 	int		size;
29193ccda647Slclee 
29203ccda647Slclee 	/*
29213ccda647Slclee 	 * Make sure the geometry is valid before getting the partition
29223ccda647Slclee 	 * information.
29233ccda647Slclee 	 */
2924*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
2925*e8fb11a1Sshidokht 	if ((rval = cmlb_validate_geometry(cl, 1, 0, tg_cookie)) != 0) {
2926*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
29273ccda647Slclee 		return (rval);
29283ccda647Slclee 	}
2929*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
29303ccda647Slclee 
29313ccda647Slclee #if defined(__i386) || defined(__amd64)
2932*e8fb11a1Sshidokht 	if (cl->cl_solaris_size == 0) {
29333ccda647Slclee 		return (EIO);
29343ccda647Slclee 	}
29353ccda647Slclee #endif
29363ccda647Slclee 
29373ccda647Slclee #ifdef _MULTI_DATAMODEL
29383ccda647Slclee 	switch (ddi_model_convert_from(flag & FMODELS)) {
29393ccda647Slclee 	case DDI_MODEL_ILP32: {
29403ccda647Slclee 		struct dk_map32 dk_map32[NDKMAP];
29413ccda647Slclee 		int		i;
29423ccda647Slclee 
29433ccda647Slclee 		for (i = 0; i < NDKMAP; i++) {
2944*e8fb11a1Sshidokht 			dk_map32[i].dkl_cylno = cl->cl_map[i].dkl_cylno;
2945*e8fb11a1Sshidokht 			dk_map32[i].dkl_nblk  = cl->cl_map[i].dkl_nblk;
29463ccda647Slclee 		}
29473ccda647Slclee 		size = NDKMAP * sizeof (struct dk_map32);
29483ccda647Slclee 		rval = ddi_copyout(dk_map32, (void *)arg, size, flag);
29493ccda647Slclee 		if (rval != 0) {
29503ccda647Slclee 			rval = EFAULT;
29513ccda647Slclee 		}
29523ccda647Slclee 		break;
29533ccda647Slclee 	}
29543ccda647Slclee 	case DDI_MODEL_NONE:
29553ccda647Slclee 		size = NDKMAP * sizeof (struct dk_map);
2956*e8fb11a1Sshidokht 		rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag);
29573ccda647Slclee 		if (rval != 0) {
29583ccda647Slclee 			rval = EFAULT;
29593ccda647Slclee 		}
29603ccda647Slclee 		break;
29613ccda647Slclee 	}
29623ccda647Slclee #else /* ! _MULTI_DATAMODEL */
29633ccda647Slclee 	size = NDKMAP * sizeof (struct dk_map);
2964*e8fb11a1Sshidokht 	rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag);
29653ccda647Slclee 	if (rval != 0) {
29663ccda647Slclee 		rval = EFAULT;
29673ccda647Slclee 	}
29683ccda647Slclee #endif /* _MULTI_DATAMODEL */
29693ccda647Slclee 	return (rval);
29703ccda647Slclee }
29713ccda647Slclee 
29723ccda647Slclee /*
29733ccda647Slclee  *    Function: cmlb_dkio_set_partition
29743ccda647Slclee  *
29753ccda647Slclee  * Description: This routine is the driver entry point for handling user
29763ccda647Slclee  *		requests to set the partition table (DKIOCSAPART). The actual
29773ccda647Slclee  *		device partition is not updated.
29783ccda647Slclee  *
29793ccda647Slclee  *   Arguments:
29803ccda647Slclee  *		arg  - pointer to user provided dk_allmap structure used to set
29813ccda647Slclee  *			the controller's notion of the partition table.
29823ccda647Slclee  *		flag - this argument is a pass through to ddi_copyxxx()
29833ccda647Slclee  *		       directly from the mode argument of ioctl().
29843ccda647Slclee  *
29853ccda647Slclee  * Return Code: 0
29863ccda647Slclee  *		EINVAL
29873ccda647Slclee  *		EFAULT
29883ccda647Slclee  *		ENXIO
29893ccda647Slclee  *		EIO
29903ccda647Slclee  */
29913ccda647Slclee static int
2992*e8fb11a1Sshidokht cmlb_dkio_set_partition(struct cmlb_lun *cl, caddr_t arg, int flag)
29933ccda647Slclee {
29943ccda647Slclee 	struct dk_map	dk_map[NDKMAP];
29953ccda647Slclee 	struct dk_map	*lp;
29963ccda647Slclee 	int		rval = 0;
29973ccda647Slclee 	int		size;
29983ccda647Slclee 	int		i;
29993ccda647Slclee #if defined(_SUNOS_VTOC_16)
30003ccda647Slclee 	struct dkl_partition	*vp;
30013ccda647Slclee #endif
30023ccda647Slclee 
30033ccda647Slclee 	/*
30043ccda647Slclee 	 * Set the map for all logical partitions.  We lock
30053ccda647Slclee 	 * the priority just to make sure an interrupt doesn't
30063ccda647Slclee 	 * come in while the map is half updated.
30073ccda647Slclee 	 */
3008*e8fb11a1Sshidokht 	_NOTE(DATA_READABLE_WITHOUT_LOCK(cmlb_lun::cl_solaris_size))
3009*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
30103ccda647Slclee 
3011*e8fb11a1Sshidokht 	if (cl->cl_blockcount > DK_MAX_BLOCKS) {
3012*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
30133ccda647Slclee 		return (ENOTSUP);
30143ccda647Slclee 	}
3015*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
3016*e8fb11a1Sshidokht 	if (cl->cl_solaris_size == 0) {
30173ccda647Slclee 		return (EIO);
30183ccda647Slclee 	}
30193ccda647Slclee 
30203ccda647Slclee #ifdef _MULTI_DATAMODEL
30213ccda647Slclee 	switch (ddi_model_convert_from(flag & FMODELS)) {
30223ccda647Slclee 	case DDI_MODEL_ILP32: {
30233ccda647Slclee 		struct dk_map32 dk_map32[NDKMAP];
30243ccda647Slclee 
30253ccda647Slclee 		size = NDKMAP * sizeof (struct dk_map32);
30263ccda647Slclee 		rval = ddi_copyin((void *)arg, dk_map32, size, flag);
30273ccda647Slclee 		if (rval != 0) {
30283ccda647Slclee 			return (EFAULT);
30293ccda647Slclee 		}
30303ccda647Slclee 		for (i = 0; i < NDKMAP; i++) {
30313ccda647Slclee 			dk_map[i].dkl_cylno = dk_map32[i].dkl_cylno;
30323ccda647Slclee 			dk_map[i].dkl_nblk  = dk_map32[i].dkl_nblk;
30333ccda647Slclee 		}
30343ccda647Slclee 		break;
30353ccda647Slclee 	}
30363ccda647Slclee 	case DDI_MODEL_NONE:
30373ccda647Slclee 		size = NDKMAP * sizeof (struct dk_map);
30383ccda647Slclee 		rval = ddi_copyin((void *)arg, dk_map, size, flag);
30393ccda647Slclee 		if (rval != 0) {
30403ccda647Slclee 			return (EFAULT);
30413ccda647Slclee 		}
30423ccda647Slclee 		break;
30433ccda647Slclee 	}
30443ccda647Slclee #else /* ! _MULTI_DATAMODEL */
30453ccda647Slclee 	size = NDKMAP * sizeof (struct dk_map);
30463ccda647Slclee 	rval = ddi_copyin((void *)arg, dk_map, size, flag);
30473ccda647Slclee 	if (rval != 0) {
30483ccda647Slclee 		return (EFAULT);
30493ccda647Slclee 	}
30503ccda647Slclee #endif /* _MULTI_DATAMODEL */
30513ccda647Slclee 
3052*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
30533ccda647Slclee 	/* Note: The size used in this bcopy is set based upon the data model */
3054*e8fb11a1Sshidokht 	bcopy(dk_map, cl->cl_map, size);
30553ccda647Slclee #if defined(_SUNOS_VTOC_16)
3056*e8fb11a1Sshidokht 	vp = (struct dkl_partition *)&(cl->cl_vtoc);
30573ccda647Slclee #endif	/* defined(_SUNOS_VTOC_16) */
30583ccda647Slclee 	for (i = 0; i < NDKMAP; i++) {
3059*e8fb11a1Sshidokht 		lp  = &cl->cl_map[i];
3060*e8fb11a1Sshidokht 		cl->cl_offset[i] =
3061*e8fb11a1Sshidokht 		    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
30623ccda647Slclee #if defined(_SUNOS_VTOC_16)
3063*e8fb11a1Sshidokht 		vp->p_start = cl->cl_offset[i];
30643ccda647Slclee 		vp->p_size = lp->dkl_nblk;
30653ccda647Slclee 		vp++;
30663ccda647Slclee #endif	/* defined(_SUNOS_VTOC_16) */
30673ccda647Slclee #if defined(__i386) || defined(__amd64)
3068*e8fb11a1Sshidokht 		cl->cl_offset[i] += cl->cl_solaris_offset;
30693ccda647Slclee #endif
30703ccda647Slclee 	}
3071*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
30723ccda647Slclee 	return (rval);
30733ccda647Slclee }
30743ccda647Slclee 
30753ccda647Slclee 
30763ccda647Slclee /*
30773ccda647Slclee  *    Function: cmlb_dkio_get_vtoc
30783ccda647Slclee  *
30793ccda647Slclee  * Description: This routine is the driver entry point for handling user
30803ccda647Slclee  *		requests to get the current volume table of contents
30813ccda647Slclee  *		(DKIOCGVTOC).
30823ccda647Slclee  *
30833ccda647Slclee  *   Arguments:
3084*e8fb11a1Sshidokht  *	arg		pointer to user provided vtoc structure specifying
30853ccda647Slclee  *			the current vtoc.
3086*e8fb11a1Sshidokht  *
3087*e8fb11a1Sshidokht  *	flag		this argument is a pass through to ddi_copyxxx()
3088*e8fb11a1Sshidokht  *			directly from the mode argument of ioctl().
3089*e8fb11a1Sshidokht  *
3090*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
3091*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
30923ccda647Slclee  *
30933ccda647Slclee  * Return Code: 0
30943ccda647Slclee  *		EFAULT
30953ccda647Slclee  *		ENXIO
30963ccda647Slclee  *		EIO
30973ccda647Slclee  */
30983ccda647Slclee static int
3099*e8fb11a1Sshidokht cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
31003ccda647Slclee {
31013ccda647Slclee #if defined(_SUNOS_VTOC_8)
31023ccda647Slclee 	struct vtoc	user_vtoc;
31033ccda647Slclee #endif	/* defined(_SUNOS_VTOC_8) */
31043ccda647Slclee 	int		rval = 0;
31053ccda647Slclee 
3106*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
3107*e8fb11a1Sshidokht 	rval = cmlb_validate_geometry(cl, 1, 0, tg_cookie);
31083ccda647Slclee 
31093ccda647Slclee #if defined(_SUNOS_VTOC_8)
31103ccda647Slclee 	if (rval == EINVAL &&
3111*e8fb11a1Sshidokht 	    (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8)) {
31123ccda647Slclee 		/*
31133ccda647Slclee 		 * This is to return a default label even when we do not
31143ccda647Slclee 		 * really assume a default label for the device.
31153ccda647Slclee 		 * dad driver utilizes this.
31163ccda647Slclee 		 */
3117*e8fb11a1Sshidokht 		if (cl->cl_blockcount <= DK_MAX_BLOCKS) {
3118*e8fb11a1Sshidokht 			cmlb_setup_default_geometry(cl, tg_cookie);
31193ccda647Slclee 			rval = 0;
31203ccda647Slclee 		}
31213ccda647Slclee 	}
31223ccda647Slclee #endif
31233ccda647Slclee 	if (rval) {
3124*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
31253ccda647Slclee 		return (rval);
31263ccda647Slclee 	}
31273ccda647Slclee 
31283ccda647Slclee #if defined(_SUNOS_VTOC_8)
3129*e8fb11a1Sshidokht 	cmlb_build_user_vtoc(cl, &user_vtoc);
3130*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
31313ccda647Slclee 
31323ccda647Slclee #ifdef _MULTI_DATAMODEL
31333ccda647Slclee 	switch (ddi_model_convert_from(flag & FMODELS)) {
31343ccda647Slclee 	case DDI_MODEL_ILP32: {
31353ccda647Slclee 		struct vtoc32 user_vtoc32;
31363ccda647Slclee 
31373ccda647Slclee 		vtoctovtoc32(user_vtoc, user_vtoc32);
31383ccda647Slclee 		if (ddi_copyout(&user_vtoc32, (void *)arg,
31393ccda647Slclee 		    sizeof (struct vtoc32), flag)) {
31403ccda647Slclee 			return (EFAULT);
31413ccda647Slclee 		}
31423ccda647Slclee 		break;
31433ccda647Slclee 	}
31443ccda647Slclee 
31453ccda647Slclee 	case DDI_MODEL_NONE:
31463ccda647Slclee 		if (ddi_copyout(&user_vtoc, (void *)arg,
31473ccda647Slclee 		    sizeof (struct vtoc), flag)) {
31483ccda647Slclee 			return (EFAULT);
31493ccda647Slclee 		}
31503ccda647Slclee 		break;
31513ccda647Slclee 	}
31523ccda647Slclee #else /* ! _MULTI_DATAMODEL */
31533ccda647Slclee 	if (ddi_copyout(&user_vtoc, (void *)arg, sizeof (struct vtoc), flag)) {
31543ccda647Slclee 		return (EFAULT);
31553ccda647Slclee 	}
31563ccda647Slclee #endif /* _MULTI_DATAMODEL */
31573ccda647Slclee 
31583ccda647Slclee #elif defined(_SUNOS_VTOC_16)
3159*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
31603ccda647Slclee 
31613ccda647Slclee #ifdef _MULTI_DATAMODEL
31623ccda647Slclee 	/*
3163*e8fb11a1Sshidokht 	 * The cl_vtoc structure is a "struct dk_vtoc"  which is always
31643ccda647Slclee 	 * 32-bit to maintain compatibility with existing on-disk
31653ccda647Slclee 	 * structures.  Thus, we need to convert the structure when copying
31663ccda647Slclee 	 * it out to a datamodel-dependent "struct vtoc" in a 64-bit
31673ccda647Slclee 	 * program.  If the target is a 32-bit program, then no conversion
31683ccda647Slclee 	 * is necessary.
31693ccda647Slclee 	 */
31703ccda647Slclee 	/* LINTED: logical expression always true: op "||" */
3171*e8fb11a1Sshidokht 	ASSERT(sizeof (cl->cl_vtoc) == sizeof (struct vtoc32));
31723ccda647Slclee 	switch (ddi_model_convert_from(flag & FMODELS)) {
31733ccda647Slclee 	case DDI_MODEL_ILP32:
3174*e8fb11a1Sshidokht 		if (ddi_copyout(&(cl->cl_vtoc), (void *)arg,
3175*e8fb11a1Sshidokht 		    sizeof (cl->cl_vtoc), flag)) {
31763ccda647Slclee 			return (EFAULT);
31773ccda647Slclee 		}
31783ccda647Slclee 		break;
31793ccda647Slclee 
31803ccda647Slclee 	case DDI_MODEL_NONE: {
31813ccda647Slclee 		struct vtoc user_vtoc;
31823ccda647Slclee 
3183*e8fb11a1Sshidokht 		vtoc32tovtoc(cl->cl_vtoc, user_vtoc);
31843ccda647Slclee 		if (ddi_copyout(&user_vtoc, (void *)arg,
31853ccda647Slclee 		    sizeof (struct vtoc), flag)) {
31863ccda647Slclee 			return (EFAULT);
31873ccda647Slclee 		}
31883ccda647Slclee 		break;
31893ccda647Slclee 	}
31903ccda647Slclee 	}
31913ccda647Slclee #else /* ! _MULTI_DATAMODEL */
3192*e8fb11a1Sshidokht 	if (ddi_copyout(&(cl->cl_vtoc), (void *)arg, sizeof (cl->cl_vtoc),
31933ccda647Slclee 	    flag)) {
31943ccda647Slclee 		return (EFAULT);
31953ccda647Slclee 	}
31963ccda647Slclee #endif /* _MULTI_DATAMODEL */
31973ccda647Slclee #else
31983ccda647Slclee #error "No VTOC format defined."
31993ccda647Slclee #endif
32003ccda647Slclee 
32013ccda647Slclee 	return (rval);
32023ccda647Slclee }
32033ccda647Slclee 
32043ccda647Slclee static int
3205*e8fb11a1Sshidokht cmlb_dkio_get_efi(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
32063ccda647Slclee {
32073ccda647Slclee 	dk_efi_t	user_efi;
32083ccda647Slclee 	int		rval = 0;
32093ccda647Slclee 	void		*buffer;
3210*e8fb11a1Sshidokht 	diskaddr_t	tgt_lba;
32113ccda647Slclee 
32123ccda647Slclee 	if (ddi_copyin(arg, &user_efi, sizeof (dk_efi_t), flag))
32133ccda647Slclee 		return (EFAULT);
32143ccda647Slclee 
32153ccda647Slclee 	user_efi.dki_data = (void *)(uintptr_t)user_efi.dki_data_64;
32163ccda647Slclee 
3217*e8fb11a1Sshidokht 	tgt_lba = user_efi.dki_lba;
3218*e8fb11a1Sshidokht 
3219*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
3220*e8fb11a1Sshidokht 	if ((cmlb_check_update_blockcount(cl, tg_cookie) != 0) ||
3221*e8fb11a1Sshidokht 	    (cl->cl_tgt_blocksize == 0)) {
3222*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
3223*e8fb11a1Sshidokht 		return (EINVAL);
3224*e8fb11a1Sshidokht 	}
3225*e8fb11a1Sshidokht 	if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize)
3226*e8fb11a1Sshidokht 		tgt_lba = tgt_lba * cl->cl_tgt_blocksize /
3227*e8fb11a1Sshidokht 		    cl->cl_sys_blocksize;
3228*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
3229*e8fb11a1Sshidokht 
32303ccda647Slclee 	buffer = kmem_alloc(user_efi.dki_length, KM_SLEEP);
3231*e8fb11a1Sshidokht 	rval = DK_TG_READ(cl, buffer, tgt_lba, user_efi.dki_length, tg_cookie);
32323ccda647Slclee 	if (rval == 0 && ddi_copyout(buffer, user_efi.dki_data,
32333ccda647Slclee 	    user_efi.dki_length, flag) != 0)
32343ccda647Slclee 		rval = EFAULT;
32353ccda647Slclee 
32363ccda647Slclee 	kmem_free(buffer, user_efi.dki_length);
32373ccda647Slclee 	return (rval);
32383ccda647Slclee }
32393ccda647Slclee 
3240*e8fb11a1Sshidokht #if defined(_SUNOS_VTOC_8)
32413ccda647Slclee /*
32423ccda647Slclee  *    Function: cmlb_build_user_vtoc
32433ccda647Slclee  *
32443ccda647Slclee  * Description: This routine populates a pass by reference variable with the
32453ccda647Slclee  *		current volume table of contents.
32463ccda647Slclee  *
3247*e8fb11a1Sshidokht  *   Arguments: cl - driver soft state (unit) structure
32483ccda647Slclee  *		user_vtoc - pointer to vtoc structure to be populated
32493ccda647Slclee  */
32503ccda647Slclee static void
3251*e8fb11a1Sshidokht cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc)
32523ccda647Slclee {
32533ccda647Slclee 	struct dk_map2		*lpart;
32543ccda647Slclee 	struct dk_map		*lmap;
32553ccda647Slclee 	struct partition	*vpart;
32563ccda647Slclee 	int			nblks;
32573ccda647Slclee 	int			i;
32583ccda647Slclee 
3259*e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
32603ccda647Slclee 
32613ccda647Slclee 	/*
32623ccda647Slclee 	 * Return vtoc structure fields in the provided VTOC area, addressed
32633ccda647Slclee 	 * by *vtoc.
32643ccda647Slclee 	 */
32653ccda647Slclee 	bzero(user_vtoc, sizeof (struct vtoc));
3266*e8fb11a1Sshidokht 	user_vtoc->v_bootinfo[0] = cl->cl_vtoc.v_bootinfo[0];
3267*e8fb11a1Sshidokht 	user_vtoc->v_bootinfo[1] = cl->cl_vtoc.v_bootinfo[1];
3268*e8fb11a1Sshidokht 	user_vtoc->v_bootinfo[2] = cl->cl_vtoc.v_bootinfo[2];
32693ccda647Slclee 	user_vtoc->v_sanity	= VTOC_SANE;
3270*e8fb11a1Sshidokht 	user_vtoc->v_version	= cl->cl_vtoc.v_version;
3271*e8fb11a1Sshidokht 	bcopy(cl->cl_vtoc.v_volume, user_vtoc->v_volume, LEN_DKL_VVOL);
3272*e8fb11a1Sshidokht 	user_vtoc->v_sectorsz = cl->cl_sys_blocksize;
3273*e8fb11a1Sshidokht 	user_vtoc->v_nparts = cl->cl_vtoc.v_nparts;
32743ccda647Slclee 
32753ccda647Slclee 	for (i = 0; i < 10; i++)
3276*e8fb11a1Sshidokht 		user_vtoc->v_reserved[i] = cl->cl_vtoc.v_reserved[i];
32773ccda647Slclee 
32783ccda647Slclee 	/*
32793ccda647Slclee 	 * Convert partitioning information.
32803ccda647Slclee 	 *
32813ccda647Slclee 	 * Note the conversion from starting cylinder number
32823ccda647Slclee 	 * to starting sector number.
32833ccda647Slclee 	 */
3284*e8fb11a1Sshidokht 	lmap = cl->cl_map;
3285*e8fb11a1Sshidokht 	lpart = (struct dk_map2 *)cl->cl_vtoc.v_part;
32863ccda647Slclee 	vpart = user_vtoc->v_part;
32873ccda647Slclee 
3288*e8fb11a1Sshidokht 	nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead;
32893ccda647Slclee 
32903ccda647Slclee 	for (i = 0; i < V_NUMPAR; i++) {
32913ccda647Slclee 		vpart->p_tag	= lpart->p_tag;
32923ccda647Slclee 		vpart->p_flag	= lpart->p_flag;
32933ccda647Slclee 		vpart->p_start	= lmap->dkl_cylno * nblks;
32943ccda647Slclee 		vpart->p_size	= lmap->dkl_nblk;
32953ccda647Slclee 		lmap++;
32963ccda647Slclee 		lpart++;
32973ccda647Slclee 		vpart++;
32983ccda647Slclee 
32993ccda647Slclee 		/* (4364927) */
3300*e8fb11a1Sshidokht 		user_vtoc->timestamp[i] = (time_t)cl->cl_vtoc.v_timestamp[i];
33013ccda647Slclee 	}
33023ccda647Slclee 
3303*e8fb11a1Sshidokht 	bcopy(cl->cl_asciilabel, user_vtoc->v_asciilabel, LEN_DKL_ASCII);
33043ccda647Slclee }
3305*e8fb11a1Sshidokht #endif
33063ccda647Slclee 
33073ccda647Slclee static int
3308*e8fb11a1Sshidokht cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
3309*e8fb11a1Sshidokht     void *tg_cookie)
33103ccda647Slclee {
33113ccda647Slclee 	struct partition64	p64;
33123ccda647Slclee 	int			rval = 0;
33133ccda647Slclee 	uint_t			nparts;
33143ccda647Slclee 	efi_gpe_t		*partitions;
33153ccda647Slclee 	efi_gpt_t		*buffer;
33163ccda647Slclee 	diskaddr_t		gpe_lba;
33173ccda647Slclee 
33183ccda647Slclee 	if (ddi_copyin((const void *)arg, &p64,
33193ccda647Slclee 	    sizeof (struct partition64), flag)) {
33203ccda647Slclee 		return (EFAULT);
33213ccda647Slclee 	}
33223ccda647Slclee 
33233ccda647Slclee 	buffer = kmem_alloc(EFI_MIN_ARRAY_SIZE, KM_SLEEP);
3324*e8fb11a1Sshidokht 	rval = DK_TG_READ(cl, buffer, 1, DEV_BSIZE, tg_cookie);
33253ccda647Slclee 	if (rval != 0)
33263ccda647Slclee 		goto done_error;
33273ccda647Slclee 
33283ccda647Slclee 	cmlb_swap_efi_gpt(buffer);
33293ccda647Slclee 
33303ccda647Slclee 	if ((rval = cmlb_validate_efi(buffer)) != 0)
33313ccda647Slclee 		goto done_error;
33323ccda647Slclee 
33333ccda647Slclee 	nparts = buffer->efi_gpt_NumberOfPartitionEntries;
33343ccda647Slclee 	gpe_lba = buffer->efi_gpt_PartitionEntryLBA;
33353ccda647Slclee 	if (p64.p_partno > nparts) {
33363ccda647Slclee 		/* couldn't find it */
33373ccda647Slclee 		rval = ESRCH;
33383ccda647Slclee 		goto done_error;
33393ccda647Slclee 	}
33403ccda647Slclee 	/*
33413ccda647Slclee 	 * if we're dealing with a partition that's out of the normal
33423ccda647Slclee 	 * 16K block, adjust accordingly
33433ccda647Slclee 	 */
33443ccda647Slclee 	gpe_lba += p64.p_partno / sizeof (efi_gpe_t);
3345*e8fb11a1Sshidokht 	rval = DK_TG_READ(cl, buffer, gpe_lba, EFI_MIN_ARRAY_SIZE, tg_cookie);
33463ccda647Slclee 
33473ccda647Slclee 	if (rval) {
33483ccda647Slclee 		goto done_error;
33493ccda647Slclee 	}
33503ccda647Slclee 	partitions = (efi_gpe_t *)buffer;
33513ccda647Slclee 
33523ccda647Slclee 	cmlb_swap_efi_gpe(nparts, partitions);
33533ccda647Slclee 
33543ccda647Slclee 	partitions += p64.p_partno;
33553ccda647Slclee 	bcopy(&partitions->efi_gpe_PartitionTypeGUID, &p64.p_type,
33563ccda647Slclee 	    sizeof (struct uuid));
33573ccda647Slclee 	p64.p_start = partitions->efi_gpe_StartingLBA;
33583ccda647Slclee 	p64.p_size = partitions->efi_gpe_EndingLBA -
3359*e8fb11a1Sshidokht 	    p64.p_start + 1;
33603ccda647Slclee 
33613ccda647Slclee 	if (ddi_copyout(&p64, (void *)arg, sizeof (struct partition64), flag))
33623ccda647Slclee 		rval = EFAULT;
33633ccda647Slclee 
33643ccda647Slclee done_error:
33653ccda647Slclee 	kmem_free(buffer, EFI_MIN_ARRAY_SIZE);
33663ccda647Slclee 	return (rval);
33673ccda647Slclee }
33683ccda647Slclee 
33693ccda647Slclee 
33703ccda647Slclee /*
33713ccda647Slclee  *    Function: cmlb_dkio_set_vtoc
33723ccda647Slclee  *
33733ccda647Slclee  * Description: This routine is the driver entry point for handling user
33743ccda647Slclee  *		requests to set the current volume table of contents
33753ccda647Slclee  *		(DKIOCSVTOC).
33763ccda647Slclee  *
3377*e8fb11a1Sshidokht  *   Arguments:
3378*e8fb11a1Sshidokht  *	dev		the device number
3379*e8fb11a1Sshidokht  *	arg		pointer to user provided vtoc structure used to set the
33803ccda647Slclee  *			current vtoc.
3381*e8fb11a1Sshidokht  *
3382*e8fb11a1Sshidokht  *	flag		this argument is a pass through to ddi_copyxxx()
3383*e8fb11a1Sshidokht  *			directly from the mode argument of ioctl().
3384*e8fb11a1Sshidokht  *
3385*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
3386*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
33873ccda647Slclee  *
33883ccda647Slclee  * Return Code: 0
33893ccda647Slclee  *		EFAULT
33903ccda647Slclee  *		ENXIO
33913ccda647Slclee  *		EINVAL
33923ccda647Slclee  *		ENOTSUP
33933ccda647Slclee  */
33943ccda647Slclee static int
3395*e8fb11a1Sshidokht cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag,
3396*e8fb11a1Sshidokht     void *tg_cookie)
33973ccda647Slclee {
33983ccda647Slclee 	struct vtoc	user_vtoc;
33993ccda647Slclee 	int		rval = 0;
34003ccda647Slclee 
34013ccda647Slclee #ifdef _MULTI_DATAMODEL
34023ccda647Slclee 	switch (ddi_model_convert_from(flag & FMODELS)) {
34033ccda647Slclee 	case DDI_MODEL_ILP32: {
34043ccda647Slclee 		struct vtoc32 user_vtoc32;
34053ccda647Slclee 
34063ccda647Slclee 		if (ddi_copyin((const void *)arg, &user_vtoc32,
34073ccda647Slclee 		    sizeof (struct vtoc32), flag)) {
34083ccda647Slclee 			return (EFAULT);
34093ccda647Slclee 		}
34103ccda647Slclee 		vtoc32tovtoc(user_vtoc32, user_vtoc);
34113ccda647Slclee 		break;
34123ccda647Slclee 	}
34133ccda647Slclee 
34143ccda647Slclee 	case DDI_MODEL_NONE:
34153ccda647Slclee 		if (ddi_copyin((const void *)arg, &user_vtoc,
34163ccda647Slclee 		    sizeof (struct vtoc), flag)) {
34173ccda647Slclee 			return (EFAULT);
34183ccda647Slclee 		}
34193ccda647Slclee 		break;
34203ccda647Slclee 	}
34213ccda647Slclee #else /* ! _MULTI_DATAMODEL */
34223ccda647Slclee 	if (ddi_copyin((const void *)arg, &user_vtoc,
34233ccda647Slclee 	    sizeof (struct vtoc), flag)) {
34243ccda647Slclee 		return (EFAULT);
34253ccda647Slclee 	}
34263ccda647Slclee #endif /* _MULTI_DATAMODEL */
34273ccda647Slclee 
3428*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
3429*e8fb11a1Sshidokht 	if (cl->cl_blockcount > DK_MAX_BLOCKS) {
3430*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
34313ccda647Slclee 		return (ENOTSUP);
34323ccda647Slclee 	}
3433*e8fb11a1Sshidokht 
3434*e8fb11a1Sshidokht #if defined(__i386) || defined(__amd64)
3435*e8fb11a1Sshidokht 	if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) {
3436*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
34373ccda647Slclee 		return (EINVAL);
34383ccda647Slclee 	}
3439*e8fb11a1Sshidokht #endif
34403ccda647Slclee 
3441*e8fb11a1Sshidokht 	if (cl->cl_g.dkg_ncyl == 0) {
3442*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
3443*e8fb11a1Sshidokht 		return (EINVAL);
3444*e8fb11a1Sshidokht 	}
3445*e8fb11a1Sshidokht 
3446*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
3447*e8fb11a1Sshidokht 	cmlb_clear_efi(cl, tg_cookie);
3448*e8fb11a1Sshidokht 	ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
3449*e8fb11a1Sshidokht 	ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
3450*e8fb11a1Sshidokht 	(void) ddi_create_minor_node(CMLB_DEVINFO(cl), "h",
34513ccda647Slclee 	    S_IFBLK, (CMLBUNIT(dev) << CMLBUNIT_SHIFT) | WD_NODE,
3452*e8fb11a1Sshidokht 	    cl->cl_node_type, NULL);
3453*e8fb11a1Sshidokht 	(void) ddi_create_minor_node(CMLB_DEVINFO(cl), "h,raw",
34543ccda647Slclee 	    S_IFCHR, (CMLBUNIT(dev) << CMLBUNIT_SHIFT) | WD_NODE,
3455*e8fb11a1Sshidokht 	    cl->cl_node_type, NULL);
3456*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
34573ccda647Slclee 
3458*e8fb11a1Sshidokht 	if ((rval = cmlb_build_label_vtoc(cl, &user_vtoc)) == 0) {
3459*e8fb11a1Sshidokht 		if ((rval = cmlb_write_label(cl, tg_cookie)) == 0) {
3460*e8fb11a1Sshidokht 			if (cmlb_validate_geometry(cl, 1, 0, tg_cookie) != 0) {
3461*e8fb11a1Sshidokht 				cmlb_dbg(CMLB_ERROR, cl,
34623ccda647Slclee 				    "cmlb_dkio_set_vtoc: "
34633ccda647Slclee 				    "Failed validate geometry\n");
34643ccda647Slclee 			}
34653ccda647Slclee 		}
34663ccda647Slclee 	}
3467*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
34683ccda647Slclee 	return (rval);
34693ccda647Slclee }
34703ccda647Slclee 
34713ccda647Slclee 
34723ccda647Slclee /*
34733ccda647Slclee  *    Function: cmlb_build_label_vtoc
34743ccda647Slclee  *
34753ccda647Slclee  * Description: This routine updates the driver soft state current volume table
34763ccda647Slclee  *		of contents based on a user specified vtoc.
34773ccda647Slclee  *
3478*e8fb11a1Sshidokht  *   Arguments: cl - driver soft state (unit) structure
34793ccda647Slclee  *		user_vtoc - pointer to vtoc structure specifying vtoc to be used
34803ccda647Slclee  *			    to update the driver soft state.
34813ccda647Slclee  *
34823ccda647Slclee  * Return Code: 0
34833ccda647Slclee  *		EINVAL
34843ccda647Slclee  */
34853ccda647Slclee static int
3486*e8fb11a1Sshidokht cmlb_build_label_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc)
34873ccda647Slclee {
34883ccda647Slclee 	struct dk_map		*lmap;
34893ccda647Slclee 	struct partition	*vpart;
34903ccda647Slclee 	int			nblks;
34913ccda647Slclee #if defined(_SUNOS_VTOC_8)
34923ccda647Slclee 	int			ncyl;
34933ccda647Slclee 	struct dk_map2		*lpart;
34943ccda647Slclee #endif	/* defined(_SUNOS_VTOC_8) */
34953ccda647Slclee 	int			i;
34963ccda647Slclee 
3497*e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
34983ccda647Slclee 
34993ccda647Slclee 	/* Sanity-check the vtoc */
35003ccda647Slclee 	if (user_vtoc->v_sanity != VTOC_SANE ||
3501*e8fb11a1Sshidokht 	    user_vtoc->v_sectorsz != cl->cl_sys_blocksize ||
35023ccda647Slclee 	    user_vtoc->v_nparts != V_NUMPAR) {
3503*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_INFO,  cl,
35043ccda647Slclee 		    "cmlb_build_label_vtoc: vtoc not valid\n");
35053ccda647Slclee 		return (EINVAL);
35063ccda647Slclee 	}
35073ccda647Slclee 
3508*e8fb11a1Sshidokht 	nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead;
35093ccda647Slclee 	if (nblks == 0) {
3510*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_INFO,  cl,
35113ccda647Slclee 		    "cmlb_build_label_vtoc: geom nblks is 0\n");
35123ccda647Slclee 		return (EINVAL);
35133ccda647Slclee 	}
35143ccda647Slclee 
35153ccda647Slclee #if defined(_SUNOS_VTOC_8)
35163ccda647Slclee 	vpart = user_vtoc->v_part;
35173ccda647Slclee 	for (i = 0; i < V_NUMPAR; i++) {
35183ccda647Slclee 		if ((vpart->p_start % nblks) != 0) {
3519*e8fb11a1Sshidokht 			cmlb_dbg(CMLB_INFO,  cl,
35203ccda647Slclee 			    "cmlb_build_label_vtoc: p_start not multiply of"
35213ccda647Slclee 			    "nblks part %d p_start %d nblks %d\n", i,
35223ccda647Slclee 			    vpart->p_start, nblks);
35233ccda647Slclee 			return (EINVAL);
35243ccda647Slclee 		}
35253ccda647Slclee 		ncyl = vpart->p_start / nblks;
35263ccda647Slclee 		ncyl += vpart->p_size / nblks;
35273ccda647Slclee 		if ((vpart->p_size % nblks) != 0) {
35283ccda647Slclee 			ncyl++;
35293ccda647Slclee 		}
3530*e8fb11a1Sshidokht 		if (ncyl > (int)cl->cl_g.dkg_ncyl) {
3531*e8fb11a1Sshidokht 			cmlb_dbg(CMLB_INFO,  cl,
35323ccda647Slclee 			    "cmlb_build_label_vtoc: ncyl %d  > dkg_ncyl %d"
35333ccda647Slclee 			    "p_size %ld p_start %ld nblks %d  part number %d"
35343ccda647Slclee 			    "tag %d\n",
3535*e8fb11a1Sshidokht 			    ncyl, cl->cl_g.dkg_ncyl, vpart->p_size,
35363ccda647Slclee 			    vpart->p_start, nblks,
35373ccda647Slclee 			    i, vpart->p_tag);
35383ccda647Slclee 
35393ccda647Slclee 			return (EINVAL);
35403ccda647Slclee 		}
35413ccda647Slclee 		vpart++;
35423ccda647Slclee 	}
35433ccda647Slclee #endif	/* defined(_SUNOS_VTOC_8) */
35443ccda647Slclee 
35453ccda647Slclee 	/* Put appropriate vtoc structure fields into the disk label */
35463ccda647Slclee #if defined(_SUNOS_VTOC_16)
35473ccda647Slclee 	/*
35483ccda647Slclee 	 * The vtoc is always a 32bit data structure to maintain the
35493ccda647Slclee 	 * on-disk format. Convert "in place" instead of doing bcopy.
35503ccda647Slclee 	 */
3551*e8fb11a1Sshidokht 	vtoctovtoc32((*user_vtoc), (*((struct vtoc32 *)&(cl->cl_vtoc))));
35523ccda647Slclee 
35533ccda647Slclee 	/*
35543ccda647Slclee 	 * in the 16-slice vtoc, starting sectors are expressed in
35553ccda647Slclee 	 * numbers *relative* to the start of the Solaris fdisk partition.
35563ccda647Slclee 	 */
3557*e8fb11a1Sshidokht 	lmap = cl->cl_map;
35583ccda647Slclee 	vpart = user_vtoc->v_part;
35593ccda647Slclee 
35603ccda647Slclee 	for (i = 0; i < (int)user_vtoc->v_nparts; i++, lmap++, vpart++) {
35613ccda647Slclee 		lmap->dkl_cylno = vpart->p_start / nblks;
35623ccda647Slclee 		lmap->dkl_nblk = vpart->p_size;
35633ccda647Slclee 	}
35643ccda647Slclee 
35653ccda647Slclee #elif defined(_SUNOS_VTOC_8)
35663ccda647Slclee 
3567*e8fb11a1Sshidokht 	cl->cl_vtoc.v_bootinfo[0] = (uint32_t)user_vtoc->v_bootinfo[0];
3568*e8fb11a1Sshidokht 	cl->cl_vtoc.v_bootinfo[1] = (uint32_t)user_vtoc->v_bootinfo[1];
3569*e8fb11a1Sshidokht 	cl->cl_vtoc.v_bootinfo[2] = (uint32_t)user_vtoc->v_bootinfo[2];
35703ccda647Slclee 
3571*e8fb11a1Sshidokht 	cl->cl_vtoc.v_sanity = (uint32_t)user_vtoc->v_sanity;
3572*e8fb11a1Sshidokht 	cl->cl_vtoc.v_version = (uint32_t)user_vtoc->v_version;
35733ccda647Slclee 
3574*e8fb11a1Sshidokht 	bcopy(user_vtoc->v_volume, cl->cl_vtoc.v_volume, LEN_DKL_VVOL);
35753ccda647Slclee 
3576*e8fb11a1Sshidokht 	cl->cl_vtoc.v_nparts = user_vtoc->v_nparts;
35773ccda647Slclee 
35783ccda647Slclee 	for (i = 0; i < 10; i++)
3579*e8fb11a1Sshidokht 		cl->cl_vtoc.v_reserved[i] =  user_vtoc->v_reserved[i];
35803ccda647Slclee 
35813ccda647Slclee 	/*
35823ccda647Slclee 	 * Note the conversion from starting sector number
35833ccda647Slclee 	 * to starting cylinder number.
35843ccda647Slclee 	 * Return error if division results in a remainder.
35853ccda647Slclee 	 */
3586*e8fb11a1Sshidokht 	lmap = cl->cl_map;
3587*e8fb11a1Sshidokht 	lpart = cl->cl_vtoc.v_part;
35883ccda647Slclee 	vpart = user_vtoc->v_part;
35893ccda647Slclee 
35903ccda647Slclee 	for (i = 0; i < (int)user_vtoc->v_nparts; i++) {
35913ccda647Slclee 		lpart->p_tag  = vpart->p_tag;
35923ccda647Slclee 		lpart->p_flag = vpart->p_flag;
35933ccda647Slclee 		lmap->dkl_cylno = vpart->p_start / nblks;
35943ccda647Slclee 		lmap->dkl_nblk = vpart->p_size;
35953ccda647Slclee 
35963ccda647Slclee 		lmap++;
35973ccda647Slclee 		lpart++;
35983ccda647Slclee 		vpart++;
35993ccda647Slclee 
36003ccda647Slclee 		/* (4387723) */
36013ccda647Slclee #ifdef _LP64
36023ccda647Slclee 		if (user_vtoc->timestamp[i] > TIME32_MAX) {
3603*e8fb11a1Sshidokht 			cl->cl_vtoc.v_timestamp[i] = TIME32_MAX;
36043ccda647Slclee 		} else {
3605*e8fb11a1Sshidokht 			cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i];
36063ccda647Slclee 		}
36073ccda647Slclee #else
3608*e8fb11a1Sshidokht 		cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i];
36093ccda647Slclee #endif
36103ccda647Slclee 	}
36113ccda647Slclee 
3612*e8fb11a1Sshidokht 	bcopy(user_vtoc->v_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII);
36133ccda647Slclee #else
36143ccda647Slclee #error "No VTOC format defined."
36153ccda647Slclee #endif
36163ccda647Slclee 	return (0);
36173ccda647Slclee }
36183ccda647Slclee 
36193ccda647Slclee /*
36203ccda647Slclee  *    Function: cmlb_clear_efi
36213ccda647Slclee  *
36223ccda647Slclee  * Description: This routine clears all EFI labels.
36233ccda647Slclee  *
3624*e8fb11a1Sshidokht  *   Arguments:
3625*e8fb11a1Sshidokht  *	cl		 driver soft state (unit) structure
36263ccda647Slclee  *
3627*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
3628*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
36293ccda647Slclee  * Return Code: void
36303ccda647Slclee  */
36313ccda647Slclee static void
3632*e8fb11a1Sshidokht cmlb_clear_efi(struct cmlb_lun *cl, void *tg_cookie)
36333ccda647Slclee {
36343ccda647Slclee 	efi_gpt_t	*gpt;
36353ccda647Slclee 	diskaddr_t	cap;
36363ccda647Slclee 	int		rval;
36373ccda647Slclee 
3638*e8fb11a1Sshidokht 	ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
3639*e8fb11a1Sshidokht 
3640*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
3641*e8fb11a1Sshidokht 	cl->cl_reserved = -1;
3642*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
36433ccda647Slclee 
36443ccda647Slclee 	gpt = kmem_alloc(sizeof (efi_gpt_t), KM_SLEEP);
36453ccda647Slclee 
3646*e8fb11a1Sshidokht 	if (DK_TG_READ(cl, gpt, 1, DEV_BSIZE, tg_cookie) != 0) {
36473ccda647Slclee 		goto done;
36483ccda647Slclee 	}
36493ccda647Slclee 
36503ccda647Slclee 	cmlb_swap_efi_gpt(gpt);
36513ccda647Slclee 	rval = cmlb_validate_efi(gpt);
36523ccda647Slclee 	if (rval == 0) {
36533ccda647Slclee 		/* clear primary */
36543ccda647Slclee 		bzero(gpt, sizeof (efi_gpt_t));
3655*e8fb11a1Sshidokht 		if (rval = DK_TG_WRITE(cl, gpt, 1, EFI_LABEL_SIZE, tg_cookie)) {
3656*e8fb11a1Sshidokht 			cmlb_dbg(CMLB_INFO,  cl,
3657*e8fb11a1Sshidokht 			    "cmlb_clear_efi: clear primary label failed\n");
36583ccda647Slclee 		}
36593ccda647Slclee 	}
36603ccda647Slclee 	/* the backup */
3661*e8fb11a1Sshidokht 	rval = DK_TG_GETCAP(cl, &cap, tg_cookie);
36623ccda647Slclee 	if (rval) {
36633ccda647Slclee 		goto done;
36643ccda647Slclee 	}
36653ccda647Slclee 
3666*e8fb11a1Sshidokht 	if ((rval = DK_TG_READ(cl, gpt, cap - 1, EFI_LABEL_SIZE, tg_cookie))
3667*e8fb11a1Sshidokht 	    != 0) {
36683ccda647Slclee 		goto done;
36693ccda647Slclee 	}
36703ccda647Slclee 	cmlb_swap_efi_gpt(gpt);
36713ccda647Slclee 	rval = cmlb_validate_efi(gpt);
36723ccda647Slclee 	if (rval == 0) {
36733ccda647Slclee 		/* clear backup */
3674*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE,  cl,
36753ccda647Slclee 		    "cmlb_clear_efi clear backup@%lu\n", cap - 1);
36763ccda647Slclee 		bzero(gpt, sizeof (efi_gpt_t));
3677*e8fb11a1Sshidokht 		if ((rval = DK_TG_WRITE(cl,  gpt, cap - 1, EFI_LABEL_SIZE,
3678*e8fb11a1Sshidokht 		    tg_cookie))) {
3679*e8fb11a1Sshidokht 			cmlb_dbg(CMLB_INFO,  cl,
3680*e8fb11a1Sshidokht 			    "cmlb_clear_efi: clear backup label failed\n");
3681*e8fb11a1Sshidokht 		}
3682*e8fb11a1Sshidokht 	} else {
3683*e8fb11a1Sshidokht 		/*
3684*e8fb11a1Sshidokht 		 * Refer to comments related to off-by-1 at the
3685*e8fb11a1Sshidokht 		 * header of this file
3686*e8fb11a1Sshidokht 		 */
3687*e8fb11a1Sshidokht 		if ((rval = DK_TG_READ(cl, gpt, cap - 2,
3688*e8fb11a1Sshidokht 		    EFI_LABEL_SIZE, tg_cookie)) != 0) {
3689*e8fb11a1Sshidokht 			goto done;
3690*e8fb11a1Sshidokht 		}
3691*e8fb11a1Sshidokht 		cmlb_swap_efi_gpt(gpt);
3692*e8fb11a1Sshidokht 		rval = cmlb_validate_efi(gpt);
3693*e8fb11a1Sshidokht 		if (rval == 0) {
3694*e8fb11a1Sshidokht 			/* clear legacy backup EFI label */
3695*e8fb11a1Sshidokht 			cmlb_dbg(CMLB_TRACE,  cl,
3696*e8fb11a1Sshidokht 			    "cmlb_clear_efi clear legacy backup@%lu\n",
3697*e8fb11a1Sshidokht 			    cap - 2);
3698*e8fb11a1Sshidokht 			bzero(gpt, sizeof (efi_gpt_t));
3699*e8fb11a1Sshidokht 			if ((rval = DK_TG_WRITE(cl,  gpt, cap - 2,
3700*e8fb11a1Sshidokht 			    EFI_LABEL_SIZE, tg_cookie))) {
3701*e8fb11a1Sshidokht 				cmlb_dbg(CMLB_INFO,  cl,
3702*e8fb11a1Sshidokht 				"cmlb_clear_efi: clear legacy backup label "
3703*e8fb11a1Sshidokht 				"failed\n");
3704*e8fb11a1Sshidokht 			}
37053ccda647Slclee 		}
37063ccda647Slclee 	}
37073ccda647Slclee 
37083ccda647Slclee done:
37093ccda647Slclee 	kmem_free(gpt, sizeof (efi_gpt_t));
37103ccda647Slclee }
37113ccda647Slclee 
37123ccda647Slclee /*
37133ccda647Slclee  *    Function: cmlb_set_vtoc
37143ccda647Slclee  *
37153ccda647Slclee  * Description: This routine writes data to the appropriate positions
37163ccda647Slclee  *
3717*e8fb11a1Sshidokht  *   Arguments:
3718*e8fb11a1Sshidokht  *	cl		driver soft state (unit) structure
3719*e8fb11a1Sshidokht  *
3720*e8fb11a1Sshidokht  *	dkl		the data to be written
3721*e8fb11a1Sshidokht  *
3722*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
3723*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
37243ccda647Slclee  *
37253ccda647Slclee  * Return: void
37263ccda647Slclee  */
37273ccda647Slclee static int
3728*e8fb11a1Sshidokht cmlb_set_vtoc(struct cmlb_lun *cl, struct dk_label *dkl, void *tg_cookie)
37293ccda647Slclee {
37303ccda647Slclee 	uint_t	label_addr;
37313ccda647Slclee 	int	sec;
37323ccda647Slclee 	int	blk;
37333ccda647Slclee 	int	head;
37343ccda647Slclee 	int	cyl;
37353ccda647Slclee 	int	rval;
37363ccda647Slclee 
37373ccda647Slclee #if defined(__i386) || defined(__amd64)
3738*e8fb11a1Sshidokht 	label_addr = cl->cl_solaris_offset + DK_LABEL_LOC;
37393ccda647Slclee #else
37403ccda647Slclee 	/* Write the primary label at block 0 of the solaris partition. */
37413ccda647Slclee 	label_addr = 0;
37423ccda647Slclee #endif
37433ccda647Slclee 
3744*e8fb11a1Sshidokht 	rval = DK_TG_WRITE(cl, dkl, label_addr, cl->cl_sys_blocksize,
3745*e8fb11a1Sshidokht 	    tg_cookie);
37463ccda647Slclee 
37473ccda647Slclee 	if (rval != 0) {
37483ccda647Slclee 		return (rval);
37493ccda647Slclee 	}
37503ccda647Slclee 
37513ccda647Slclee 	/*
37523ccda647Slclee 	 * Calculate where the backup labels go.  They are always on
37533ccda647Slclee 	 * the last alternate cylinder, but some older drives put them
37543ccda647Slclee 	 * on head 2 instead of the last head.	They are always on the
37553ccda647Slclee 	 * first 5 odd sectors of the appropriate track.
37563ccda647Slclee 	 *
37573ccda647Slclee 	 * We have no choice at this point, but to believe that the
37583ccda647Slclee 	 * disk label is valid.	 Use the geometry of the disk
37593ccda647Slclee 	 * as described in the label.
37603ccda647Slclee 	 */
37613ccda647Slclee 	cyl  = dkl->dkl_ncyl  + dkl->dkl_acyl - 1;
37623ccda647Slclee 	head = dkl->dkl_nhead - 1;
37633ccda647Slclee 
37643ccda647Slclee 	/*
37653ccda647Slclee 	 * Write and verify the backup labels. Make sure we don't try to
37663ccda647Slclee 	 * write past the last cylinder.
37673ccda647Slclee 	 */
37683ccda647Slclee 	for (sec = 1; ((sec < 5 * 2 + 1) && (sec < dkl->dkl_nsect)); sec += 2) {
37693ccda647Slclee 		blk = (daddr_t)(
37703ccda647Slclee 		    (cyl * ((dkl->dkl_nhead * dkl->dkl_nsect) - dkl->dkl_apc)) +
37713ccda647Slclee 		    (head * dkl->dkl_nsect) + sec);
37723ccda647Slclee #if defined(__i386) || defined(__amd64)
3773*e8fb11a1Sshidokht 		blk += cl->cl_solaris_offset;
37743ccda647Slclee #endif
3775*e8fb11a1Sshidokht 		rval = DK_TG_WRITE(cl, dkl, blk, cl->cl_sys_blocksize,
3776*e8fb11a1Sshidokht 		    tg_cookie);
3777*e8fb11a1Sshidokht 		cmlb_dbg(CMLB_INFO,  cl,
37783ccda647Slclee 		"cmlb_set_vtoc: wrote backup label %d\n", blk);
37793ccda647Slclee 		if (rval != 0) {
37803ccda647Slclee 			goto exit;
37813ccda647Slclee 		}
37823ccda647Slclee 	}
37833ccda647Slclee exit:
37843ccda647Slclee 	return (rval);
37853ccda647Slclee }
37863ccda647Slclee 
37873ccda647Slclee /*
37883ccda647Slclee  *    Function: cmlb_clear_vtoc
37893ccda647Slclee  *
37903ccda647Slclee  * Description: This routine clears out the VTOC labels.
37913ccda647Slclee  *
3792*e8fb11a1Sshidokht  *   Arguments:
3793*e8fb11a1Sshidokht  *	cl		driver soft state (unit) structure
3794*e8fb11a1Sshidokht  *
3795*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
3796*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
37973ccda647Slclee  *
37983ccda647Slclee  * Return: void
37993ccda647Slclee  */
38003ccda647Slclee static void
3801*e8fb11a1Sshidokht cmlb_clear_vtoc(struct cmlb_lun *cl, void *tg_cookie)
38023ccda647Slclee {
38033ccda647Slclee 	struct dk_label		*dkl;
38043ccda647Slclee 
3805*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
38063ccda647Slclee 	dkl = kmem_zalloc(sizeof (struct dk_label), KM_SLEEP);
3807*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
38083ccda647Slclee 	/*
38093ccda647Slclee 	 * cmlb_set_vtoc uses these fields in order to figure out
38103ccda647Slclee 	 * where to overwrite the backup labels
38113ccda647Slclee 	 */
3812*e8fb11a1Sshidokht 	dkl->dkl_apc    = cl->cl_g.dkg_apc;
3813*e8fb11a1Sshidokht 	dkl->dkl_ncyl   = cl->cl_g.dkg_ncyl;
3814*e8fb11a1Sshidokht 	dkl->dkl_acyl   = cl->cl_g.dkg_acyl;
3815*e8fb11a1Sshidokht 	dkl->dkl_nhead  = cl->cl_g.dkg_nhead;
3816*e8fb11a1Sshidokht 	dkl->dkl_nsect  = cl->cl_g.dkg_nsect;
3817*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
3818*e8fb11a1Sshidokht 	(void) cmlb_set_vtoc(cl, dkl, tg_cookie);
38193ccda647Slclee 	kmem_free(dkl, sizeof (struct dk_label));
38203ccda647Slclee 
3821*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
38223ccda647Slclee }
38233ccda647Slclee 
38243ccda647Slclee /*
38253ccda647Slclee  *    Function: cmlb_write_label
38263ccda647Slclee  *
38273ccda647Slclee  * Description: This routine will validate and write the driver soft state vtoc
38283ccda647Slclee  *		contents to the device.
38293ccda647Slclee  *
3830*e8fb11a1Sshidokht  *   Arguments:
3831*e8fb11a1Sshidokht  *	cl		cmlb handle
3832*e8fb11a1Sshidokht  *
3833*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
3834*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
3835*e8fb11a1Sshidokht  *
38363ccda647Slclee  *
38373ccda647Slclee  * Return Code: the code returned by cmlb_send_scsi_cmd()
38383ccda647Slclee  *		0
38393ccda647Slclee  *		EINVAL
38403ccda647Slclee  *		ENXIO
38413ccda647Slclee  *		ENOMEM
38423ccda647Slclee  */
38433ccda647Slclee static int
3844*e8fb11a1Sshidokht cmlb_write_label(struct cmlb_lun *cl, void *tg_cookie)
38453ccda647Slclee {
38463ccda647Slclee 	struct dk_label	*dkl;
38473ccda647Slclee 	short		sum;
38483ccda647Slclee 	short		*sp;
38493ccda647Slclee 	int		i;
38503ccda647Slclee 	int		rval;
38513ccda647Slclee 
3852*e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
3853*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
38543ccda647Slclee 	dkl = kmem_zalloc(sizeof (struct dk_label), KM_SLEEP);
3855*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
3856*e8fb11a1Sshidokht 
3857*e8fb11a1Sshidokht 	bcopy(&cl->cl_vtoc, &dkl->dkl_vtoc, sizeof (struct dk_vtoc));
3858*e8fb11a1Sshidokht 	dkl->dkl_rpm	= cl->cl_g.dkg_rpm;
3859*e8fb11a1Sshidokht 	dkl->dkl_pcyl	= cl->cl_g.dkg_pcyl;
3860*e8fb11a1Sshidokht 	dkl->dkl_apc	= cl->cl_g.dkg_apc;
3861*e8fb11a1Sshidokht 	dkl->dkl_intrlv = cl->cl_g.dkg_intrlv;
3862*e8fb11a1Sshidokht 	dkl->dkl_ncyl	= cl->cl_g.dkg_ncyl;
3863*e8fb11a1Sshidokht 	dkl->dkl_acyl	= cl->cl_g.dkg_acyl;
3864*e8fb11a1Sshidokht 	dkl->dkl_nhead	= cl->cl_g.dkg_nhead;
3865*e8fb11a1Sshidokht 	dkl->dkl_nsect	= cl->cl_g.dkg_nsect;
38663ccda647Slclee 
38673ccda647Slclee #if defined(_SUNOS_VTOC_8)
3868*e8fb11a1Sshidokht 	dkl->dkl_obs1	= cl->cl_g.dkg_obs1;
3869*e8fb11a1Sshidokht 	dkl->dkl_obs2	= cl->cl_g.dkg_obs2;
3870*e8fb11a1Sshidokht 	dkl->dkl_obs3	= cl->cl_g.dkg_obs3;
38713ccda647Slclee 	for (i = 0; i < NDKMAP; i++) {
3872*e8fb11a1Sshidokht 		dkl->dkl_map[i].dkl_cylno = cl->cl_map[i].dkl_cylno;
3873*e8fb11a1Sshidokht 		dkl->dkl_map[i].dkl_nblk  = cl->cl_map[i].dkl_nblk;
38743ccda647Slclee 	}
3875*e8fb11a1Sshidokht 	bcopy(cl->cl_asciilabel, dkl->dkl_asciilabel, LEN_DKL_ASCII);
38763ccda647Slclee #elif defined(_SUNOS_VTOC_16)
3877*e8fb11a1Sshidokht 	dkl->dkl_skew	= cl->cl_dkg_skew;
38783ccda647Slclee #else
38793ccda647Slclee #error "No VTOC format defined."
38803ccda647Slclee #endif
38813ccda647Slclee 
38823ccda647Slclee 	dkl->dkl_magic			= DKL_MAGIC;
3883*e8fb11a1Sshidokht 	dkl->dkl_write_reinstruct	= cl->cl_g.dkg_write_reinstruct;
3884*e8fb11a1Sshidokht 	dkl->dkl_read_reinstruct	= cl->cl_g.dkg_read_reinstruct;
38853ccda647Slclee 
38863ccda647Slclee 	/* Construct checksum for the new disk label */
38873ccda647Slclee 	sum = 0;
38883ccda647Slclee 	sp = (short *)dkl;
38893ccda647Slclee 	i = sizeof (struct dk_label) / sizeof (short);
38903ccda647Slclee 	while (i--) {
38913ccda647Slclee 		sum ^= *sp++;
38923ccda647Slclee 	}
38933ccda647Slclee 	dkl->dkl_cksum = sum;
38943ccda647Slclee 
3895*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
38963ccda647Slclee 
3897*e8fb11a1Sshidokht 	rval = cmlb_set_vtoc(cl, dkl, tg_cookie);
38983ccda647Slclee exit:
38993ccda647Slclee 	kmem_free(dkl, sizeof (struct dk_label));
3900*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
39013ccda647Slclee 	return (rval);
39023ccda647Slclee }
39033ccda647Slclee 
39043ccda647Slclee static int
3905*e8fb11a1Sshidokht cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag,
3906*e8fb11a1Sshidokht     void *tg_cookie)
39073ccda647Slclee {
39083ccda647Slclee 	dk_efi_t	user_efi;
39093ccda647Slclee 	int		rval = 0;
39103ccda647Slclee 	void		*buffer;
3911*e8fb11a1Sshidokht 	diskaddr_t	tgt_lba;
39123ccda647Slclee 
39133ccda647Slclee 	if (ddi_copyin(arg, &user_efi, sizeof (dk_efi_t), flag))
39143ccda647Slclee 		return (EFAULT);
39153ccda647Slclee 
39163ccda647Slclee 	user_efi.dki_data = (void *)(uintptr_t)user_efi.dki_data_64;
39173ccda647Slclee 
39183ccda647Slclee 	buffer = kmem_alloc(user_efi.dki_length, KM_SLEEP);
39193ccda647Slclee 	if (ddi_copyin(user_efi.dki_data, buffer, user_efi.dki_length, flag)) {
39203ccda647Slclee 		rval = EFAULT;
39213ccda647Slclee 	} else {
39223ccda647Slclee 		/*
39233ccda647Slclee 		 * let's clear the vtoc labels and clear the softstate
39243ccda647Slclee 		 * vtoc.
39253ccda647Slclee 		 */
3926*e8fb11a1Sshidokht 		mutex_enter(CMLB_MUTEX(cl));
3927*e8fb11a1Sshidokht 		if (cl->cl_vtoc.v_sanity == VTOC_SANE) {
3928*e8fb11a1Sshidokht 			cmlb_dbg(CMLB_TRACE,  cl,
3929*e8fb11a1Sshidokht 			    "cmlb_dkio_set_efi: CLEAR VTOC\n");
3930*e8fb11a1Sshidokht 			if (cl->cl_vtoc_label_is_from_media)
3931*e8fb11a1Sshidokht 				cmlb_clear_vtoc(cl, tg_cookie);
3932*e8fb11a1Sshidokht 			bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
3933*e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
3934*e8fb11a1Sshidokht 			ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
3935*e8fb11a1Sshidokht 			ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
3936*e8fb11a1Sshidokht 			(void) ddi_create_minor_node(CMLB_DEVINFO(cl), "wd",
39373ccda647Slclee 			    S_IFBLK,
39383ccda647Slclee 			    (CMLBUNIT(dev) << CMLBUNIT_SHIFT) | WD_NODE,
3939*e8fb11a1Sshidokht 			    cl->cl_node_type, NULL);
3940*e8fb11a1Sshidokht 			(void) ddi_create_minor_node(CMLB_DEVINFO(cl), "wd,raw",
39413ccda647Slclee 			    S_IFCHR,
39423ccda647Slclee 			    (CMLBUNIT(dev) << CMLBUNIT_SHIFT) | WD_NODE,
3943*e8fb11a1Sshidokht 			    cl->cl_node_type, NULL);
39443ccda647Slclee 		} else
3945*e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
3946*e8fb11a1Sshidokht 
3947*e8fb11a1Sshidokht 		tgt_lba = user_efi.dki_lba;
3948*e8fb11a1Sshidokht 
3949*e8fb11a1Sshidokht 		mutex_enter(CMLB_MUTEX(cl));
3950*e8fb11a1Sshidokht 		if ((cmlb_check_update_blockcount(cl, tg_cookie) != 0) ||
3951*e8fb11a1Sshidokht 		    (cl->cl_tgt_blocksize == 0)) {
3952*e8fb11a1Sshidokht 			kmem_free(buffer, user_efi.dki_length);
3953*e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
3954*e8fb11a1Sshidokht 			return (EINVAL);
3955*e8fb11a1Sshidokht 		}
3956*e8fb11a1Sshidokht 		if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize)
3957*e8fb11a1Sshidokht 			tgt_lba = tgt_lba *
3958*e8fb11a1Sshidokht 			    cl->cl_tgt_blocksize / cl->cl_sys_blocksize;
3959*e8fb11a1Sshidokht 
3960*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
3961*e8fb11a1Sshidokht 		rval = DK_TG_WRITE(cl, buffer, tgt_lba, user_efi.dki_length,
3962*e8fb11a1Sshidokht 		    tg_cookie);
3963*e8fb11a1Sshidokht 
39643ccda647Slclee 		if (rval == 0) {
3965*e8fb11a1Sshidokht 			mutex_enter(CMLB_MUTEX(cl));
3966*e8fb11a1Sshidokht 			cl->cl_f_geometry_is_valid = FALSE;
3967*e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
39683ccda647Slclee 		}
39693ccda647Slclee 	}
39703ccda647Slclee 	kmem_free(buffer, user_efi.dki_length);
39713ccda647Slclee 	return (rval);
39723ccda647Slclee }
39733ccda647Slclee 
39743ccda647Slclee /*
39753ccda647Slclee  *    Function: cmlb_dkio_get_mboot
39763ccda647Slclee  *
39773ccda647Slclee  * Description: This routine is the driver entry point for handling user
39783ccda647Slclee  *		requests to get the current device mboot (DKIOCGMBOOT)
39793ccda647Slclee  *
39803ccda647Slclee  *   Arguments:
3981*e8fb11a1Sshidokht  *	arg		pointer to user provided mboot structure specifying
39823ccda647Slclee  *			the current mboot.
3983*e8fb11a1Sshidokht  *
3984*e8fb11a1Sshidokht  *	flag		this argument is a pass through to ddi_copyxxx()
3985*e8fb11a1Sshidokht  *			directly from the mode argument of ioctl().
3986*e8fb11a1Sshidokht  *
3987*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
3988*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
39893ccda647Slclee  *
39903ccda647Slclee  * Return Code: 0
39913ccda647Slclee  *		EINVAL
39923ccda647Slclee  *		EFAULT
39933ccda647Slclee  *		ENXIO
39943ccda647Slclee  */
39953ccda647Slclee static int
3996*e8fb11a1Sshidokht cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
39973ccda647Slclee {
39983ccda647Slclee 	struct mboot	*mboot;
39993ccda647Slclee 	int		rval;
40003ccda647Slclee 	size_t		buffer_size;
40013ccda647Slclee 
40023ccda647Slclee 
40033ccda647Slclee #if defined(_SUNOS_VTOC_8)
4004*e8fb11a1Sshidokht 	if ((!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) || (arg == NULL)) {
40053ccda647Slclee #elif defined(_SUNOS_VTOC_16)
40063ccda647Slclee 	if (arg == NULL) {
40073ccda647Slclee #endif
40083ccda647Slclee 		return (EINVAL);
40093ccda647Slclee 	}
40103ccda647Slclee 
40113ccda647Slclee 	/*
40123ccda647Slclee 	 * Read the mboot block, located at absolute block 0 on the target.
40133ccda647Slclee 	 */
40143ccda647Slclee 	buffer_size = sizeof (struct mboot);
40153ccda647Slclee 
4016*e8fb11a1Sshidokht 	cmlb_dbg(CMLB_TRACE,  cl,
40173ccda647Slclee 	    "cmlb_dkio_get_mboot: allocation size: 0x%x\n", buffer_size);
40183ccda647Slclee 
40193ccda647Slclee 	mboot = kmem_zalloc(buffer_size, KM_SLEEP);
4020*e8fb11a1Sshidokht 	if ((rval = DK_TG_READ(cl, mboot, 0, buffer_size, tg_cookie)) == 0) {
40213ccda647Slclee 		if (ddi_copyout(mboot, (void *)arg,
40223ccda647Slclee 		    sizeof (struct mboot), flag) != 0) {
40233ccda647Slclee 			rval = EFAULT;
40243ccda647Slclee 		}
40253ccda647Slclee 	}
40263ccda647Slclee 	kmem_free(mboot, buffer_size);
40273ccda647Slclee 	return (rval);
40283ccda647Slclee }
40293ccda647Slclee 
40303ccda647Slclee 
40313ccda647Slclee /*
40323ccda647Slclee  *    Function: cmlb_dkio_set_mboot
40333ccda647Slclee  *
40343ccda647Slclee  * Description: This routine is the driver entry point for handling user
40353ccda647Slclee  *		requests to validate and set the device master boot
40363ccda647Slclee  *		(DKIOCSMBOOT).
40373ccda647Slclee  *
40383ccda647Slclee  *   Arguments:
4039*e8fb11a1Sshidokht  *	arg		pointer to user provided mboot structure used to set the
40403ccda647Slclee  *			master boot.
4041*e8fb11a1Sshidokht  *
4042*e8fb11a1Sshidokht  *	flag		this argument is a pass through to ddi_copyxxx()
4043*e8fb11a1Sshidokht  *			directly from the mode argument of ioctl().
4044*e8fb11a1Sshidokht  *
4045*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
4046*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
40473ccda647Slclee  *
40483ccda647Slclee  * Return Code: 0
40493ccda647Slclee  *		EINVAL
40503ccda647Slclee  *		EFAULT
40513ccda647Slclee  *		ENXIO
40523ccda647Slclee  */
40533ccda647Slclee static int
4054*e8fb11a1Sshidokht cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
40553ccda647Slclee {
40563ccda647Slclee 	struct mboot	*mboot = NULL;
40573ccda647Slclee 	int		rval;
40583ccda647Slclee 	ushort_t	magic;
40593ccda647Slclee 
40603ccda647Slclee 
4061*e8fb11a1Sshidokht 	ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
40623ccda647Slclee 
40633ccda647Slclee #if defined(_SUNOS_VTOC_8)
4064*e8fb11a1Sshidokht 	if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
40653ccda647Slclee 		return (EINVAL);
40663ccda647Slclee 	}
40673ccda647Slclee #endif
40683ccda647Slclee 
40693ccda647Slclee 	if (arg == NULL) {
40703ccda647Slclee 		return (EINVAL);
40713ccda647Slclee 	}
40723ccda647Slclee 
40733ccda647Slclee 	mboot = kmem_zalloc(sizeof (struct mboot), KM_SLEEP);
40743ccda647Slclee 
40753ccda647Slclee 	if (ddi_copyin((const void *)arg, mboot,
40763ccda647Slclee 	    sizeof (struct mboot), flag) != 0) {
40773ccda647Slclee 		kmem_free(mboot, (size_t)(sizeof (struct mboot)));
40783ccda647Slclee 		return (EFAULT);
40793ccda647Slclee 	}
40803ccda647Slclee 
40813ccda647Slclee 	/* Is this really a master boot record? */
40823ccda647Slclee 	magic = LE_16(mboot->signature);
40833ccda647Slclee 	if (magic != MBB_MAGIC) {
40843ccda647Slclee 		kmem_free(mboot, (size_t)(sizeof (struct mboot)));
40853ccda647Slclee 		return (EINVAL);
40863ccda647Slclee 	}
40873ccda647Slclee 
4088*e8fb11a1Sshidokht 	rval = DK_TG_WRITE(cl, mboot, 0, cl->cl_sys_blocksize, tg_cookie);
40893ccda647Slclee 
4090*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
40913ccda647Slclee #if defined(__i386) || defined(__amd64)
40923ccda647Slclee 	if (rval == 0) {
40933ccda647Slclee 		/*
40943ccda647Slclee 		 * mboot has been written successfully.
40953ccda647Slclee 		 * update the fdisk and vtoc tables in memory
40963ccda647Slclee 		 */
4097*e8fb11a1Sshidokht 		rval = cmlb_update_fdisk_and_vtoc(cl, tg_cookie);
4098*e8fb11a1Sshidokht 		if ((cl->cl_f_geometry_is_valid == FALSE) || (rval != 0)) {
4099*e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
41003ccda647Slclee 			kmem_free(mboot, (size_t)(sizeof (struct mboot)));
41013ccda647Slclee 			return (rval);
41023ccda647Slclee 		}
41033ccda647Slclee 	}
4104*e8fb11a1Sshidokht 
4105*e8fb11a1Sshidokht #ifdef __lock_lint
4106*e8fb11a1Sshidokht 	cmlb_setup_default_geometry(cl, tg_cookie);
4107*e8fb11a1Sshidokht #endif
4108*e8fb11a1Sshidokht 
41093ccda647Slclee #else
41103ccda647Slclee 	if (rval == 0) {
41113ccda647Slclee 		/*
41123ccda647Slclee 		 * mboot has been written successfully.
41133ccda647Slclee 		 * set up the default geometry and VTOC
41143ccda647Slclee 		 */
4115*e8fb11a1Sshidokht 		if (cl->cl_blockcount <= DK_MAX_BLOCKS)
4116*e8fb11a1Sshidokht 			cmlb_setup_default_geometry(cl, tg_cookie);
41173ccda647Slclee 	}
41183ccda647Slclee #endif
4119*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
41203ccda647Slclee 	kmem_free(mboot, (size_t)(sizeof (struct mboot)));
41213ccda647Slclee 	return (rval);
41223ccda647Slclee }
41233ccda647Slclee 
41243ccda647Slclee 
41253ccda647Slclee /*
41263ccda647Slclee  *    Function: cmlb_setup_default_geometry
41273ccda647Slclee  *
41283ccda647Slclee  * Description: This local utility routine sets the default geometry as part of
41293ccda647Slclee  *		setting the device mboot.
41303ccda647Slclee  *
4131*e8fb11a1Sshidokht  *   Arguments:
4132*e8fb11a1Sshidokht  *	cl		driver soft state (unit) structure
4133*e8fb11a1Sshidokht  *
4134*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
4135*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
4136*e8fb11a1Sshidokht  *
41373ccda647Slclee  *
41383ccda647Slclee  * Note: This may be redundant with cmlb_build_default_label.
41393ccda647Slclee  */
41403ccda647Slclee static void
4141*e8fb11a1Sshidokht cmlb_setup_default_geometry(struct cmlb_lun *cl, void *tg_cookie)
41423ccda647Slclee {
41433ccda647Slclee 	struct cmlb_geom	pgeom;
41443ccda647Slclee 	struct cmlb_geom	*pgeomp = &pgeom;
41453ccda647Slclee 	int			ret;
41463ccda647Slclee 	int			geom_base_cap = 1;
41473ccda647Slclee 
41483ccda647Slclee 
4149*e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
41503ccda647Slclee 
41513ccda647Slclee 	/* zero out the soft state geometry and partition table. */
4152*e8fb11a1Sshidokht 	bzero(&cl->cl_g, sizeof (struct dk_geom));
4153*e8fb11a1Sshidokht 	bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
4154*e8fb11a1Sshidokht 	bzero(cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
41553ccda647Slclee 
41563ccda647Slclee 	/*
41573ccda647Slclee 	 * For the rpm, we use the minimum for the disk.
41583ccda647Slclee 	 * For the head, cyl and number of sector per track,
41593ccda647Slclee 	 * if the capacity <= 1GB, head = 64, sect = 32.
41603ccda647Slclee 	 * else head = 255, sect 63
41613ccda647Slclee 	 * Note: the capacity should be equal to C*H*S values.
41623ccda647Slclee 	 * This will cause some truncation of size due to
41633ccda647Slclee 	 * round off errors. For CD-ROMs, this truncation can
41643ccda647Slclee 	 * have adverse side effects, so returning ncyl and
41653ccda647Slclee 	 * nhead as 1. The nsect will overflow for most of
41663ccda647Slclee 	 * CD-ROMs as nsect is of type ushort.
41673ccda647Slclee 	 */
4168*e8fb11a1Sshidokht 	if (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) {
41693ccda647Slclee 		/*
41703ccda647Slclee 		 * newfs currently can not handle 255 ntracks for SPARC
41713ccda647Slclee 		 * so get the geometry from target driver instead of coming up
41723ccda647Slclee 		 * with one based on capacity.
41733ccda647Slclee 		 */
4174*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
4175*e8fb11a1Sshidokht 		ret = DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie);
4176*e8fb11a1Sshidokht 		mutex_enter(CMLB_MUTEX(cl));
41773ccda647Slclee 
41783ccda647Slclee 		if (ret  == 0) {
41793ccda647Slclee 			geom_base_cap = 0;
41803ccda647Slclee 		} else {
4181*e8fb11a1Sshidokht 			cmlb_dbg(CMLB_ERROR,  cl,
41823ccda647Slclee 			    "cmlb_setup_default_geometry: "
41833ccda647Slclee 			    "tg_getphygeom failed %d\n", ret);
41843ccda647Slclee 
41853ccda647Slclee 			/* do default setting, geometry based on capacity */
41863ccda647Slclee 		}
41873ccda647Slclee 	}
41883ccda647Slclee 
41893ccda647Slclee 	if (geom_base_cap) {
4190*e8fb11a1Sshidokht 		if (ISCD(cl)) {
4191*e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl = 1;
4192*e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 1;
4193*e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = cl->cl_blockcount;
4194*e8fb11a1Sshidokht 		} else if (cl->cl_blockcount <= 0x1000) {
41953ccda647Slclee 			/* Needed for unlabeled SCSI floppies. */
4196*e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 2;
4197*e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl = 80;
4198*e8fb11a1Sshidokht 			cl->cl_g.dkg_pcyl = 80;
4199*e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = cl->cl_blockcount / (2 * 80);
4200*e8fb11a1Sshidokht 		} else if (cl->cl_blockcount <= 0x200000) {
4201*e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 64;
4202*e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = 32;
4203*e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32);
42043ccda647Slclee 		} else {
4205*e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 255;
4206*e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = 63;
4207*e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl = cl->cl_blockcount / (255 * 63);
42083ccda647Slclee 		}
42093ccda647Slclee 
4210*e8fb11a1Sshidokht 		cl->cl_g.dkg_acyl = 0;
4211*e8fb11a1Sshidokht 		cl->cl_g.dkg_bcyl = 0;
4212*e8fb11a1Sshidokht 		cl->cl_g.dkg_intrlv = 1;
4213*e8fb11a1Sshidokht 		cl->cl_g.dkg_rpm = 200;
4214*e8fb11a1Sshidokht 		if (cl->cl_g.dkg_pcyl == 0)
4215*e8fb11a1Sshidokht 			cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl +
4216*e8fb11a1Sshidokht 			    cl->cl_g.dkg_acyl;
42173ccda647Slclee 	} else {
4218*e8fb11a1Sshidokht 		cl->cl_g.dkg_ncyl = (short)pgeomp->g_ncyl;
4219*e8fb11a1Sshidokht 		cl->cl_g.dkg_acyl = pgeomp->g_acyl;
4220*e8fb11a1Sshidokht 		cl->cl_g.dkg_nhead = pgeomp->g_nhead;
4221*e8fb11a1Sshidokht 		cl->cl_g.dkg_nsect = pgeomp->g_nsect;
4222*e8fb11a1Sshidokht 		cl->cl_g.dkg_intrlv = pgeomp->g_intrlv;
4223*e8fb11a1Sshidokht 		cl->cl_g.dkg_rpm = pgeomp->g_rpm;
4224*e8fb11a1Sshidokht 		cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl;
4225*e8fb11a1Sshidokht 	}
4226*e8fb11a1Sshidokht 
4227*e8fb11a1Sshidokht 	cl->cl_g.dkg_read_reinstruct = 0;
4228*e8fb11a1Sshidokht 	cl->cl_g.dkg_write_reinstruct = 0;
4229*e8fb11a1Sshidokht 	cl->cl_solaris_size = cl->cl_g.dkg_ncyl *
4230*e8fb11a1Sshidokht 	    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
4231*e8fb11a1Sshidokht 
4232*e8fb11a1Sshidokht 	cl->cl_map['a'-'a'].dkl_cylno = 0;
4233*e8fb11a1Sshidokht 	cl->cl_map['a'-'a'].dkl_nblk = cl->cl_solaris_size;
4234*e8fb11a1Sshidokht 
4235*e8fb11a1Sshidokht 	cl->cl_map['c'-'a'].dkl_cylno = 0;
4236*e8fb11a1Sshidokht 	cl->cl_map['c'-'a'].dkl_nblk = cl->cl_solaris_size;
4237*e8fb11a1Sshidokht 
4238*e8fb11a1Sshidokht 	cl->cl_vtoc.v_part[2].p_tag   = V_BACKUP;
4239*e8fb11a1Sshidokht 	cl->cl_vtoc.v_part[2].p_flag  = V_UNMNT;
4240*e8fb11a1Sshidokht 	cl->cl_vtoc.v_nparts = V_NUMPAR;
4241*e8fb11a1Sshidokht 	cl->cl_vtoc.v_version = V_VERSION;
4242*e8fb11a1Sshidokht 	(void) sprintf((char *)cl->cl_asciilabel, "DEFAULT cyl %d alt %d"
4243*e8fb11a1Sshidokht 	    " hd %d sec %d", cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
4244*e8fb11a1Sshidokht 	    cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
4245*e8fb11a1Sshidokht 
4246*e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = FALSE;
42473ccda647Slclee }
42483ccda647Slclee 
42493ccda647Slclee 
42503ccda647Slclee #if defined(__i386) || defined(__amd64)
42513ccda647Slclee /*
42523ccda647Slclee  *    Function: cmlb_update_fdisk_and_vtoc
42533ccda647Slclee  *
42543ccda647Slclee  * Description: This local utility routine updates the device fdisk and vtoc
42553ccda647Slclee  *		as part of setting the device mboot.
42563ccda647Slclee  *
4257*e8fb11a1Sshidokht  *   Arguments:
4258*e8fb11a1Sshidokht  *	cl		driver soft state (unit) structure
4259*e8fb11a1Sshidokht  *
4260*e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
4261*e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
4262*e8fb11a1Sshidokht  *
42633ccda647Slclee  *
42643ccda647Slclee  * Return Code: 0 for success or errno-type return code.
42653ccda647Slclee  *
42663ccda647Slclee  *    Note:x86: This looks like a duplicate of cmlb_validate_geometry(), but
42673ccda647Slclee  *		these did exist separately in x86 sd.c.
42683ccda647Slclee  */
42693ccda647Slclee static int
4270*e8fb11a1Sshidokht cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie)
42713ccda647Slclee {
42723ccda647Slclee 	int		count;
42733ccda647Slclee 	int		label_rc = 0;
42743ccda647Slclee 	int		fdisk_rval;
42753ccda647Slclee 	diskaddr_t	capacity;
42763ccda647Slclee 
4277*e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
42783ccda647Slclee 
4279*e8fb11a1Sshidokht 	if (cmlb_check_update_blockcount(cl, tg_cookie) != 0)
42803ccda647Slclee 		return (EINVAL);
42813ccda647Slclee 
42823ccda647Slclee #if defined(_SUNOS_VTOC_16)
42833ccda647Slclee 	/*
42843ccda647Slclee 	 * Set up the "whole disk" fdisk partition; this should always
42853ccda647Slclee 	 * exist, regardless of whether the disk contains an fdisk table
42863ccda647Slclee 	 * or vtoc.
42873ccda647Slclee 	 */
4288*e8fb11a1Sshidokht 	cl->cl_map[P0_RAW_DISK].dkl_cylno = 0;
4289*e8fb11a1Sshidokht 	cl->cl_map[P0_RAW_DISK].dkl_nblk = cl->cl_blockcount;
42903ccda647Slclee #endif	/* defined(_SUNOS_VTOC_16) */
42913ccda647Slclee 
42923ccda647Slclee 	/*
42933ccda647Slclee 	 * copy the lbasize and capacity so that if they're
4294*e8fb11a1Sshidokht 	 * reset while we're not holding the CMLB_MUTEX(cl), we will
4295*e8fb11a1Sshidokht 	 * continue to use valid values after the CMLB_MUTEX(cl) is
42963ccda647Slclee 	 * reacquired.
42973ccda647Slclee 	 */
4298*e8fb11a1Sshidokht 	capacity = cl->cl_blockcount;
42993ccda647Slclee 
43003ccda647Slclee 	/*
43013ccda647Slclee 	 * refresh the logical and physical geometry caches.
43023ccda647Slclee 	 * (data from mode sense format/rigid disk geometry pages,
43033ccda647Slclee 	 * and scsi_ifgetcap("geometry").
43043ccda647Slclee 	 */
4305*e8fb11a1Sshidokht 	cmlb_resync_geom_caches(cl, capacity, tg_cookie);
43063ccda647Slclee 
43073ccda647Slclee 	/*
4308*e8fb11a1Sshidokht 	 * Only DIRECT ACCESS devices will have Scl labels.
4309*e8fb11a1Sshidokht 	 * CD's supposedly have a Scl label, too
43103ccda647Slclee 	 */
4311*e8fb11a1Sshidokht 	if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) {
4312*e8fb11a1Sshidokht 		fdisk_rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
43133ccda647Slclee 		if (fdisk_rval != 0) {
4314*e8fb11a1Sshidokht 			ASSERT(mutex_owned(CMLB_MUTEX(cl)));
43153ccda647Slclee 			return (fdisk_rval);
43163ccda647Slclee 		}
43173ccda647Slclee 
4318*e8fb11a1Sshidokht 		if (cl->cl_solaris_size <= DK_LABEL_LOC) {
43193ccda647Slclee 			/*
43203ccda647Slclee 			 * Found fdisk table but no Solaris partition entry,
43213ccda647Slclee 			 * so don't call cmlb_uselabel() and don't create
43223ccda647Slclee 			 * a default label.
43233ccda647Slclee 			 */
43243ccda647Slclee 			label_rc = 0;
4325*e8fb11a1Sshidokht 			cl->cl_f_geometry_is_valid = TRUE;
43263ccda647Slclee 			goto no_solaris_partition;
43273ccda647Slclee 		}
43283ccda647Slclee 	} else if (capacity < 0) {
4329*e8fb11a1Sshidokht 		ASSERT(mutex_owned(CMLB_MUTEX(cl)));
43303ccda647Slclee 		return (EINVAL);
43313ccda647Slclee 	}
43323ccda647Slclee 
43333ccda647Slclee 	/*
43343ccda647Slclee 	 * For Removable media We reach here if we have found a
43353ccda647Slclee 	 * SOLARIS PARTITION.
4336*e8fb11a1Sshidokht 	 * If cl_f_geometry_is_valid is FALSE it indicates that the SOLARIS
43373ccda647Slclee 	 * PARTITION has changed from the previous one, hence we will setup a
43383ccda647Slclee 	 * default VTOC in this case.
43393ccda647Slclee 	 */
4340*e8fb11a1Sshidokht 	if (cl->cl_f_geometry_is_valid == FALSE) {
43413ccda647Slclee 		/* if we get here it is writable */
43423ccda647Slclee 		/* we are called from SMBOOT, and after a write of fdisk */
4343*e8fb11a1Sshidokht 		cmlb_build_default_label(cl, tg_cookie);
43443ccda647Slclee 		label_rc = 0;
43453ccda647Slclee 	}
43463ccda647Slclee 
43473ccda647Slclee no_solaris_partition:
43483ccda647Slclee 
43493ccda647Slclee #if defined(_SUNOS_VTOC_16)
43503ccda647Slclee 	/*
43513ccda647Slclee 	 * If we have valid geometry, set up the remaining fdisk partitions.
43523ccda647Slclee 	 * Note that dkl_cylno is not used for the fdisk map entries, so
43533ccda647Slclee 	 * we set it to an entirely bogus value.
43543ccda647Slclee 	 */
43553ccda647Slclee 	for (count = 0; count < FD_NUMPART; count++) {
4356*e8fb11a1Sshidokht 		cl->cl_map[FDISK_P1 + count].dkl_cylno = -1;
4357*e8fb11a1Sshidokht 		cl->cl_map[FDISK_P1 + count].dkl_nblk =
4358*e8fb11a1Sshidokht 		    cl->cl_fmap[count].fmap_nblk;
4359*e8fb11a1Sshidokht 		cl->cl_offset[FDISK_P1 + count] =
4360*e8fb11a1Sshidokht 		    cl->cl_fmap[count].fmap_start;
43613ccda647Slclee 	}
43623ccda647Slclee #endif
43633ccda647Slclee 
43643ccda647Slclee 	for (count = 0; count < NDKMAP; count++) {
43653ccda647Slclee #if defined(_SUNOS_VTOC_8)
4366*e8fb11a1Sshidokht 		struct dk_map *lp  = &cl->cl_map[count];
4367*e8fb11a1Sshidokht 		cl->cl_offset[count] =
4368*e8fb11a1Sshidokht 		    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
43693ccda647Slclee #elif defined(_SUNOS_VTOC_16)
4370*e8fb11a1Sshidokht 		struct dkl_partition *vp = &cl->cl_vtoc.v_part[count];
4371*e8fb11a1Sshidokht 		cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset;
43723ccda647Slclee #else
43733ccda647Slclee #error "No VTOC format defined."
43743ccda647Slclee #endif
43753ccda647Slclee 	}
43763ccda647Slclee 
4377*e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
43783ccda647Slclee 	return (label_rc);
43793ccda647Slclee }
43803ccda647Slclee #endif
43813ccda647Slclee 
43823ccda647Slclee #if defined(__i386) || defined(__amd64)
43833ccda647Slclee static int
4384*e8fb11a1Sshidokht cmlb_dkio_get_virtgeom(struct cmlb_lun *cl, caddr_t arg, int flag)
43853ccda647Slclee {
43863ccda647Slclee 	int err = 0;
43873ccda647Slclee 
43883ccda647Slclee 	/* Return the driver's notion of the media's logical geometry */
43893ccda647Slclee 	struct dk_geom	disk_geom;
43903ccda647Slclee 	struct dk_geom	*dkgp = &disk_geom;
43913ccda647Slclee 
4392*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
43933ccda647Slclee 	/*
43943ccda647Slclee 	 * If there is no HBA geometry available, or
43953ccda647Slclee 	 * if the HBA returned us something that doesn't
43963ccda647Slclee 	 * really fit into an Int 13/function 8 geometry
43973ccda647Slclee 	 * result, just fail the ioctl.  See PSARC 1998/313.
43983ccda647Slclee 	 */
4399*e8fb11a1Sshidokht 	if (cl->cl_lgeom.g_nhead == 0 ||
4400*e8fb11a1Sshidokht 	    cl->cl_lgeom.g_nsect == 0 ||
4401*e8fb11a1Sshidokht 	    cl->cl_lgeom.g_ncyl > 1024) {
4402*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
44033ccda647Slclee 		err = EINVAL;
44043ccda647Slclee 	} else {
4405*e8fb11a1Sshidokht 		dkgp->dkg_ncyl	= cl->cl_lgeom.g_ncyl;
4406*e8fb11a1Sshidokht 		dkgp->dkg_acyl	= cl->cl_lgeom.g_acyl;
44073ccda647Slclee 		dkgp->dkg_pcyl	= dkgp->dkg_ncyl + dkgp->dkg_acyl;
4408*e8fb11a1Sshidokht 		dkgp->dkg_nhead	= cl->cl_lgeom.g_nhead;
4409*e8fb11a1Sshidokht 		dkgp->dkg_nsect	= cl->cl_lgeom.g_nsect;
44103ccda647Slclee 
44113ccda647Slclee 		if (ddi_copyout(dkgp, (void *)arg,
44123ccda647Slclee 		    sizeof (struct dk_geom), flag)) {
4413*e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
44143ccda647Slclee 			err = EFAULT;
44153ccda647Slclee 		} else {
4416*e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
44173ccda647Slclee 			err = 0;
44183ccda647Slclee 		}
44193ccda647Slclee 	}
44203ccda647Slclee 	return (err);
44213ccda647Slclee }
44223ccda647Slclee #endif
44233ccda647Slclee 
44243ccda647Slclee #if defined(__i386) || defined(__amd64)
44253ccda647Slclee static int
4426*e8fb11a1Sshidokht cmlb_dkio_get_phygeom(struct cmlb_lun *cl, caddr_t  arg, int flag)
44273ccda647Slclee {
44283ccda647Slclee 	int err = 0;
4429*e8fb11a1Sshidokht 	diskaddr_t capacity;
44303ccda647Slclee 
44313ccda647Slclee 
44323ccda647Slclee 	/* Return the driver's notion of the media physical geometry */
44333ccda647Slclee 	struct dk_geom	disk_geom;
44343ccda647Slclee 	struct dk_geom	*dkgp = &disk_geom;
44353ccda647Slclee 
4436*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
44373ccda647Slclee 
4438*e8fb11a1Sshidokht 	if (cl->cl_g.dkg_nhead != 0 &&
4439*e8fb11a1Sshidokht 	    cl->cl_g.dkg_nsect != 0) {
44403ccda647Slclee 		/*
44413ccda647Slclee 		 * We succeeded in getting a geometry, but
44423ccda647Slclee 		 * right now it is being reported as just the
44433ccda647Slclee 		 * Solaris fdisk partition, just like for
44443ccda647Slclee 		 * DKIOCGGEOM. We need to change that to be
44453ccda647Slclee 		 * correct for the entire disk now.
44463ccda647Slclee 		 */
4447*e8fb11a1Sshidokht 		bcopy(&cl->cl_g, dkgp, sizeof (*dkgp));
44483ccda647Slclee 		dkgp->dkg_acyl = 0;
4449*e8fb11a1Sshidokht 		dkgp->dkg_ncyl = cl->cl_blockcount /
44503ccda647Slclee 		    (dkgp->dkg_nhead * dkgp->dkg_nsect);
44513ccda647Slclee 	} else {
44523ccda647Slclee 		bzero(dkgp, sizeof (struct dk_geom));
44533ccda647Slclee 		/*
44543ccda647Slclee 		 * This disk does not have a Solaris VTOC
44553ccda647Slclee 		 * so we must present a physical geometry
44563ccda647Slclee 		 * that will remain consistent regardless
44573ccda647Slclee 		 * of how the disk is used. This will ensure
44583ccda647Slclee 		 * that the geometry does not change regardless
44593ccda647Slclee 		 * of the fdisk partition type (ie. EFI, FAT32,
44603ccda647Slclee 		 * Solaris, etc).
44613ccda647Slclee 		 */
4462*e8fb11a1Sshidokht 		if (ISCD(cl)) {
4463*e8fb11a1Sshidokht 			dkgp->dkg_nhead = cl->cl_pgeom.g_nhead;
4464*e8fb11a1Sshidokht 			dkgp->dkg_nsect = cl->cl_pgeom.g_nsect;
4465*e8fb11a1Sshidokht 			dkgp->dkg_ncyl = cl->cl_pgeom.g_ncyl;
4466*e8fb11a1Sshidokht 			dkgp->dkg_acyl = cl->cl_pgeom.g_acyl;
44673ccda647Slclee 		} else {
4468*e8fb11a1Sshidokht 			/*
4469*e8fb11a1Sshidokht 			 * Invalid cl_blockcount can generate invalid
4470*e8fb11a1Sshidokht 			 * dk_geom and may result in division by zero
4471*e8fb11a1Sshidokht 			 * system failure. Should make sure blockcount
4472*e8fb11a1Sshidokht 			 * is valid before using it here.
4473*e8fb11a1Sshidokht 			 */
4474*e8fb11a1Sshidokht 			if (cl->cl_blockcount == 0) {
4475*e8fb11a1Sshidokht 				mutex_exit(CMLB_MUTEX(cl));
4476*e8fb11a1Sshidokht 				err = EIO;
4477*e8fb11a1Sshidokht 				return (err);
4478*e8fb11a1Sshidokht 			}
4479*e8fb11a1Sshidokht 			/*
4480*e8fb11a1Sshidokht 			 * Refer to comments related to off-by-1 at the
4481*e8fb11a1Sshidokht 			 * header of this file
4482*e8fb11a1Sshidokht 			 */
4483*e8fb11a1Sshidokht 			if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE)
4484*e8fb11a1Sshidokht 				capacity = cl->cl_blockcount - 1;
4485*e8fb11a1Sshidokht 			else
4486*e8fb11a1Sshidokht 				capacity = cl->cl_blockcount;
4487*e8fb11a1Sshidokht 
4488*e8fb11a1Sshidokht 			cmlb_convert_geometry(capacity, dkgp);
44893ccda647Slclee 			dkgp->dkg_acyl = 0;
4490*e8fb11a1Sshidokht 			dkgp->dkg_ncyl = capacity /
44913ccda647Slclee 			    (dkgp->dkg_nhead * dkgp->dkg_nsect);
44923ccda647Slclee 		}
44933ccda647Slclee 	}
44943ccda647Slclee 	dkgp->dkg_pcyl = dkgp->dkg_ncyl + dkgp->dkg_acyl;
44953ccda647Slclee 
44963ccda647Slclee 	if (ddi_copyout(dkgp, (void *)arg,
44973ccda647Slclee 	    sizeof (struct dk_geom), flag)) {
4498*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
44993ccda647Slclee 		err = EFAULT;
45003ccda647Slclee 	} else {
4501*e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
45023ccda647Slclee 		err = 0;
45033ccda647Slclee 	}
45043ccda647Slclee 	return (err);
45053ccda647Slclee }
45063ccda647Slclee #endif
45073ccda647Slclee 
45083ccda647Slclee #if defined(__i386) || defined(__amd64)
45093ccda647Slclee static int
4510*e8fb11a1Sshidokht cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t  arg, int flag)
45113ccda647Slclee {
45123ccda647Slclee 	int err = 0;
45133ccda647Slclee 
45143ccda647Slclee 	/*
45153ccda647Slclee 	 * Return parameters describing the selected disk slice.
45163ccda647Slclee 	 * Note: this ioctl is for the intel platform only
45173ccda647Slclee 	 */
45183ccda647Slclee 	int part;
45193ccda647Slclee 
45203ccda647Slclee 	part = CMLBPART(dev);
45213ccda647Slclee 
4522*e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
4523*e8fb11a1Sshidokht 	/* don't check cl_solaris_size for pN */
4524*e8fb11a1Sshidokht 	if (part < P0_RAW_DISK && cl->cl_solaris_size == 0) {
45253ccda647Slclee 		err = EIO;
45263ccda647Slclee 	} else {
45273ccda647Slclee 		struct part_info p;
45283ccda647Slclee 
4529*e8fb11a1Sshidokht 		p.p_start = (daddr_t)cl->cl_offset[part];
4530*e8fb11a1Sshidokht 		p.p_length = (int)cl->cl_map[part].dkl_nblk;
45313ccda647Slclee #ifdef _MULTI_DATAMODEL
45323ccda647Slclee 		switch (ddi_model_convert_from(flag & FMODELS)) {
45333ccda647Slclee 		case DDI_MODEL_ILP32:
45343ccda647Slclee 		{
45353ccda647Slclee 			struct part_info32 p32;
45363ccda647Slclee 
45373ccda647Slclee 			p32.p_start = (daddr32_t)p.p_start;
45383ccda647Slclee 			p32.p_length = p.p_length;
45393ccda647Slclee 			if (ddi_copyout(&p32, (void *)arg,
45403ccda647Slclee 			    sizeof (p32), flag))
45413ccda647Slclee 				err = EFAULT;
45423ccda647Slclee 			break;
45433ccda647Slclee 		}
45443ccda647Slclee 
45453ccda647Slclee 		case DDI_MODEL_NONE:
45463ccda647Slclee 		{
45473ccda647Slclee 			if (ddi_copyout(&p, (void *)arg, sizeof (p),
45483ccda647Slclee 			    flag))
45493ccda647Slclee 				err = EFAULT;
45503ccda647Slclee 			break;
45513ccda647Slclee 		}
45523ccda647Slclee 		}
45533ccda647Slclee #else /* ! _MULTI_DATAMODEL */
45543ccda647Slclee 		if (ddi_copyout(&p, (void *)arg, sizeof (p), flag))
45553ccda647Slclee 			err = EFAULT;
45563ccda647Slclee #endif /* _MULTI_DATAMODEL */
45573ccda647Slclee 	}
4558*e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
45593ccda647Slclee 	return (err);
45603ccda647Slclee }
45613ccda647Slclee #endif
4562