xref: /illumos-gate/usr/src/uts/common/io/cmlb.c (revision 7e70b434)
13ccda647Slclee /*
23ccda647Slclee  * CDDL HEADER START
33ccda647Slclee  *
43ccda647Slclee  * The contents of this file are subject to the terms of the
5e8fb11a1Sshidokht  * Common Development and Distribution License (the "License").
6e8fb11a1Sshidokht  * 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 /*
2348794f22SSriram Popuri  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
243ccda647Slclee  * Use is subject to license terms.
253ccda647Slclee  */
263ccda647Slclee 
273ccda647Slclee /*
283ccda647Slclee  * This module provides support for labeling operations for target
293ccda647Slclee  * drivers.
303ccda647Slclee  */
313ccda647Slclee 
323ccda647Slclee #include <sys/scsi/scsi.h>
333ccda647Slclee #include <sys/sunddi.h>
343ccda647Slclee #include <sys/dklabel.h>
353ccda647Slclee #include <sys/dkio.h>
363ccda647Slclee #include <sys/vtoc.h>
373ccda647Slclee #include <sys/dktp/fdisk.h>
383ccda647Slclee #include <sys/vtrace.h>
393ccda647Slclee #include <sys/efi_partition.h>
403ccda647Slclee #include <sys/cmlb.h>
413ccda647Slclee #include <sys/cmlb_impl.h>
42b9ccdc5aScth #include <sys/ddi_impldefs.h>
433ccda647Slclee 
443ccda647Slclee /*
453ccda647Slclee  * Driver minor node structure and data table
463ccda647Slclee  */
473ccda647Slclee struct driver_minor_data {
483ccda647Slclee 	char	*name;
493ccda647Slclee 	minor_t	minor;
503ccda647Slclee 	int	type;
513ccda647Slclee };
523ccda647Slclee 
533ccda647Slclee static struct driver_minor_data dk_minor_data[] = {
543ccda647Slclee 	{"a", 0, S_IFBLK},
553ccda647Slclee 	{"b", 1, S_IFBLK},
563ccda647Slclee 	{"c", 2, S_IFBLK},
573ccda647Slclee 	{"d", 3, S_IFBLK},
583ccda647Slclee 	{"e", 4, S_IFBLK},
593ccda647Slclee 	{"f", 5, S_IFBLK},
603ccda647Slclee 	{"g", 6, S_IFBLK},
613ccda647Slclee 	{"h", 7, S_IFBLK},
623ccda647Slclee #if defined(_SUNOS_VTOC_16)
633ccda647Slclee 	{"i", 8, S_IFBLK},
643ccda647Slclee 	{"j", 9, S_IFBLK},
653ccda647Slclee 	{"k", 10, S_IFBLK},
663ccda647Slclee 	{"l", 11, S_IFBLK},
673ccda647Slclee 	{"m", 12, S_IFBLK},
683ccda647Slclee 	{"n", 13, S_IFBLK},
693ccda647Slclee 	{"o", 14, S_IFBLK},
703ccda647Slclee 	{"p", 15, S_IFBLK},
713ccda647Slclee #endif			/* defined(_SUNOS_VTOC_16) */
723ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
733ccda647Slclee 	{"q", 16, S_IFBLK},
743ccda647Slclee 	{"r", 17, S_IFBLK},
753ccda647Slclee 	{"s", 18, S_IFBLK},
763ccda647Slclee 	{"t", 19, S_IFBLK},
773ccda647Slclee 	{"u", 20, S_IFBLK},
783ccda647Slclee #endif			/* defined(_FIRMWARE_NEEDS_FDISK) */
793ccda647Slclee 	{"a,raw", 0, S_IFCHR},
803ccda647Slclee 	{"b,raw", 1, S_IFCHR},
813ccda647Slclee 	{"c,raw", 2, S_IFCHR},
823ccda647Slclee 	{"d,raw", 3, S_IFCHR},
833ccda647Slclee 	{"e,raw", 4, S_IFCHR},
843ccda647Slclee 	{"f,raw", 5, S_IFCHR},
853ccda647Slclee 	{"g,raw", 6, S_IFCHR},
863ccda647Slclee 	{"h,raw", 7, S_IFCHR},
873ccda647Slclee #if defined(_SUNOS_VTOC_16)
883ccda647Slclee 	{"i,raw", 8, S_IFCHR},
893ccda647Slclee 	{"j,raw", 9, S_IFCHR},
903ccda647Slclee 	{"k,raw", 10, S_IFCHR},
913ccda647Slclee 	{"l,raw", 11, S_IFCHR},
923ccda647Slclee 	{"m,raw", 12, S_IFCHR},
933ccda647Slclee 	{"n,raw", 13, S_IFCHR},
943ccda647Slclee 	{"o,raw", 14, S_IFCHR},
953ccda647Slclee 	{"p,raw", 15, S_IFCHR},
963ccda647Slclee #endif			/* defined(_SUNOS_VTOC_16) */
973ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
983ccda647Slclee 	{"q,raw", 16, S_IFCHR},
993ccda647Slclee 	{"r,raw", 17, S_IFCHR},
1003ccda647Slclee 	{"s,raw", 18, S_IFCHR},
1013ccda647Slclee 	{"t,raw", 19, S_IFCHR},
1023ccda647Slclee 	{"u,raw", 20, S_IFCHR},
1033ccda647Slclee #endif			/* defined(_FIRMWARE_NEEDS_FDISK) */
1043ccda647Slclee 	{0}
1053ccda647Slclee };
1063ccda647Slclee 
1073ccda647Slclee static struct driver_minor_data dk_minor_data_efi[] = {
1083ccda647Slclee 	{"a", 0, S_IFBLK},
1093ccda647Slclee 	{"b", 1, S_IFBLK},
1103ccda647Slclee 	{"c", 2, S_IFBLK},
1113ccda647Slclee 	{"d", 3, S_IFBLK},
1123ccda647Slclee 	{"e", 4, S_IFBLK},
1133ccda647Slclee 	{"f", 5, S_IFBLK},
1143ccda647Slclee 	{"g", 6, S_IFBLK},
1153ccda647Slclee 	{"wd", 7, S_IFBLK},
116*7e70b434SShidokht Yadegari #if defined(_SUNOS_VTOC_16)
117*7e70b434SShidokht Yadegari 	{"i", 8, S_IFBLK},
118*7e70b434SShidokht Yadegari 	{"j", 9, S_IFBLK},
119*7e70b434SShidokht Yadegari 	{"k", 10, S_IFBLK},
120*7e70b434SShidokht Yadegari 	{"l", 11, S_IFBLK},
121*7e70b434SShidokht Yadegari 	{"m", 12, S_IFBLK},
122*7e70b434SShidokht Yadegari 	{"n", 13, S_IFBLK},
123*7e70b434SShidokht Yadegari 	{"o", 14, S_IFBLK},
124*7e70b434SShidokht Yadegari 	{"p", 15, S_IFBLK},
125*7e70b434SShidokht Yadegari #endif			/* defined(_SUNOS_VTOC_16) */
1263ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
1273ccda647Slclee 	{"q", 16, S_IFBLK},
1283ccda647Slclee 	{"r", 17, S_IFBLK},
1293ccda647Slclee 	{"s", 18, S_IFBLK},
1303ccda647Slclee 	{"t", 19, S_IFBLK},
1313ccda647Slclee 	{"u", 20, S_IFBLK},
1323ccda647Slclee #endif			/* defined(_FIRMWARE_NEEDS_FDISK) */
1333ccda647Slclee 	{"a,raw", 0, S_IFCHR},
1343ccda647Slclee 	{"b,raw", 1, S_IFCHR},
1353ccda647Slclee 	{"c,raw", 2, S_IFCHR},
1363ccda647Slclee 	{"d,raw", 3, S_IFCHR},
1373ccda647Slclee 	{"e,raw", 4, S_IFCHR},
1383ccda647Slclee 	{"f,raw", 5, S_IFCHR},
1393ccda647Slclee 	{"g,raw", 6, S_IFCHR},
1403ccda647Slclee 	{"wd,raw", 7, S_IFCHR},
141*7e70b434SShidokht Yadegari #if defined(_SUNOS_VTOC_16)
142*7e70b434SShidokht Yadegari 	{"i,raw", 8, S_IFCHR},
143*7e70b434SShidokht Yadegari 	{"j,raw", 9, S_IFCHR},
144*7e70b434SShidokht Yadegari 	{"k,raw", 10, S_IFCHR},
145*7e70b434SShidokht Yadegari 	{"l,raw", 11, S_IFCHR},
146*7e70b434SShidokht Yadegari 	{"m,raw", 12, S_IFCHR},
147*7e70b434SShidokht Yadegari 	{"n,raw", 13, S_IFCHR},
148*7e70b434SShidokht Yadegari 	{"o,raw", 14, S_IFCHR},
149*7e70b434SShidokht Yadegari 	{"p,raw", 15, S_IFCHR},
150*7e70b434SShidokht Yadegari #endif			/* defined(_SUNOS_VTOC_16) */
1513ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
1523ccda647Slclee 	{"q,raw", 16, S_IFCHR},
1533ccda647Slclee 	{"r,raw", 17, S_IFCHR},
1543ccda647Slclee 	{"s,raw", 18, S_IFCHR},
1553ccda647Slclee 	{"t,raw", 19, S_IFCHR},
1563ccda647Slclee 	{"u,raw", 20, S_IFCHR},
1573ccda647Slclee #endif			/* defined(_FIRMWARE_NEEDS_FDISK) */
1583ccda647Slclee 	{0}
1593ccda647Slclee };
1603ccda647Slclee 
161b9ccdc5aScth /*
162b9ccdc5aScth  * Declare the dynamic properties implemented in prop_op(9E) implementation
163b9ccdc5aScth  * that we want to have show up in a di_init(3DEVINFO) device tree snapshot
164b9ccdc5aScth  * of drivers that call cmlb_attach().
165b9ccdc5aScth  */
166b9ccdc5aScth static i_ddi_prop_dyn_t cmlb_prop_dyn[] = {
167b9ccdc5aScth 	{"Nblocks",		DDI_PROP_TYPE_INT64,	S_IFBLK},
168b9ccdc5aScth 	{"Size",		DDI_PROP_TYPE_INT64,	S_IFCHR},
169b9ccdc5aScth 	{"device-nblocks",	DDI_PROP_TYPE_INT64},
170b9ccdc5aScth 	{"device-blksize",	DDI_PROP_TYPE_INT},
171b9ccdc5aScth 	{NULL}
172b9ccdc5aScth };
1733ccda647Slclee 
17406bbe1e0Sedp /*
17506bbe1e0Sedp  * External kernel interfaces
17606bbe1e0Sedp  */
1773ccda647Slclee extern struct mod_ops mod_miscops;
1783ccda647Slclee 
17906bbe1e0Sedp extern int ddi_create_internal_pathname(dev_info_t *dip, char *name,
18006bbe1e0Sedp     int spec_type, minor_t minor_num);
18106bbe1e0Sedp 
1823ccda647Slclee /*
1833ccda647Slclee  * Global buffer and mutex for debug logging
1843ccda647Slclee  */
1853ccda647Slclee static char	cmlb_log_buffer[1024];
1863ccda647Slclee static kmutex_t	cmlb_log_mutex;
1873ccda647Slclee 
1883ccda647Slclee 
189e8fb11a1Sshidokht struct cmlb_lun *cmlb_debug_cl = NULL;
1903ccda647Slclee uint_t cmlb_level_mask = 0x0;
1913ccda647Slclee 
1923ccda647Slclee int cmlb_rot_delay = 4;	/* default rotational delay */
1933ccda647Slclee 
1943ccda647Slclee static struct modlmisc modlmisc = {
1953ccda647Slclee 	&mod_miscops,   /* Type of module */
196342440ecSPrasad Singamsetty 	"Common Labeling module"
1973ccda647Slclee };
1983ccda647Slclee 
1993ccda647Slclee static struct modlinkage modlinkage = {
2003ccda647Slclee 	MODREV_1, (void *)&modlmisc, NULL
2013ccda647Slclee };
2023ccda647Slclee 
2033ccda647Slclee /* Local function prototypes */
204e8fb11a1Sshidokht static dev_t cmlb_make_device(struct cmlb_lun *cl);
205e8fb11a1Sshidokht static int cmlb_validate_geometry(struct cmlb_lun *cl, int forcerevalid,
206e8fb11a1Sshidokht     int flags, void *tg_cookie);
207e8fb11a1Sshidokht static void cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity,
208e8fb11a1Sshidokht     void *tg_cookie);
209e8fb11a1Sshidokht static int cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity,
210e8fb11a1Sshidokht     void *tg_cookie);
2113ccda647Slclee static void cmlb_swap_efi_gpt(efi_gpt_t *e);
2123ccda647Slclee static void cmlb_swap_efi_gpe(int nparts, efi_gpe_t *p);
2133ccda647Slclee static int cmlb_validate_efi(efi_gpt_t *labp);
214e8fb11a1Sshidokht static int cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags,
215e8fb11a1Sshidokht     void *tg_cookie);
216e8fb11a1Sshidokht static void cmlb_build_default_label(struct cmlb_lun *cl, void *tg_cookie);
217e8fb11a1Sshidokht static int  cmlb_uselabel(struct cmlb_lun *cl,  struct dk_label *l, int flags);
218e8fb11a1Sshidokht #if defined(_SUNOS_VTOC_8)
219e8fb11a1Sshidokht static void cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc);
220e8fb11a1Sshidokht #endif
221e8fb11a1Sshidokht static int cmlb_build_label_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc);
222e8fb11a1Sshidokht static int cmlb_write_label(struct cmlb_lun *cl, void *tg_cookie);
223e8fb11a1Sshidokht static int cmlb_set_vtoc(struct cmlb_lun *cl, struct dk_label *dkl,
224e8fb11a1Sshidokht     void *tg_cookie);
225e8fb11a1Sshidokht static void cmlb_clear_efi(struct cmlb_lun *cl, void *tg_cookie);
226e8fb11a1Sshidokht static void cmlb_clear_vtoc(struct cmlb_lun *cl, void *tg_cookie);
227e8fb11a1Sshidokht static void cmlb_setup_default_geometry(struct cmlb_lun *cl, void *tg_cookie);
228e8fb11a1Sshidokht static int cmlb_create_minor_nodes(struct cmlb_lun *cl);
229e8fb11a1Sshidokht static int cmlb_check_update_blockcount(struct cmlb_lun *cl, void *tg_cookie);
230342440ecSPrasad Singamsetty static int cmlb_check_efi_mbr(uchar_t *buf, int *is_mbr);
2313ccda647Slclee 
2323ccda647Slclee #if defined(__i386) || defined(__amd64)
233e8fb11a1Sshidokht static int cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie);
2343ccda647Slclee #endif
2353ccda647Slclee 
2363ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
2373ccda647Slclee static int  cmlb_has_max_chs_vals(struct ipart *fdp);
2383ccda647Slclee #endif
2393ccda647Slclee 
2403ccda647Slclee #if defined(_SUNOS_VTOC_16)
241e8fb11a1Sshidokht static void cmlb_convert_geometry(diskaddr_t capacity, struct dk_geom *cl_g);
2423ccda647Slclee #endif
2433ccda647Slclee 
244e8fb11a1Sshidokht static int cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag,
245e8fb11a1Sshidokht     void *tg_cookie);
246e8fb11a1Sshidokht static int cmlb_dkio_set_geometry(struct cmlb_lun *cl, caddr_t arg, int flag);
247e8fb11a1Sshidokht static int cmlb_dkio_get_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
248e8fb11a1Sshidokht     void *tg_cookie);
249e8fb11a1Sshidokht static int cmlb_dkio_set_partition(struct cmlb_lun *cl, caddr_t arg, int flag);
250e8fb11a1Sshidokht static int cmlb_dkio_get_efi(struct cmlb_lun *cl, caddr_t arg, int flag,
251e8fb11a1Sshidokht     void *tg_cookie);
252e8fb11a1Sshidokht static int cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
253e8fb11a1Sshidokht     int flag, void *tg_cookie);
254e8fb11a1Sshidokht static int cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
255e8fb11a1Sshidokht     void *tg_cookie);
256342440ecSPrasad Singamsetty static int cmlb_dkio_get_extvtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
257342440ecSPrasad Singamsetty     void *tg_cookie);
258e8fb11a1Sshidokht static int cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
259e8fb11a1Sshidokht     int flag, void *tg_cookie);
260342440ecSPrasad Singamsetty static int cmlb_dkio_set_extvtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
261342440ecSPrasad Singamsetty     int flag, void *tg_cookie);
262e8fb11a1Sshidokht static int cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag,
263e8fb11a1Sshidokht     void *tg_cookie);
264e8fb11a1Sshidokht static int cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag,
265e8fb11a1Sshidokht     void *tg_cookie);
266e8fb11a1Sshidokht static int cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
267e8fb11a1Sshidokht     void *tg_cookie);
2683ccda647Slclee 
2693ccda647Slclee #if defined(__i386) || defined(__amd64)
270e8fb11a1Sshidokht static int cmlb_dkio_get_virtgeom(struct cmlb_lun *cl, caddr_t arg, int flag);
271e8fb11a1Sshidokht static int cmlb_dkio_get_phygeom(struct cmlb_lun *cl, caddr_t  arg, int flag);
272e8fb11a1Sshidokht static int cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
2733ccda647Slclee     int flag);
274342440ecSPrasad Singamsetty static int cmlb_dkio_extpartinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
275342440ecSPrasad Singamsetty     int flag);
2763ccda647Slclee #endif
2773ccda647Slclee 
278e8fb11a1Sshidokht static void cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...);
2793ccda647Slclee static void cmlb_v_log(dev_info_t *dev, char *label, uint_t level,
2803ccda647Slclee     const char *fmt, va_list ap);
2813ccda647Slclee static void cmlb_log(dev_info_t *dev, char *label, uint_t level,
2823ccda647Slclee     const char *fmt, ...);
2833ccda647Slclee 
2843ccda647Slclee int
2853ccda647Slclee _init(void)
2863ccda647Slclee {
2873ccda647Slclee 	mutex_init(&cmlb_log_mutex, NULL, MUTEX_DRIVER, NULL);
2883ccda647Slclee 	return (mod_install(&modlinkage));
2893ccda647Slclee }
2903ccda647Slclee 
2913ccda647Slclee int
2923ccda647Slclee _info(struct modinfo *modinfop)
2933ccda647Slclee {
2943ccda647Slclee 	return (mod_info(&modlinkage, modinfop));
2953ccda647Slclee }
2963ccda647Slclee 
2973ccda647Slclee int
2983ccda647Slclee _fini(void)
2993ccda647Slclee {
3003ccda647Slclee 	int err;
3013ccda647Slclee 
3023ccda647Slclee 	if ((err = mod_remove(&modlinkage)) != 0) {
3033ccda647Slclee 		return (err);
3043ccda647Slclee 	}
3053ccda647Slclee 
3063ccda647Slclee 	mutex_destroy(&cmlb_log_mutex);
3073ccda647Slclee 	return (err);
3083ccda647Slclee }
3093ccda647Slclee 
3103ccda647Slclee /*
3113ccda647Slclee  * cmlb_dbg is used for debugging to log additional info
3123ccda647Slclee  * Level of output is controlled via cmlb_level_mask setting.
3133ccda647Slclee  */
3143ccda647Slclee static void
315e8fb11a1Sshidokht cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...)
3163ccda647Slclee {
3173ccda647Slclee 	va_list		ap;
3183ccda647Slclee 	dev_info_t	*dev;
3193ccda647Slclee 	uint_t		level_mask = 0;
3203ccda647Slclee 
321e8fb11a1Sshidokht 	ASSERT(cl != NULL);
322e8fb11a1Sshidokht 	dev = CMLB_DEVINFO(cl);
3233ccda647Slclee 	ASSERT(dev != NULL);
3243ccda647Slclee 	/*
3253ccda647Slclee 	 * Filter messages based on the global component and level masks,
326e8fb11a1Sshidokht 	 * also print if cl matches the value of cmlb_debug_cl, or if
327e8fb11a1Sshidokht 	 * cmlb_debug_cl is set to NULL.
3283ccda647Slclee 	 */
3293ccda647Slclee 	if (comp & CMLB_TRACE)
3303ccda647Slclee 		level_mask |= CMLB_LOGMASK_TRACE;
3313ccda647Slclee 
3323ccda647Slclee 	if (comp & CMLB_INFO)
3333ccda647Slclee 		level_mask |= CMLB_LOGMASK_INFO;
3343ccda647Slclee 
3353ccda647Slclee 	if (comp & CMLB_ERROR)
3363ccda647Slclee 		level_mask |= CMLB_LOGMASK_ERROR;
3373ccda647Slclee 
3383ccda647Slclee 	if ((cmlb_level_mask & level_mask) &&
339e8fb11a1Sshidokht 	    ((cmlb_debug_cl == NULL) || (cmlb_debug_cl == cl))) {
3403ccda647Slclee 		va_start(ap, fmt);
341e8fb11a1Sshidokht 		cmlb_v_log(dev, CMLB_LABEL(cl), CE_CONT, fmt, ap);
3423ccda647Slclee 		va_end(ap);
3433ccda647Slclee 	}
3443ccda647Slclee }
3453ccda647Slclee 
3463ccda647Slclee /*
3473ccda647Slclee  * cmlb_log is basically a duplicate of scsi_log. It is redefined here
3483ccda647Slclee  * so that this module does not depend on scsi module.
3493ccda647Slclee  */
3503ccda647Slclee static void
3513ccda647Slclee cmlb_log(dev_info_t *dev, char *label, uint_t level, const char *fmt, ...)
3523ccda647Slclee {
3533ccda647Slclee 	va_list		ap;
3543ccda647Slclee 
3553ccda647Slclee 	va_start(ap, fmt);
3563ccda647Slclee 	cmlb_v_log(dev, label, level, fmt, ap);
3573ccda647Slclee 	va_end(ap);
3583ccda647Slclee }
3593ccda647Slclee 
3603ccda647Slclee static void
3613ccda647Slclee cmlb_v_log(dev_info_t *dev, char *label, uint_t level, const char *fmt,
3623ccda647Slclee     va_list ap)
3633ccda647Slclee {
3643ccda647Slclee 	static char 	name[256];
3653ccda647Slclee 	int 		log_only = 0;
3663ccda647Slclee 	int 		boot_only = 0;
3673ccda647Slclee 	int 		console_only = 0;
3683ccda647Slclee 
3693ccda647Slclee 	mutex_enter(&cmlb_log_mutex);
3703ccda647Slclee 
3713ccda647Slclee 	if (dev) {
3723ccda647Slclee 		if (level == CE_PANIC || level == CE_WARN ||
3733ccda647Slclee 		    level == CE_NOTE) {
3743ccda647Slclee 			(void) sprintf(name, "%s (%s%d):\n",
3753ccda647Slclee 			    ddi_pathname(dev, cmlb_log_buffer),
3763ccda647Slclee 			    label, ddi_get_instance(dev));
3773ccda647Slclee 		} else {
3783ccda647Slclee 			name[0] = '\0';
3793ccda647Slclee 		}
3803ccda647Slclee 	} else {
3813ccda647Slclee 		(void) sprintf(name, "%s:", label);
3823ccda647Slclee 	}
3833ccda647Slclee 
3843ccda647Slclee 	(void) vsprintf(cmlb_log_buffer, fmt, ap);
3853ccda647Slclee 
3863ccda647Slclee 	switch (cmlb_log_buffer[0]) {
3873ccda647Slclee 	case '!':
3883ccda647Slclee 		log_only = 1;
3893ccda647Slclee 		break;
3903ccda647Slclee 	case '?':
3913ccda647Slclee 		boot_only = 1;
3923ccda647Slclee 		break;
3933ccda647Slclee 	case '^':
3943ccda647Slclee 		console_only = 1;
3953ccda647Slclee 		break;
3963ccda647Slclee 	}
3973ccda647Slclee 
3983ccda647Slclee 	switch (level) {
3993ccda647Slclee 	case CE_NOTE:
4003ccda647Slclee 		level = CE_CONT;
4013ccda647Slclee 		/* FALLTHROUGH */
4023ccda647Slclee 	case CE_CONT:
4033ccda647Slclee 	case CE_WARN:
4043ccda647Slclee 	case CE_PANIC:
4053ccda647Slclee 		if (boot_only) {
4063ccda647Slclee 			cmn_err(level, "?%s\t%s", name, &cmlb_log_buffer[1]);
4073ccda647Slclee 		} else if (console_only) {
4083ccda647Slclee 			cmn_err(level, "^%s\t%s", name, &cmlb_log_buffer[1]);
4093ccda647Slclee 		} else if (log_only) {
4103ccda647Slclee 			cmn_err(level, "!%s\t%s", name, &cmlb_log_buffer[1]);
4113ccda647Slclee 		} else {
4123ccda647Slclee 			cmn_err(level, "%s\t%s", name, cmlb_log_buffer);
4133ccda647Slclee 		}
4143ccda647Slclee 		break;
4153ccda647Slclee 	case CE_IGNORE:
4163ccda647Slclee 		break;
4173ccda647Slclee 	default:
4183ccda647Slclee 		cmn_err(CE_CONT, "^DEBUG: %s\t%s", name, cmlb_log_buffer);
4193ccda647Slclee 		break;
4203ccda647Slclee 	}
4213ccda647Slclee 	mutex_exit(&cmlb_log_mutex);
4223ccda647Slclee }
4233ccda647Slclee 
4243ccda647Slclee 
4253ccda647Slclee /*
4263ccda647Slclee  * cmlb_alloc_handle:
4273ccda647Slclee  *
4283ccda647Slclee  *	Allocates a handle.
4293ccda647Slclee  *
4303ccda647Slclee  * Arguments:
4313ccda647Slclee  *	cmlbhandlep	pointer to handle
4323ccda647Slclee  *
4333ccda647Slclee  * Notes:
4343ccda647Slclee  *	Allocates a handle and stores the allocated handle in the area
4353ccda647Slclee  *	pointed to by cmlbhandlep
4363ccda647Slclee  *
4373ccda647Slclee  * Context:
4383ccda647Slclee  *	Kernel thread only (can sleep).
4393ccda647Slclee  */
4403ccda647Slclee void
4413ccda647Slclee cmlb_alloc_handle(cmlb_handle_t *cmlbhandlep)
4423ccda647Slclee {
443e8fb11a1Sshidokht 	struct cmlb_lun 	*cl;
4443ccda647Slclee 
445e8fb11a1Sshidokht 	cl = kmem_zalloc(sizeof (struct cmlb_lun), KM_SLEEP);
4463ccda647Slclee 	ASSERT(cmlbhandlep != NULL);
4473ccda647Slclee 
448e8fb11a1Sshidokht 	cl->cl_state = CMLB_INITED;
449e8fb11a1Sshidokht 	cl->cl_def_labeltype = CMLB_LABEL_UNDEF;
450e8fb11a1Sshidokht 	mutex_init(CMLB_MUTEX(cl), NULL, MUTEX_DRIVER, NULL);
4513ccda647Slclee 
452e8fb11a1Sshidokht 	*cmlbhandlep = (cmlb_handle_t)(cl);
4533ccda647Slclee }
4543ccda647Slclee 
4553ccda647Slclee /*
4563ccda647Slclee  * cmlb_free_handle
4573ccda647Slclee  *
4583ccda647Slclee  *	Frees handle.
4593ccda647Slclee  *
4603ccda647Slclee  * Arguments:
4613ccda647Slclee  *	cmlbhandlep	pointer to handle
4623ccda647Slclee  */
4633ccda647Slclee void
4643ccda647Slclee cmlb_free_handle(cmlb_handle_t *cmlbhandlep)
4653ccda647Slclee {
466e8fb11a1Sshidokht 	struct cmlb_lun 	*cl;
4673ccda647Slclee 
468e8fb11a1Sshidokht 	cl = (struct cmlb_lun *)*cmlbhandlep;
469e8fb11a1Sshidokht 	if (cl != NULL) {
470e8fb11a1Sshidokht 		mutex_destroy(CMLB_MUTEX(cl));
471e8fb11a1Sshidokht 		kmem_free(cl, sizeof (struct cmlb_lun));
4723ccda647Slclee 	}
4733ccda647Slclee 
4743ccda647Slclee }
4753ccda647Slclee 
4763ccda647Slclee /*
4773ccda647Slclee  * cmlb_attach:
4783ccda647Slclee  *
4793ccda647Slclee  *	Attach handle to device, create minor nodes for device.
4803ccda647Slclee  *
4813ccda647Slclee  * Arguments:
4823ccda647Slclee  * 	devi		pointer to device's dev_info structure.
4833ccda647Slclee  * 	tgopsp		pointer to array of functions cmlb can use to callback
4843ccda647Slclee  *			to target driver.
4853ccda647Slclee  *
4863ccda647Slclee  *	device_type	Peripheral device type as defined in
4873ccda647Slclee  *			scsi/generic/inquiry.h
4883ccda647Slclee  *
4893ccda647Slclee  *	is_removable	whether or not device is removable.
4903ccda647Slclee  *			0 non-removable, 1 removable.
4913ccda647Slclee  *
492e8fb11a1Sshidokht  *	is_hotpluggable	whether or not device is hotpluggable.
493e8fb11a1Sshidokht  *			0 non-hotpluggable, 1 hotpluggable.
494e8fb11a1Sshidokht  *
4953ccda647Slclee  *	node_type	minor node type (as used by ddi_create_minor_node)
4963ccda647Slclee  *
4973ccda647Slclee  *	alter_behavior
4983ccda647Slclee  *			bit flags:
4993ccda647Slclee  *
5003ccda647Slclee  *			CMLB_CREATE_ALTSLICE_VTOC_16_DTYPE_DIRECT: create
5013ccda647Slclee  *			an alternate slice for the default label, if
5023ccda647Slclee  *			device type is DTYPE_DIRECT an architectures default
5033ccda647Slclee  *			label type is VTOC16.
5043ccda647Slclee  *			Otherwise alternate slice will no be created.
5053ccda647Slclee  *
5063ccda647Slclee  *
5073ccda647Slclee  *			CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8: report a default
5083ccda647Slclee  *			geometry and label for DKIOCGGEOM and DKIOCGVTOC
5093ccda647Slclee  *			on architecture with VTOC8 label types.
5103ccda647Slclee  *
511e8fb11a1Sshidokht  * 			CMLB_OFF_BY_ONE: do the workaround for legacy off-by-
512e8fb11a1Sshidokht  *                      one bug in obtaining capacity (in sd):
513e8fb11a1Sshidokht  *			SCSI READ_CAPACITY command returns the LBA number of the
514e8fb11a1Sshidokht  *			last logical block, but sd once treated this number as
515e8fb11a1Sshidokht  *			disks' capacity on x86 platform. And LBAs are addressed
516e8fb11a1Sshidokht  *			based 0. So the last block was lost on x86 platform.
517e8fb11a1Sshidokht  *
518e8fb11a1Sshidokht  *			Now, we remove this workaround. In order for present sd
519e8fb11a1Sshidokht  *			driver to work with disks which are labeled/partitioned
520e8fb11a1Sshidokht  *			via previous sd, we add workaround as follows:
521e8fb11a1Sshidokht  *
522e8fb11a1Sshidokht  *			1) Locate backup EFI label: cmlb searches the next to
523e8fb11a1Sshidokht  *			   last
524e8fb11a1Sshidokht  *			   block for backup EFI label. If fails, it will
525e8fb11a1Sshidokht  *			   turn to the last block for backup EFI label;
526e8fb11a1Sshidokht  *
527e8fb11a1Sshidokht  *			2) Clear backup EFI label: cmlb first search the last
528e8fb11a1Sshidokht  *			   block for backup EFI label, and will search the
529e8fb11a1Sshidokht  *			   next to last block only if failed for the last
530e8fb11a1Sshidokht  *			   block.
531e8fb11a1Sshidokht  *
532e8fb11a1Sshidokht  *			3) Calculate geometry:refer to cmlb_convert_geometry()
533e8fb11a1Sshidokht  *			   If capacity increasing by 1 causes disks' capacity
534342440ecSPrasad Singamsetty  *			   to cross over the limits in geometry calculation,
535e8fb11a1Sshidokht  *			   geometry info will change. This will raise an issue:
536e8fb11a1Sshidokht  *			   In case that primary VTOC label is destroyed, format
537e8fb11a1Sshidokht  *			   commandline can restore it via backup VTOC labels.
538e8fb11a1Sshidokht  *			   And format locates backup VTOC labels by use of
539e8fb11a1Sshidokht  *			   geometry. So changing geometry will
540e8fb11a1Sshidokht  *			   prevent format from finding backup VTOC labels. To
541e8fb11a1Sshidokht  *			   eliminate this side effect for compatibility,
542e8fb11a1Sshidokht  *			   sd uses (capacity -1) to calculate geometry;
543e8fb11a1Sshidokht  *
544e8fb11a1Sshidokht  *			4) 1TB disks: some important data structures use
545e8fb11a1Sshidokht  *			   32-bit signed long/int (for example, daddr_t),
546e8fb11a1Sshidokht  *			   so that sd doesn't support a disk with capacity
547e8fb11a1Sshidokht  *			   larger than 1TB on 32-bit platform. However,
548e8fb11a1Sshidokht  *			   for exactly 1TB disk, it was treated as (1T - 512)B
549e8fb11a1Sshidokht  *			   in the past, and could have valid Solaris
550e8fb11a1Sshidokht  *			   partitions. To workaround this, if an exactly 1TB
551e8fb11a1Sshidokht  *			   disk has Solaris fdisk partition, it will be allowed
552e8fb11a1Sshidokht  *			   to work with sd.
553e8fb11a1Sshidokht  *
554e8fb11a1Sshidokht  *
5553ccda647Slclee  *
556843e1988Sjohnlev  *			CMLB_FAKE_LABEL_ONE_PARTITION: create s0 and s2 covering
557843e1988Sjohnlev  *			the entire disk, if there is no valid partition info.
558843e1988Sjohnlev  *			If there is a valid Solaris partition, s0 and s2 will
559843e1988Sjohnlev  *			only cover the entire Solaris partition.
560843e1988Sjohnlev  *
561843e1988Sjohnlev  *
5623ccda647Slclee  *	cmlbhandle	cmlb handle associated with device
5633ccda647Slclee  *
564e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
565e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
566e8fb11a1Sshidokht  *
5673ccda647Slclee  * Notes:
5683ccda647Slclee  *	Assumes a default label based on capacity for non-removable devices.
5693ccda647Slclee  *	If capacity > 1TB, EFI is assumed otherwise VTOC (default VTOC
5703ccda647Slclee  *	for the architecture).
5713ccda647Slclee  *
5723ccda647Slclee  *	For removable devices, default label type is assumed to be VTOC
5733ccda647Slclee  *	type. Create minor nodes based on a default label type.
5743ccda647Slclee  *	Label on the media is not validated.
5753ccda647Slclee  *	minor number consists of:
5763ccda647Slclee  *		if _SUNOS_VTOC_8 is defined
5773ccda647Slclee  *			lowest 3 bits is taken as partition number
5783ccda647Slclee  *			the rest is instance number
5793ccda647Slclee  *		if _SUNOS_VTOC_16 is defined
5803ccda647Slclee  *			lowest 6 bits is taken as partition number
5813ccda647Slclee  *			the rest is instance number
5823ccda647Slclee  *
5833ccda647Slclee  *
5843ccda647Slclee  * Return values:
5853ccda647Slclee  *	0 	Success
5863ccda647Slclee  * 	ENXIO 	creating minor nodes failed.
587e8fb11a1Sshidokht  *	EINVAL  invalid arg, unsupported tg_ops version
5883ccda647Slclee  */
5893ccda647Slclee int
5903ccda647Slclee cmlb_attach(dev_info_t *devi, cmlb_tg_ops_t *tgopsp, int device_type,
591e8fb11a1Sshidokht     int is_removable, int is_hotpluggable, char *node_type,
592e8fb11a1Sshidokht     int alter_behavior, cmlb_handle_t cmlbhandle, void *tg_cookie)
5933ccda647Slclee {
5943ccda647Slclee 
595e8fb11a1Sshidokht 	struct cmlb_lun	*cl = (struct cmlb_lun *)cmlbhandle;
5963ccda647Slclee 	diskaddr_t	cap;
5973ccda647Slclee 	int		status;
5983ccda647Slclee 
599e8fb11a1Sshidokht 	if (tgopsp->tg_version < TG_DK_OPS_VERSION_1)
600e8fb11a1Sshidokht 		return (EINVAL);
6013ccda647Slclee 
602e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
603e8fb11a1Sshidokht 
604e8fb11a1Sshidokht 	CMLB_DEVINFO(cl) = devi;
605e8fb11a1Sshidokht 	cl->cmlb_tg_ops = tgopsp;
606e8fb11a1Sshidokht 	cl->cl_device_type = device_type;
607e8fb11a1Sshidokht 	cl->cl_is_removable = is_removable;
608e8fb11a1Sshidokht 	cl->cl_is_hotpluggable = is_hotpluggable;
609e8fb11a1Sshidokht 	cl->cl_node_type = node_type;
610e8fb11a1Sshidokht 	cl->cl_sys_blocksize = DEV_BSIZE;
611e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = FALSE;
612e8fb11a1Sshidokht 	cl->cl_def_labeltype = CMLB_LABEL_VTOC;
613e8fb11a1Sshidokht 	cl->cl_alter_behavior = alter_behavior;
614e8fb11a1Sshidokht 	cl->cl_reserved = -1;
615342440ecSPrasad Singamsetty 	cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
6163ccda647Slclee 
617342440ecSPrasad Singamsetty 	if (is_removable == 0) {
618e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
619e8fb11a1Sshidokht 		status = DK_TG_GETCAP(cl, &cap, tg_cookie);
620e8fb11a1Sshidokht 		mutex_enter(CMLB_MUTEX(cl));
621342440ecSPrasad Singamsetty 		if (status == 0 && cap > CMLB_EXTVTOC_LIMIT) {
622342440ecSPrasad Singamsetty 			/* set default EFI if > 2TB */
623e8fb11a1Sshidokht 			cl->cl_def_labeltype = CMLB_LABEL_EFI;
6243ccda647Slclee 		}
6253ccda647Slclee 	}
6263ccda647Slclee 
6273ccda647Slclee 	/* create minor nodes based on default label type */
628e8fb11a1Sshidokht 	cl->cl_last_labeltype = CMLB_LABEL_UNDEF;
629e8fb11a1Sshidokht 	cl->cl_cur_labeltype = CMLB_LABEL_UNDEF;
6303ccda647Slclee 
631e8fb11a1Sshidokht 	if (cmlb_create_minor_nodes(cl) != 0) {
632e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
6333ccda647Slclee 		return (ENXIO);
6343ccda647Slclee 	}
6353ccda647Slclee 
636b9ccdc5aScth 	/* Define the dynamic properties for devinfo spapshots. */
637b9ccdc5aScth 	i_ddi_prop_dyn_driver_set(CMLB_DEVINFO(cl), cmlb_prop_dyn);
638b9ccdc5aScth 
639e8fb11a1Sshidokht 	cl->cl_state = CMLB_ATTACHED;
6403ccda647Slclee 
641e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
6423ccda647Slclee 	return (0);
6433ccda647Slclee }
6443ccda647Slclee 
6453ccda647Slclee /*
6463ccda647Slclee  * cmlb_detach:
6473ccda647Slclee  *
6483ccda647Slclee  * Invalidate in-core labeling data and remove all minor nodes for
6493ccda647Slclee  * the device associate with handle.
6503ccda647Slclee  *
6513ccda647Slclee  * Arguments:
6523ccda647Slclee  *	cmlbhandle	cmlb handle associated with device.
6533ccda647Slclee  *
654e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
655e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
656e8fb11a1Sshidokht  *
6573ccda647Slclee  */
658e8fb11a1Sshidokht /*ARGSUSED1*/
6593ccda647Slclee void
660e8fb11a1Sshidokht cmlb_detach(cmlb_handle_t cmlbhandle, void *tg_cookie)
6613ccda647Slclee {
662e8fb11a1Sshidokht 	struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
663e8fb11a1Sshidokht 
664e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
665e8fb11a1Sshidokht 	cl->cl_def_labeltype = CMLB_LABEL_UNDEF;
666e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = FALSE;
667e8fb11a1Sshidokht 	ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
668b9ccdc5aScth 	i_ddi_prop_dyn_driver_set(CMLB_DEVINFO(cl), NULL);
669e8fb11a1Sshidokht 	cl->cl_state = CMLB_INITED;
670e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
6713ccda647Slclee }
6723ccda647Slclee 
6733ccda647Slclee /*
6743ccda647Slclee  * cmlb_validate:
6753ccda647Slclee  *
6763ccda647Slclee  *	Validates label.
6773ccda647Slclee  *
6783ccda647Slclee  * Arguments
6793ccda647Slclee  *	cmlbhandle	cmlb handle associated with device.
6803ccda647Slclee  *
681e8fb11a1Sshidokht  *	flags		operation flags. used for verbosity control
682e8fb11a1Sshidokht  *
683e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
684e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
685e8fb11a1Sshidokht  *
686e8fb11a1Sshidokht  *
6873ccda647Slclee  * Notes:
6883ccda647Slclee  *	If new label type is different from the current, adjust minor nodes
6893ccda647Slclee  *	accordingly.
6903ccda647Slclee  *
6913ccda647Slclee  * Return values:
6923ccda647Slclee  *	0		success
6933ccda647Slclee  *			Note: having fdisk but no solaris partition is assumed
6943ccda647Slclee  *			success.
6953ccda647Slclee  *
6963ccda647Slclee  *	ENOMEM		memory allocation failed
6973ccda647Slclee  *	EIO		i/o errors during read or get capacity
6983ccda647Slclee  * 	EACCESS		reservation conflicts
6993ccda647Slclee  * 	EINVAL		label was corrupt, or no default label was assumed
7003ccda647Slclee  *	ENXIO		invalid handle
7013ccda647Slclee  */
7023ccda647Slclee int
703e8fb11a1Sshidokht cmlb_validate(cmlb_handle_t cmlbhandle, int flags, void *tg_cookie)
7043ccda647Slclee {
705e8fb11a1Sshidokht 	struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
7063ccda647Slclee 	int 		rval;
7073ccda647Slclee 	int  		ret = 0;
7083ccda647Slclee 
7093ccda647Slclee 	/*
710e8fb11a1Sshidokht 	 * Temp work-around checking cl for NULL since there is a bug
7113ccda647Slclee 	 * in sd_detach calling this routine from taskq_dispatch
7123ccda647Slclee 	 * inited function.
7133ccda647Slclee 	 */
714e8fb11a1Sshidokht 	if (cl == NULL)
7153ccda647Slclee 		return (ENXIO);
7163ccda647Slclee 
717e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
718e8fb11a1Sshidokht 	if (cl->cl_state < CMLB_ATTACHED) {
719e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
7203ccda647Slclee 		return (ENXIO);
7213ccda647Slclee 	}
7223ccda647Slclee 
723e8fb11a1Sshidokht 	rval = cmlb_validate_geometry((struct cmlb_lun *)cmlbhandle, 1,
724e8fb11a1Sshidokht 	    flags, tg_cookie);
7253ccda647Slclee 
7263ccda647Slclee 	if (rval == ENOTSUP) {
727e8fb11a1Sshidokht 		if (cl->cl_f_geometry_is_valid == TRUE) {
728e8fb11a1Sshidokht 			cl->cl_cur_labeltype = CMLB_LABEL_EFI;
7293ccda647Slclee 			ret = 0;
7303ccda647Slclee 		} else {
7313ccda647Slclee 			ret = EINVAL;
7323ccda647Slclee 		}
7333ccda647Slclee 	} else {
7343ccda647Slclee 		ret = rval;
7353ccda647Slclee 		if (ret == 0)
736e8fb11a1Sshidokht 			cl->cl_cur_labeltype = CMLB_LABEL_VTOC;
7373ccda647Slclee 	}
7383ccda647Slclee 
7393ccda647Slclee 	if (ret == 0)
740e8fb11a1Sshidokht 		(void) cmlb_create_minor_nodes(cl);
7413ccda647Slclee 
742e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
7433ccda647Slclee 	return (ret);
7443ccda647Slclee }
7453ccda647Slclee 
7463ccda647Slclee /*
7473ccda647Slclee  * cmlb_invalidate:
7483ccda647Slclee  *	Invalidate in core label data
7493ccda647Slclee  *
7503ccda647Slclee  * Arguments:
7513ccda647Slclee  *	cmlbhandle	cmlb handle associated with device.
752e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
753e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
7543ccda647Slclee  */
755e8fb11a1Sshidokht /*ARGSUSED1*/
7563ccda647Slclee void
757e8fb11a1Sshidokht cmlb_invalidate(cmlb_handle_t cmlbhandle, void *tg_cookie)
7583ccda647Slclee {
759e8fb11a1Sshidokht 	struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
7603ccda647Slclee 
761e8fb11a1Sshidokht 	if (cl == NULL)
7623ccda647Slclee 		return;
7633ccda647Slclee 
764e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
765e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = FALSE;
766e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
767e8fb11a1Sshidokht }
768e8fb11a1Sshidokht 
769e8fb11a1Sshidokht /*
770e8fb11a1Sshidokht  * cmlb_is_valid
771e8fb11a1Sshidokht  * 	Get status on whether the incore label/geom data is valid
772e8fb11a1Sshidokht  *
773e8fb11a1Sshidokht  * Arguments:
774e8fb11a1Sshidokht  *	cmlbhandle      cmlb handle associated with device.
775e8fb11a1Sshidokht  *
776e8fb11a1Sshidokht  * Return values:
777e8fb11a1Sshidokht  *	TRUE if incore label/geom data is valid.
778e8fb11a1Sshidokht  *	FALSE otherwise.
779e8fb11a1Sshidokht  *
780e8fb11a1Sshidokht  */
781e8fb11a1Sshidokht 
782e8fb11a1Sshidokht 
783e8fb11a1Sshidokht int
784e8fb11a1Sshidokht cmlb_is_valid(cmlb_handle_t cmlbhandle)
785e8fb11a1Sshidokht {
786e8fb11a1Sshidokht 	struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
787e8fb11a1Sshidokht 
788e8fb11a1Sshidokht 	if (cmlbhandle == NULL)
789e8fb11a1Sshidokht 		return (FALSE);
790e8fb11a1Sshidokht 
791e8fb11a1Sshidokht 	return (cl->cl_f_geometry_is_valid);
792e8fb11a1Sshidokht 
7933ccda647Slclee }
7943ccda647Slclee 
795e8fb11a1Sshidokht 
796e8fb11a1Sshidokht 
7973ccda647Slclee /*
7983ccda647Slclee  * cmlb_close:
7993ccda647Slclee  *
8003ccda647Slclee  * Close the device, revert to a default label minor node for the device,
8013ccda647Slclee  * if it is removable.
8023ccda647Slclee  *
8033ccda647Slclee  * Arguments:
8043ccda647Slclee  *	cmlbhandle	cmlb handle associated with device.
8053ccda647Slclee  *
806e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
807e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
8083ccda647Slclee  * Return values:
8093ccda647Slclee  *	0	Success
8103ccda647Slclee  * 	ENXIO	Re-creating minor node failed.
8113ccda647Slclee  */
812e8fb11a1Sshidokht /*ARGSUSED1*/
8133ccda647Slclee int
814e8fb11a1Sshidokht cmlb_close(cmlb_handle_t cmlbhandle, void *tg_cookie)
8153ccda647Slclee {
816e8fb11a1Sshidokht 	struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
8173ccda647Slclee 
818e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
819e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = FALSE;
8203ccda647Slclee 
8213ccda647Slclee 	/* revert to default minor node for this device */
822e8fb11a1Sshidokht 	if (ISREMOVABLE(cl)) {
823e8fb11a1Sshidokht 		cl->cl_cur_labeltype = CMLB_LABEL_UNDEF;
824e8fb11a1Sshidokht 		(void) cmlb_create_minor_nodes(cl);
8253ccda647Slclee 	}
8263ccda647Slclee 
827e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
8283ccda647Slclee 	return (0);
8293ccda647Slclee }
8303ccda647Slclee 
8313ccda647Slclee /*
8323ccda647Slclee  * cmlb_get_devid_block:
8333ccda647Slclee  *	 get the block number where device id is stored.
8343ccda647Slclee  *
8353ccda647Slclee  * Arguments:
8363ccda647Slclee  *	cmlbhandle	cmlb handle associated with device.
8373ccda647Slclee  *	devidblockp	pointer to block number.
838e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
839e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
8403ccda647Slclee  *
8413ccda647Slclee  * Notes:
8423ccda647Slclee  *	It stores the block number of device id in the area pointed to
8433ccda647Slclee  *	by devidblockp.
8443ccda647Slclee  * 	with the block number of device id.
8453ccda647Slclee  *
8463ccda647Slclee  * Return values:
8473ccda647Slclee  *	0	success
8483ccda647Slclee  *	EINVAL 	device id does not apply to current label type.
8493ccda647Slclee  */
850e8fb11a1Sshidokht /*ARGSUSED2*/
8513ccda647Slclee int
852e8fb11a1Sshidokht cmlb_get_devid_block(cmlb_handle_t cmlbhandle, diskaddr_t *devidblockp,
853e8fb11a1Sshidokht     void *tg_cookie)
8543ccda647Slclee {
8553ccda647Slclee 	daddr_t			spc, blk, head, cyl;
856e8fb11a1Sshidokht 	struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
8573ccda647Slclee 
858e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
859e8fb11a1Sshidokht 	if (cl->cl_state < CMLB_ATTACHED) {
860e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
8613ccda647Slclee 		return (EINVAL);
8623ccda647Slclee 	}
8633ccda647Slclee 
864e8fb11a1Sshidokht 	if ((cl->cl_f_geometry_is_valid == FALSE) ||
865e8fb11a1Sshidokht 	    (cl->cl_solaris_size < DK_LABEL_LOC)) {
866e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
867e8fb11a1Sshidokht 		return (EINVAL);
868e8fb11a1Sshidokht 	}
869e8fb11a1Sshidokht 
870e8fb11a1Sshidokht 	if (cl->cl_cur_labeltype == CMLB_LABEL_EFI) {
871e8fb11a1Sshidokht 		if (cl->cl_reserved != -1) {
872e8fb11a1Sshidokht 			blk = cl->cl_map[cl->cl_reserved].dkl_cylno;
873e8fb11a1Sshidokht 		} else {
874e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
875e8fb11a1Sshidokht 			return (EINVAL);
876e8fb11a1Sshidokht 		}
877e8fb11a1Sshidokht 	} else {
8785d22422eSml 		/* if the disk is unlabeled, don't write a devid to it */
879342440ecSPrasad Singamsetty 		if (cl->cl_label_from_media != CMLB_LABEL_VTOC) {
8805d22422eSml 			mutex_exit(CMLB_MUTEX(cl));
8815d22422eSml 			return (EINVAL);
8825d22422eSml 		}
8835d22422eSml 
8843ccda647Slclee 		/* this geometry doesn't allow us to write a devid */
885e8fb11a1Sshidokht 		if (cl->cl_g.dkg_acyl < 2) {
886e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
8873ccda647Slclee 			return (EINVAL);
8883ccda647Slclee 		}
8893ccda647Slclee 
8903ccda647Slclee 		/*
8913ccda647Slclee 		 * Subtract 2 guarantees that the next to last cylinder
8923ccda647Slclee 		 * is used
8933ccda647Slclee 		 */
894e8fb11a1Sshidokht 		cyl  = cl->cl_g.dkg_ncyl  + cl->cl_g.dkg_acyl - 2;
895e8fb11a1Sshidokht 		spc  = cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
896e8fb11a1Sshidokht 		head = cl->cl_g.dkg_nhead - 1;
8975d22422eSml 		blk  = cl->cl_solaris_offset +
8985d22422eSml 		    (cyl * (spc - cl->cl_g.dkg_apc)) +
899e8fb11a1Sshidokht 		    (head * cl->cl_g.dkg_nsect) + 1;
9003ccda647Slclee 	}
901e8fb11a1Sshidokht 
9023ccda647Slclee 	*devidblockp = blk;
903e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
9043ccda647Slclee 	return (0);
9053ccda647Slclee }
9063ccda647Slclee 
9073ccda647Slclee /*
9083ccda647Slclee  * cmlb_partinfo:
9093ccda647Slclee  *	Get partition info for specified partition number.
9103ccda647Slclee  *
9113ccda647Slclee  * Arguments:
9123ccda647Slclee  *	cmlbhandle	cmlb handle associated with device.
9133ccda647Slclee  *	part		partition number
9143ccda647Slclee  *	nblocksp	pointer to number of blocks
9153ccda647Slclee  *	startblockp	pointer to starting block
9163ccda647Slclee  *	partnamep	pointer to name of partition
9173ccda647Slclee  *	tagp		pointer to tag info
918e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
919e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
9203ccda647Slclee  *
9213ccda647Slclee  *
9223ccda647Slclee  * Notes:
9233ccda647Slclee  *	If in-core label is not valid, this functions tries to revalidate
9243ccda647Slclee  *	the label. If label is valid, it stores the total number of blocks
9253ccda647Slclee  *	in this partition in the area pointed to by nblocksp, starting
9263ccda647Slclee  *	block number in area pointed to by startblockp,  pointer to partition
9273ccda647Slclee  *	name in area pointed to by partnamep, and tag value in area
9283ccda647Slclee  *	pointed by tagp.
9293ccda647Slclee  *	For EFI labels, tag value will be set to 0.
9303ccda647Slclee  *
9313ccda647Slclee  *	For all nblocksp, startblockp and partnamep, tagp, a value of NULL
9323ccda647Slclee  *	indicates the corresponding info is not requested.
9333ccda647Slclee  *
9343ccda647Slclee  *
9353ccda647Slclee  * Return values:
9363ccda647Slclee  *	0	success
9373ccda647Slclee  *	EINVAL  no valid label or requested partition number is invalid.
9383ccda647Slclee  *
9393ccda647Slclee  */
9403ccda647Slclee int
9413ccda647Slclee cmlb_partinfo(cmlb_handle_t cmlbhandle, int part, diskaddr_t *nblocksp,
942e8fb11a1Sshidokht     diskaddr_t *startblockp, char **partnamep, uint16_t *tagp, void *tg_cookie)
9433ccda647Slclee {
9443ccda647Slclee 
945e8fb11a1Sshidokht 	struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
9463ccda647Slclee 	int rval;
9473ccda647Slclee 
948e8fb11a1Sshidokht 	ASSERT(cl != NULL);
949e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
950e8fb11a1Sshidokht 	if (cl->cl_state < CMLB_ATTACHED) {
951e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
9523ccda647Slclee 		return (EINVAL);
9533ccda647Slclee 	}
9543ccda647Slclee 
9553ccda647Slclee 	if (part  < 0 || part >= MAXPART) {
9563ccda647Slclee 		rval = EINVAL;
9573ccda647Slclee 	} else {
958e8fb11a1Sshidokht 		if (cl->cl_f_geometry_is_valid == FALSE)
959e8fb11a1Sshidokht 			(void) cmlb_validate_geometry((struct cmlb_lun *)cl, 0,
960e8fb11a1Sshidokht 			    0, tg_cookie);
961e8fb11a1Sshidokht 
962342440ecSPrasad Singamsetty #if defined(_SUNOS_VTOC_16)
963342440ecSPrasad Singamsetty 		if (((cl->cl_f_geometry_is_valid == FALSE) ||
964342440ecSPrasad Singamsetty 		    (part < NDKMAP && cl->cl_solaris_size == 0)) &&
965342440ecSPrasad Singamsetty 		    (part != P0_RAW_DISK)) {
966342440ecSPrasad Singamsetty #else
967e8fb11a1Sshidokht 		if ((cl->cl_f_geometry_is_valid == FALSE) ||
968e8fb11a1Sshidokht 		    (part < NDKMAP && cl->cl_solaris_size == 0)) {
969342440ecSPrasad Singamsetty #endif
9703ccda647Slclee 			rval = EINVAL;
9713ccda647Slclee 		} else {
9723ccda647Slclee 			if (startblockp != NULL)
973e8fb11a1Sshidokht 				*startblockp = (diskaddr_t)cl->cl_offset[part];
9743ccda647Slclee 
9753ccda647Slclee 			if (nblocksp != NULL)
9763ccda647Slclee 				*nblocksp = (diskaddr_t)
977e8fb11a1Sshidokht 				    cl->cl_map[part].dkl_nblk;
9783ccda647Slclee 
9793ccda647Slclee 			if (tagp != NULL)
980e8fb11a1Sshidokht 				if (cl->cl_cur_labeltype == CMLB_LABEL_EFI)
9813ccda647Slclee 					*tagp = V_UNASSIGNED;
9823ccda647Slclee 				else
983e8fb11a1Sshidokht 					*tagp = cl->cl_vtoc.v_part[part].p_tag;
9843ccda647Slclee 			rval = 0;
9853ccda647Slclee 		}
9863ccda647Slclee 
9873ccda647Slclee 		/* consistent with behavior of sd for getting minor name */
9883ccda647Slclee 		if (partnamep != NULL)
9893ccda647Slclee 			*partnamep = dk_minor_data[part].name;
9903ccda647Slclee 
9913ccda647Slclee 	}
9923ccda647Slclee 
993e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
9943ccda647Slclee 	return (rval);
9953ccda647Slclee }
9963ccda647Slclee 
997af007057Syl /*
998af007057Syl  * cmlb_efi_label_capacity:
999af007057Syl  *	Get capacity stored in EFI disk label.
1000af007057Syl  *
1001af007057Syl  * Arguments:
1002af007057Syl  *	cmlbhandle	cmlb handle associated with device.
1003af007057Syl  *	capacity	pointer to capacity stored in EFI disk label.
1004af007057Syl  *	tg_cookie	cookie from target driver to be passed back to target
1005af007057Syl  *			driver when we call back to it through tg_ops.
1006af007057Syl  *
1007af007057Syl  *
1008af007057Syl  * Notes:
1009af007057Syl  *	If in-core label is not valid, this functions tries to revalidate
1010af007057Syl  *	the label. If label is valid and is an EFI label, it stores the capacity
1011af007057Syl  *      in disk label in the area pointed to by capacity.
1012af007057Syl  *
1013af007057Syl  *
1014af007057Syl  * Return values:
1015af007057Syl  *	0	success
1016af007057Syl  *	EINVAL  no valid EFI label or capacity is NULL.
1017af007057Syl  *
1018af007057Syl  */
1019af007057Syl int
1020af007057Syl cmlb_efi_label_capacity(cmlb_handle_t cmlbhandle, diskaddr_t *capacity,
1021af007057Syl     void *tg_cookie)
1022af007057Syl {
1023af007057Syl 	struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
1024af007057Syl 	int rval;
1025af007057Syl 
1026af007057Syl 	ASSERT(cl != NULL);
1027af007057Syl 	mutex_enter(CMLB_MUTEX(cl));
1028af007057Syl 	if (cl->cl_state < CMLB_ATTACHED) {
1029af007057Syl 		mutex_exit(CMLB_MUTEX(cl));
1030af007057Syl 		return (EINVAL);
1031af007057Syl 	}
1032af007057Syl 
1033af007057Syl 	if (cl->cl_f_geometry_is_valid == FALSE)
1034af007057Syl 		(void) cmlb_validate_geometry((struct cmlb_lun *)cl, 0,
1035af007057Syl 		    0, tg_cookie);
1036af007057Syl 
1037af007057Syl 	if ((cl->cl_f_geometry_is_valid == FALSE) || (capacity == NULL) ||
1038af007057Syl 	    (cl->cl_cur_labeltype != CMLB_LABEL_EFI)) {
1039af007057Syl 		rval = EINVAL;
1040af007057Syl 	} else {
1041af007057Syl 		*capacity = (diskaddr_t)cl->cl_map[WD_NODE].dkl_nblk;
1042af007057Syl 		rval = 0;
1043af007057Syl 	}
1044af007057Syl 
1045af007057Syl 	mutex_exit(CMLB_MUTEX(cl));
1046af007057Syl 	return (rval);
1047af007057Syl }
1048af007057Syl 
1049e8fb11a1Sshidokht /* Caller should make sure Test Unit Ready succeeds before calling this. */
1050e8fb11a1Sshidokht /*ARGSUSED*/
10513ccda647Slclee int
10523ccda647Slclee cmlb_ioctl(cmlb_handle_t cmlbhandle, dev_t dev, int cmd, intptr_t arg,
1053e8fb11a1Sshidokht     int flag, cred_t *cred_p, int *rval_p, void *tg_cookie)
10543ccda647Slclee {
10553ccda647Slclee 
10563ccda647Slclee 	int err;
1057e8fb11a1Sshidokht 	struct cmlb_lun *cl;
10583ccda647Slclee 
1059e8fb11a1Sshidokht 	cl = (struct cmlb_lun *)cmlbhandle;
10603ccda647Slclee 
1061e8fb11a1Sshidokht 	ASSERT(cl != NULL);
10623ccda647Slclee 
1063e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
1064e8fb11a1Sshidokht 	if (cl->cl_state < CMLB_ATTACHED) {
1065e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
10663ccda647Slclee 		return (EIO);
10673ccda647Slclee 	}
10683ccda647Slclee 
10693ccda647Slclee 	switch (cmd) {
1070342440ecSPrasad Singamsetty 		case DKIOCSEXTVTOC:
1071e8fb11a1Sshidokht 		case DKIOCSGEOM:
10723ccda647Slclee 		case DKIOCSETEFI:
10733ccda647Slclee 		case DKIOCSMBOOT:
10743ccda647Slclee 			break;
1075342440ecSPrasad Singamsetty 		case DKIOCSVTOC:
1076342440ecSPrasad Singamsetty #if defined(__i386) || defined(__amd64)
1077342440ecSPrasad Singamsetty 		case DKIOCPARTINFO:
1078342440ecSPrasad Singamsetty #endif
1079342440ecSPrasad Singamsetty 			if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
1080342440ecSPrasad Singamsetty 				mutex_exit(CMLB_MUTEX(cl));
1081342440ecSPrasad Singamsetty 				return (EOVERFLOW);
1082342440ecSPrasad Singamsetty 			}
1083342440ecSPrasad Singamsetty 			break;
10843ccda647Slclee 		default:
1085342440ecSPrasad Singamsetty 			(void) cmlb_validate_geometry(cl, 1, CMLB_SILENT,
1086adc076afSshidokht 			    tg_cookie);
1087e8fb11a1Sshidokht 
1088342440ecSPrasad Singamsetty 			switch (cmd) {
1089342440ecSPrasad Singamsetty 			case DKIOCGVTOC:
1090342440ecSPrasad Singamsetty 			case DKIOCGAPART:
1091342440ecSPrasad Singamsetty 			case DKIOCSAPART:
1092e8fb11a1Sshidokht 
1093342440ecSPrasad Singamsetty 				if (cl->cl_label_from_media == CMLB_LABEL_EFI) {
1094342440ecSPrasad Singamsetty 					/* GPT label on disk */
1095e8fb11a1Sshidokht 					mutex_exit(CMLB_MUTEX(cl));
10963ccda647Slclee 					return (ENOTSUP);
1097342440ecSPrasad Singamsetty 				} else if
1098342440ecSPrasad Singamsetty 				    (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
1099342440ecSPrasad Singamsetty 					mutex_exit(CMLB_MUTEX(cl));
1100342440ecSPrasad Singamsetty 					return (EOVERFLOW);
11013ccda647Slclee 				}
1102342440ecSPrasad Singamsetty 				break;
1103342440ecSPrasad Singamsetty 
1104342440ecSPrasad Singamsetty 			case DKIOCGGEOM:
1105342440ecSPrasad Singamsetty 				if (cl->cl_label_from_media == CMLB_LABEL_EFI) {
1106342440ecSPrasad Singamsetty 					/* GPT label on disk */
1107342440ecSPrasad Singamsetty 					mutex_exit(CMLB_MUTEX(cl));
1108342440ecSPrasad Singamsetty 					return (ENOTSUP);
1109e8fb11a1Sshidokht 				}
1110342440ecSPrasad Singamsetty 				break;
1111342440ecSPrasad Singamsetty 			default:
1112342440ecSPrasad Singamsetty 				break;
11133ccda647Slclee 			}
11143ccda647Slclee 	}
11153ccda647Slclee 
1116e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
11173ccda647Slclee 
11183ccda647Slclee 	switch (cmd) {
11193ccda647Slclee 	case DKIOCGGEOM:
1120e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCGGEOM\n");
1121e8fb11a1Sshidokht 		err = cmlb_dkio_get_geometry(cl, (caddr_t)arg, flag, tg_cookie);
11223ccda647Slclee 		break;
11233ccda647Slclee 
11243ccda647Slclee 	case DKIOCSGEOM:
1125e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCSGEOM\n");
1126e8fb11a1Sshidokht 		err = cmlb_dkio_set_geometry(cl, (caddr_t)arg, flag);
11273ccda647Slclee 		break;
11283ccda647Slclee 
11293ccda647Slclee 	case DKIOCGAPART:
1130e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCGAPART\n");
1131e8fb11a1Sshidokht 		err = cmlb_dkio_get_partition(cl, (caddr_t)arg,
1132e8fb11a1Sshidokht 		    flag, tg_cookie);
11333ccda647Slclee 		break;
11343ccda647Slclee 
11353ccda647Slclee 	case DKIOCSAPART:
1136e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCSAPART\n");
1137e8fb11a1Sshidokht 		err = cmlb_dkio_set_partition(cl, (caddr_t)arg, flag);
11383ccda647Slclee 		break;
11393ccda647Slclee 
11403ccda647Slclee 	case DKIOCGVTOC:
1141e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCGVTOC\n");
1142e8fb11a1Sshidokht 		err = cmlb_dkio_get_vtoc(cl, (caddr_t)arg, flag, tg_cookie);
11433ccda647Slclee 		break;
11443ccda647Slclee 
1145342440ecSPrasad Singamsetty 	case DKIOCGEXTVTOC:
1146342440ecSPrasad Singamsetty 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCGVTOC\n");
1147342440ecSPrasad Singamsetty 		err = cmlb_dkio_get_extvtoc(cl, (caddr_t)arg, flag, tg_cookie);
1148342440ecSPrasad Singamsetty 		break;
1149342440ecSPrasad Singamsetty 
11503ccda647Slclee 	case DKIOCGETEFI:
1151e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCGETEFI\n");
1152e8fb11a1Sshidokht 		err = cmlb_dkio_get_efi(cl, (caddr_t)arg, flag, tg_cookie);
11533ccda647Slclee 		break;
11543ccda647Slclee 
11553ccda647Slclee 	case DKIOCPARTITION:
1156e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTITION\n");
1157e8fb11a1Sshidokht 		err = cmlb_dkio_partition(cl, (caddr_t)arg, flag, tg_cookie);
11583ccda647Slclee 		break;
11593ccda647Slclee 
11603ccda647Slclee 	case DKIOCSVTOC:
1161e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCSVTOC\n");
1162e8fb11a1Sshidokht 		err = cmlb_dkio_set_vtoc(cl, dev, (caddr_t)arg, flag,
1163e8fb11a1Sshidokht 		    tg_cookie);
11643ccda647Slclee 		break;
11653ccda647Slclee 
1166342440ecSPrasad Singamsetty 	case DKIOCSEXTVTOC:
1167342440ecSPrasad Singamsetty 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCSVTOC\n");
1168342440ecSPrasad Singamsetty 		err = cmlb_dkio_set_extvtoc(cl, dev, (caddr_t)arg, flag,
1169342440ecSPrasad Singamsetty 		    tg_cookie);
1170342440ecSPrasad Singamsetty 		break;
1171342440ecSPrasad Singamsetty 
11723ccda647Slclee 	case DKIOCSETEFI:
1173e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCSETEFI\n");
1174e8fb11a1Sshidokht 		err = cmlb_dkio_set_efi(cl, dev, (caddr_t)arg, flag, tg_cookie);
11753ccda647Slclee 		break;
11763ccda647Slclee 
11773ccda647Slclee 	case DKIOCGMBOOT:
1178e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCGMBOOT\n");
1179e8fb11a1Sshidokht 		err = cmlb_dkio_get_mboot(cl, (caddr_t)arg, flag, tg_cookie);
11803ccda647Slclee 		break;
11813ccda647Slclee 
11823ccda647Slclee 	case DKIOCSMBOOT:
1183e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCSMBOOT\n");
1184e8fb11a1Sshidokht 		err = cmlb_dkio_set_mboot(cl, (caddr_t)arg, flag, tg_cookie);
11853ccda647Slclee 		break;
11863ccda647Slclee 	case DKIOCG_PHYGEOM:
1187e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_PHYGEOM\n");
11883ccda647Slclee #if defined(__i386) || defined(__amd64)
1189e8fb11a1Sshidokht 		err = cmlb_dkio_get_phygeom(cl, (caddr_t)arg, flag);
11903ccda647Slclee #else
11913ccda647Slclee 		err = ENOTTY;
11923ccda647Slclee #endif
11933ccda647Slclee 		break;
11943ccda647Slclee 	case DKIOCG_VIRTGEOM:
1195e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_VIRTGEOM\n");
11963ccda647Slclee #if defined(__i386) || defined(__amd64)
1197e8fb11a1Sshidokht 		err = cmlb_dkio_get_virtgeom(cl, (caddr_t)arg, flag);
11983ccda647Slclee #else
11993ccda647Slclee 		err = ENOTTY;
12003ccda647Slclee #endif
12013ccda647Slclee 		break;
12023ccda647Slclee 	case DKIOCPARTINFO:
1203e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTINFO");
12043ccda647Slclee #if defined(__i386) || defined(__amd64)
1205e8fb11a1Sshidokht 		err = cmlb_dkio_partinfo(cl, dev, (caddr_t)arg, flag);
12063ccda647Slclee #else
12073ccda647Slclee 		err = ENOTTY;
1208342440ecSPrasad Singamsetty #endif
1209342440ecSPrasad Singamsetty 		break;
1210342440ecSPrasad Singamsetty 	case DKIOCEXTPARTINFO:
1211342440ecSPrasad Singamsetty 		cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTINFO");
1212342440ecSPrasad Singamsetty #if defined(__i386) || defined(__amd64)
1213342440ecSPrasad Singamsetty 		err = cmlb_dkio_extpartinfo(cl, dev, (caddr_t)arg, flag);
1214342440ecSPrasad Singamsetty #else
1215342440ecSPrasad Singamsetty 		err = ENOTTY;
12163ccda647Slclee #endif
12173ccda647Slclee 		break;
1218f85c7842SSuhasini Peddada 
12193ccda647Slclee 	default:
12203ccda647Slclee 		err = ENOTTY;
12213ccda647Slclee 
12223ccda647Slclee 	}
1223b9ccdc5aScth 
1224b9ccdc5aScth 	/*
1225b9ccdc5aScth 	 * An ioctl that succeeds and changed ('set') size(9P) information
1226b9ccdc5aScth 	 * needs to invalidate the cached devinfo snapshot to avoid having
1227b9ccdc5aScth 	 * old information being returned in a snapshots.
1228b9ccdc5aScth 	 *
1229b9ccdc5aScth 	 * NB: When available, call ddi_change_minor_node() to clear
1230b9ccdc5aScth 	 * SSIZEVALID in specfs vnodes via spec_size_invalidate().
1231b9ccdc5aScth 	 */
1232b9ccdc5aScth 	if (err == 0) {
1233b9ccdc5aScth 		switch (cmd) {
1234b9ccdc5aScth 		case DKIOCSGEOM:
1235b9ccdc5aScth 		case DKIOCSAPART:
1236b9ccdc5aScth 		case DKIOCSVTOC:
1237342440ecSPrasad Singamsetty 		case DKIOCSEXTVTOC:
1238b9ccdc5aScth 		case DKIOCSETEFI:
1239b9ccdc5aScth 			i_ddi_prop_dyn_cache_invalidate(CMLB_DEVINFO(cl),
1240b9ccdc5aScth 			    i_ddi_prop_dyn_driver_get(CMLB_DEVINFO(cl)));
1241b9ccdc5aScth 		}
1242b9ccdc5aScth 	}
12433ccda647Slclee 	return (err);
12443ccda647Slclee }
12453ccda647Slclee 
12463ccda647Slclee dev_t
1247e8fb11a1Sshidokht cmlb_make_device(struct cmlb_lun *cl)
12483ccda647Slclee {
12495c066ec2SJerry Gilliam 	return (makedevice(ddi_driver_major(CMLB_DEVINFO(cl)),
1250e8fb11a1Sshidokht 	    ddi_get_instance(CMLB_DEVINFO(cl)) << CMLBUNIT_SHIFT));
12513ccda647Slclee }
12523ccda647Slclee 
12533ccda647Slclee /*
12543ccda647Slclee  * Function: cmlb_check_update_blockcount
12553ccda647Slclee  *
12563ccda647Slclee  * Description: If current capacity value is invalid, obtains the
12573ccda647Slclee  *		current capacity from target driver.
12583ccda647Slclee  *
12593ccda647Slclee  * Return Code: 0	success
12603ccda647Slclee  *		EIO	failure
12613ccda647Slclee  */
12623ccda647Slclee static int
1263e8fb11a1Sshidokht cmlb_check_update_blockcount(struct cmlb_lun *cl, void *tg_cookie)
12643ccda647Slclee {
12653ccda647Slclee 	int status;
12663ccda647Slclee 	diskaddr_t capacity;
1267e8fb11a1Sshidokht 	uint32_t lbasize;
12683ccda647Slclee 
1269e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
12703ccda647Slclee 
1271e8fb11a1Sshidokht 	if (cl->cl_f_geometry_is_valid == FALSE)  {
1272e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
1273e8fb11a1Sshidokht 		status = DK_TG_GETCAP(cl, &capacity, tg_cookie);
1274e8fb11a1Sshidokht 		if (status != 0) {
1275e8fb11a1Sshidokht 			mutex_enter(CMLB_MUTEX(cl));
1276e8fb11a1Sshidokht 			return (EIO);
1277e8fb11a1Sshidokht 		}
1278e8fb11a1Sshidokht 
1279e8fb11a1Sshidokht 		status = DK_TG_GETBLOCKSIZE(cl, &lbasize, tg_cookie);
1280e8fb11a1Sshidokht 		mutex_enter(CMLB_MUTEX(cl));
1281e8fb11a1Sshidokht 		if (status != 0)
1282e8fb11a1Sshidokht 			return (EIO);
1283e8fb11a1Sshidokht 
1284e8fb11a1Sshidokht 		if ((capacity != 0) && (lbasize != 0)) {
1285e8fb11a1Sshidokht 			cl->cl_blockcount = capacity;
1286e8fb11a1Sshidokht 			cl->cl_tgt_blocksize = lbasize;
12873ccda647Slclee 			return (0);
12883ccda647Slclee 		} else
12893ccda647Slclee 			return (EIO);
12903ccda647Slclee 	} else
12913ccda647Slclee 		return (0);
12923ccda647Slclee }
12933ccda647Slclee 
129406bbe1e0Sedp static int
129506bbe1e0Sedp cmlb_create_minor(dev_info_t *dip, char *name, int spec_type,
129606bbe1e0Sedp     minor_t minor_num, char *node_type, int flag, boolean_t internal)
129706bbe1e0Sedp {
129806bbe1e0Sedp 	if (internal)
129906bbe1e0Sedp 		return (ddi_create_internal_pathname(dip,
130006bbe1e0Sedp 		    name, spec_type, minor_num));
130106bbe1e0Sedp 	else
130206bbe1e0Sedp 		return (ddi_create_minor_node(dip,
130306bbe1e0Sedp 		    name, spec_type, minor_num, node_type, flag));
130406bbe1e0Sedp }
130506bbe1e0Sedp 
13063ccda647Slclee /*
13073ccda647Slclee  *    Function: cmlb_create_minor_nodes
13083ccda647Slclee  *
13093ccda647Slclee  * Description: Create or adjust the minor device nodes for the instance.
13103ccda647Slclee  * 		Minor nodes are created based on default label type,
13113ccda647Slclee  *		current label type and last label type we created
13123ccda647Slclee  *		minor nodes based on.
13133ccda647Slclee  *
13143ccda647Slclee  *
1315e8fb11a1Sshidokht  *   Arguments: cl - driver soft state (unit) structure
13163ccda647Slclee  *
13173ccda647Slclee  * Return Code: 0 success
13183ccda647Slclee  *		ENXIO	failure.
13193ccda647Slclee  *
13203ccda647Slclee  *     Context: Kernel thread context
13213ccda647Slclee  */
13223ccda647Slclee static int
1323e8fb11a1Sshidokht cmlb_create_minor_nodes(struct cmlb_lun *cl)
13243ccda647Slclee {
13253ccda647Slclee 	struct driver_minor_data	*dmdp;
13263ccda647Slclee 	int				instance;
13273ccda647Slclee 	char				name[48];
13283ccda647Slclee 	cmlb_label_t			newlabeltype;
132906bbe1e0Sedp 	boolean_t			internal;
13303ccda647Slclee 
1331e8fb11a1Sshidokht 	ASSERT(cl != NULL);
1332e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
13333ccda647Slclee 
133406bbe1e0Sedp 	internal = ((cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
13353ccda647Slclee 
13363ccda647Slclee 	/* check the most common case */
1337e8fb11a1Sshidokht 	if (cl->cl_cur_labeltype != CMLB_LABEL_UNDEF &&
1338e8fb11a1Sshidokht 	    cl->cl_last_labeltype == cl->cl_cur_labeltype) {
13393ccda647Slclee 		/* do nothing */
13403ccda647Slclee 		return (0);
13413ccda647Slclee 	}
13423ccda647Slclee 
1343e8fb11a1Sshidokht 	if (cl->cl_def_labeltype == CMLB_LABEL_UNDEF) {
13443ccda647Slclee 		/* we should never get here */
13453ccda647Slclee 		return (ENXIO);
13463ccda647Slclee 	}
13473ccda647Slclee 
1348e8fb11a1Sshidokht 	if (cl->cl_last_labeltype == CMLB_LABEL_UNDEF) {
13493ccda647Slclee 		/* first time during attach */
1350e8fb11a1Sshidokht 		newlabeltype = cl->cl_def_labeltype;
13513ccda647Slclee 
1352e8fb11a1Sshidokht 		instance = ddi_get_instance(CMLB_DEVINFO(cl));
13533ccda647Slclee 
13543ccda647Slclee 		/* Create all the minor nodes for this target. */
13553ccda647Slclee 		dmdp = (newlabeltype == CMLB_LABEL_EFI) ? dk_minor_data_efi :
13563ccda647Slclee 		    dk_minor_data;
13573ccda647Slclee 		while (dmdp->name != NULL) {
13583ccda647Slclee 
13593ccda647Slclee 			(void) sprintf(name, "%s", dmdp->name);
13603ccda647Slclee 
136106bbe1e0Sedp 			if (cmlb_create_minor(CMLB_DEVINFO(cl), name,
13623ccda647Slclee 			    dmdp->type,
13633ccda647Slclee 			    (instance << CMLBUNIT_SHIFT) | dmdp->minor,
136406bbe1e0Sedp 			    cl->cl_node_type, NULL, internal) == DDI_FAILURE) {
13653ccda647Slclee 				/*
13663ccda647Slclee 				 * Clean up any nodes that may have been
13673ccda647Slclee 				 * created, in case this fails in the middle
13683ccda647Slclee 				 * of the loop.
13693ccda647Slclee 				 */
1370e8fb11a1Sshidokht 				ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
13713ccda647Slclee 				return (ENXIO);
13723ccda647Slclee 			}
13733ccda647Slclee 			dmdp++;
13743ccda647Slclee 		}
1375e8fb11a1Sshidokht 		cl->cl_last_labeltype = newlabeltype;
13763ccda647Slclee 		return (0);
13773ccda647Slclee 	}
13783ccda647Slclee 
13793ccda647Slclee 	/* Not first time  */
1380e8fb11a1Sshidokht 	if (cl->cl_cur_labeltype == CMLB_LABEL_UNDEF) {
1381e8fb11a1Sshidokht 		if (cl->cl_last_labeltype != cl->cl_def_labeltype) {
13823ccda647Slclee 			/* close time, revert to default. */
1383e8fb11a1Sshidokht 			newlabeltype = cl->cl_def_labeltype;
13843ccda647Slclee 		} else {
13853ccda647Slclee 			/*
13863ccda647Slclee 			 * do nothing since the type for which we last created
13873ccda647Slclee 			 * nodes matches the default
13883ccda647Slclee 			 */
13893ccda647Slclee 			return (0);
13903ccda647Slclee 		}
13913ccda647Slclee 	} else {
1392e8fb11a1Sshidokht 		if (cl->cl_cur_labeltype != cl->cl_last_labeltype) {
13933ccda647Slclee 			/* We are not closing, use current label type */
1394e8fb11a1Sshidokht 			newlabeltype = cl->cl_cur_labeltype;
13953ccda647Slclee 		} else {
13963ccda647Slclee 			/*
13973ccda647Slclee 			 * do nothing since the type for which we last created
13983ccda647Slclee 			 * nodes matches the current label type
13993ccda647Slclee 			 */
14003ccda647Slclee 			return (0);
14013ccda647Slclee 		}
14023ccda647Slclee 	}
14033ccda647Slclee 
1404e8fb11a1Sshidokht 	instance = ddi_get_instance(CMLB_DEVINFO(cl));
14053ccda647Slclee 
14063ccda647Slclee 	/*
14073ccda647Slclee 	 * Currently we only fix up the s7 node when we are switching
14083ccda647Slclee 	 * label types from or to EFI. This is consistent with
14093ccda647Slclee 	 * current behavior of sd.
14103ccda647Slclee 	 */
14113ccda647Slclee 	if (newlabeltype == CMLB_LABEL_EFI &&
1412e8fb11a1Sshidokht 	    cl->cl_last_labeltype != CMLB_LABEL_EFI) {
14133ccda647Slclee 		/* from vtoc to EFI */
1414e8fb11a1Sshidokht 		ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
1415e8fb11a1Sshidokht 		ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
141606bbe1e0Sedp 		(void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd",
14173ccda647Slclee 		    S_IFBLK, (instance << CMLBUNIT_SHIFT) | WD_NODE,
141806bbe1e0Sedp 		    cl->cl_node_type, NULL, internal);
141906bbe1e0Sedp 		(void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd,raw",
14203ccda647Slclee 		    S_IFCHR, (instance << CMLBUNIT_SHIFT) | WD_NODE,
142106bbe1e0Sedp 		    cl->cl_node_type, NULL, internal);
14223ccda647Slclee 	} else {
14233ccda647Slclee 		/* from efi to vtoc */
1424e8fb11a1Sshidokht 		ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
1425e8fb11a1Sshidokht 		ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
142606bbe1e0Sedp 		(void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
14273ccda647Slclee 		    S_IFBLK, (instance << CMLBUNIT_SHIFT) | WD_NODE,
142806bbe1e0Sedp 		    cl->cl_node_type, NULL, internal);
142906bbe1e0Sedp 		(void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
14303ccda647Slclee 		    S_IFCHR, (instance << CMLBUNIT_SHIFT) | WD_NODE,
143106bbe1e0Sedp 		    cl->cl_node_type, NULL, internal);
14323ccda647Slclee 	}
14333ccda647Slclee 
1434e8fb11a1Sshidokht 	cl->cl_last_labeltype = newlabeltype;
14353ccda647Slclee 	return (0);
14363ccda647Slclee }
14373ccda647Slclee 
14383ccda647Slclee /*
14393ccda647Slclee  *    Function: cmlb_validate_geometry
14403ccda647Slclee  *
14413ccda647Slclee  * Description: Read the label from the disk (if present). Update the unit's
14423ccda647Slclee  *		geometry and vtoc information from the data in the label.
14433ccda647Slclee  *		Verify that the label is valid.
14443ccda647Slclee  *
1445e8fb11a1Sshidokht  *   Arguments:
1446e8fb11a1Sshidokht  *	cl		driver soft state (unit) structure
1447e8fb11a1Sshidokht  *
1448e8fb11a1Sshidokht  *	forcerevalid	force revalidation even if we are already valid.
1449e8fb11a1Sshidokht  *	flags		operation flags from target driver. Used for verbosity
1450e8fb11a1Sshidokht  *			control	at this time.
1451e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
1452e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
14533ccda647Slclee  *
14543ccda647Slclee  * Return Code: 0 - Successful completion
1455e8fb11a1Sshidokht  *		EINVAL  - Invalid value in cl->cl_tgt_blocksize or
1456e8fb11a1Sshidokht  *			  cl->cl_blockcount; or label on disk is corrupted
14573ccda647Slclee  *			  or unreadable.
14583ccda647Slclee  *		EACCES  - Reservation conflict at the device.
14593ccda647Slclee  *		ENOMEM  - Resource allocation error
14603ccda647Slclee  *		ENOTSUP - geometry not applicable
14613ccda647Slclee  *
14623ccda647Slclee  *     Context: Kernel thread only (can sleep).
14633ccda647Slclee  */
14643ccda647Slclee static int
1465e8fb11a1Sshidokht cmlb_validate_geometry(struct cmlb_lun *cl, int forcerevalid, int flags,
1466e8fb11a1Sshidokht     void *tg_cookie)
14673ccda647Slclee {
14683ccda647Slclee 	int		label_error = 0;
14693ccda647Slclee 	diskaddr_t	capacity;
14703ccda647Slclee 	int		count;
14713ccda647Slclee 
1472e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
14733ccda647Slclee 
1474e8fb11a1Sshidokht 	if ((cl->cl_f_geometry_is_valid == TRUE) && (forcerevalid == 0)) {
1475e8fb11a1Sshidokht 		if (cl->cl_cur_labeltype == CMLB_LABEL_EFI)
14763ccda647Slclee 			return (ENOTSUP);
14773ccda647Slclee 		return (0);
14783ccda647Slclee 	}
14793ccda647Slclee 
1480e8fb11a1Sshidokht 	if (cmlb_check_update_blockcount(cl, tg_cookie) != 0)
14813ccda647Slclee 		return (EIO);
14823ccda647Slclee 
1483e8fb11a1Sshidokht 	capacity = cl->cl_blockcount;
14843ccda647Slclee 
14853ccda647Slclee #if defined(_SUNOS_VTOC_16)
14863ccda647Slclee 	/*
14873ccda647Slclee 	 * Set up the "whole disk" fdisk partition; this should always
14883ccda647Slclee 	 * exist, regardless of whether the disk contains an fdisk table
14893ccda647Slclee 	 * or vtoc.
14903ccda647Slclee 	 */
1491e8fb11a1Sshidokht 	cl->cl_map[P0_RAW_DISK].dkl_cylno = 0;
1492342440ecSPrasad Singamsetty 	cl->cl_offset[P0_RAW_DISK] = 0;
14933ccda647Slclee 	/*
1494342440ecSPrasad Singamsetty 	 * note if capacity > int32_max(1TB) we are in 64bit environment
1495342440ecSPrasad Singamsetty 	 * so no truncation happens
14963ccda647Slclee 	 */
1497e8fb11a1Sshidokht 	cl->cl_map[P0_RAW_DISK].dkl_nblk  = capacity;
14983ccda647Slclee #endif
14993ccda647Slclee 	/*
15003ccda647Slclee 	 * Refresh the logical and physical geometry caches.
15013ccda647Slclee 	 * (data from MODE SENSE format/rigid disk geometry pages,
15023ccda647Slclee 	 * and scsi_ifgetcap("geometry").
15033ccda647Slclee 	 */
1504e8fb11a1Sshidokht 	cmlb_resync_geom_caches(cl, capacity, tg_cookie);
15053ccda647Slclee 
1506342440ecSPrasad Singamsetty 	cl->cl_label_from_media = CMLB_LABEL_UNDEF;
1507e8fb11a1Sshidokht 	label_error = cmlb_use_efi(cl, capacity, flags, tg_cookie);
15083ccda647Slclee 	if (label_error == 0) {
15093ccda647Slclee 
15103ccda647Slclee 		/* found a valid EFI label */
1511e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl,
15123ccda647Slclee 		    "cmlb_validate_geometry: found EFI label\n");
15133ccda647Slclee 		/*
15143ccda647Slclee 		 * solaris_size and geometry_is_valid are set in
15153ccda647Slclee 		 * cmlb_use_efi
15163ccda647Slclee 		 */
15173ccda647Slclee 		return (ENOTSUP);
15183ccda647Slclee 	}
15193ccda647Slclee 
15203ccda647Slclee 	/* NO EFI label found */
15213ccda647Slclee 
1522342440ecSPrasad Singamsetty 	if (capacity > CMLB_EXTVTOC_LIMIT) {
15233ccda647Slclee 		if (label_error == ESRCH) {
15243ccda647Slclee 			/*
1525342440ecSPrasad Singamsetty 			 * they've configured a LUN over 2TB, but used
15263ccda647Slclee 			 * format.dat to restrict format's view of the
1527342440ecSPrasad Singamsetty 			 * capacity to be under 2TB in some earlier Solaris
1528342440ecSPrasad Singamsetty 			 * release.
15293ccda647Slclee 			 */
1530342440ecSPrasad Singamsetty 			/* i.e > 2TB with a VTOC < 2TB */
1531342440ecSPrasad Singamsetty 			if (!(flags & CMLB_SILENT) &&
1532342440ecSPrasad Singamsetty 			    (cl->cl_msglog_flag & CMLB_ALLOW_2TB_WARN)) {
1533e8fb11a1Sshidokht 
1534e8fb11a1Sshidokht 				cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
1535342440ecSPrasad Singamsetty 				    CE_NOTE, "!Disk (%s%d) is limited to 2 TB "
1536342440ecSPrasad Singamsetty 				    "due to VTOC label. To use the full "
1537342440ecSPrasad Singamsetty 				    "capacity of the disk, use format(1M) to "
1538342440ecSPrasad Singamsetty 				    "relabel the disk with EFI/GPT label.\n",
1539342440ecSPrasad Singamsetty 				    CMLB_LABEL(cl),
1540342440ecSPrasad Singamsetty 				    ddi_get_instance(CMLB_DEVINFO(cl)));
1541342440ecSPrasad Singamsetty 
1542342440ecSPrasad Singamsetty 				cl->cl_msglog_flag &= ~CMLB_ALLOW_2TB_WARN;
1543e8fb11a1Sshidokht 			}
15443ccda647Slclee 		} else {
1545e8fb11a1Sshidokht 				return (ENOTSUP);
15463ccda647Slclee 		}
15473ccda647Slclee 	}
15483ccda647Slclee 
15493ccda647Slclee 	label_error = 0;
15503ccda647Slclee 
15513ccda647Slclee 	/*
15523ccda647Slclee 	 * at this point it is either labeled with a VTOC or it is
1553e8fb11a1Sshidokht 	 * under 1TB (<= 1TB actually for off-by-1)
15543ccda647Slclee 	 */
15553ccda647Slclee 
15563ccda647Slclee 	/*
1557e8fb11a1Sshidokht 	 * Only DIRECT ACCESS devices will have Scl labels.
1558e8fb11a1Sshidokht 	 * CD's supposedly have a Scl label, too
15593ccda647Slclee 	 */
1560e8fb11a1Sshidokht 	if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) {
15613ccda647Slclee 		struct	dk_label *dkl;
15623ccda647Slclee 		offset_t label_addr;
15633ccda647Slclee 		int	rval;
15643ccda647Slclee 		size_t	buffer_size;
15653ccda647Slclee 
15663ccda647Slclee 		/*
1567e8fb11a1Sshidokht 		 * Note: This will set up cl->cl_solaris_size and
1568e8fb11a1Sshidokht 		 * cl->cl_solaris_offset.
15693ccda647Slclee 		 */
1570e8fb11a1Sshidokht 		rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
1571e8fb11a1Sshidokht 		if ((rval != 0) && !ISCD(cl)) {
1572e8fb11a1Sshidokht 			ASSERT(mutex_owned(CMLB_MUTEX(cl)));
15733ccda647Slclee 			return (rval);
15743ccda647Slclee 		}
15753ccda647Slclee 
1576e8fb11a1Sshidokht 		if (cl->cl_solaris_size <= DK_LABEL_LOC) {
15773ccda647Slclee 			/*
15783ccda647Slclee 			 * Found fdisk table but no Solaris partition entry,
15793ccda647Slclee 			 * so don't call cmlb_uselabel() and don't create
15803ccda647Slclee 			 * a default label.
15813ccda647Slclee 			 */
15823ccda647Slclee 			label_error = 0;
1583e8fb11a1Sshidokht 			cl->cl_f_geometry_is_valid = TRUE;
15843ccda647Slclee 			goto no_solaris_partition;
15853ccda647Slclee 		}
15863ccda647Slclee 
1587e8fb11a1Sshidokht 		label_addr = (daddr_t)(cl->cl_solaris_offset + DK_LABEL_LOC);
1588e8fb11a1Sshidokht 
15893ccda647Slclee 		buffer_size = sizeof (struct dk_label);
15903ccda647Slclee 
1591e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE, cl, "cmlb_validate_geometry: "
15923ccda647Slclee 		    "label_addr: 0x%x allocation size: 0x%x\n",
15933ccda647Slclee 		    label_addr, buffer_size);
15943ccda647Slclee 
15953ccda647Slclee 		if ((dkl = kmem_zalloc(buffer_size, KM_NOSLEEP)) == NULL)
15963ccda647Slclee 			return (ENOMEM);
15973ccda647Slclee 
1598e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
1599e8fb11a1Sshidokht 		rval = DK_TG_READ(cl, dkl, label_addr, buffer_size, tg_cookie);
1600e8fb11a1Sshidokht 		mutex_enter(CMLB_MUTEX(cl));
16013ccda647Slclee 
16023ccda647Slclee 		switch (rval) {
16033ccda647Slclee 		case 0:
16043ccda647Slclee 			/*
16053ccda647Slclee 			 * cmlb_uselabel will establish that the geometry
16063ccda647Slclee 			 * is valid.
16073ccda647Slclee 			 */
1608e8fb11a1Sshidokht 			if (cmlb_uselabel(cl,
1609e8fb11a1Sshidokht 			    (struct dk_label *)(uintptr_t)dkl, flags) !=
16103ccda647Slclee 			    CMLB_LABEL_IS_VALID) {
16113ccda647Slclee 				label_error = EINVAL;
16123ccda647Slclee 			} else
1613342440ecSPrasad Singamsetty 				cl->cl_label_from_media = CMLB_LABEL_VTOC;
16143ccda647Slclee 			break;
16153ccda647Slclee 		case EACCES:
16163ccda647Slclee 			label_error = EACCES;
16173ccda647Slclee 			break;
16183ccda647Slclee 		default:
16193ccda647Slclee 			label_error = EINVAL;
16203ccda647Slclee 			break;
16213ccda647Slclee 		}
16223ccda647Slclee 
16233ccda647Slclee 		kmem_free(dkl, buffer_size);
16243ccda647Slclee 	}
16253ccda647Slclee 
16263ccda647Slclee 	/*
16273ccda647Slclee 	 * If a valid label was not found, AND if no reservation conflict
16283ccda647Slclee 	 * was detected, then go ahead and create a default label (4069506).
16293ccda647Slclee 	 *
16303ccda647Slclee 	 * Note: currently, for VTOC_8 devices, the default label is created
1631e8fb11a1Sshidokht 	 * for removables and hotpluggables only.  For VTOC_16 devices, the
1632e8fb11a1Sshidokht 	 * default label will be created for all devices.
16333ccda647Slclee 	 * (see cmlb_build_default_label)
16343ccda647Slclee 	 */
16353ccda647Slclee #if defined(_SUNOS_VTOC_8)
1636e8fb11a1Sshidokht 	if ((ISREMOVABLE(cl) || ISHOTPLUGGABLE(cl)) &&
1637e8fb11a1Sshidokht 	    (label_error != EACCES)) {
16383ccda647Slclee #elif defined(_SUNOS_VTOC_16)
16393ccda647Slclee 	if (label_error != EACCES) {
16403ccda647Slclee #endif
1641e8fb11a1Sshidokht 		if (cl->cl_f_geometry_is_valid == FALSE) {
1642e8fb11a1Sshidokht 			cmlb_build_default_label(cl, tg_cookie);
16433ccda647Slclee 		}
16443ccda647Slclee 		label_error = 0;
16453ccda647Slclee 	}
16463ccda647Slclee 
16473ccda647Slclee no_solaris_partition:
16483ccda647Slclee 
16493ccda647Slclee #if defined(_SUNOS_VTOC_16)
16503ccda647Slclee 	/*
16513ccda647Slclee 	 * If we have valid geometry, set up the remaining fdisk partitions.
16523ccda647Slclee 	 * Note that dkl_cylno is not used for the fdisk map entries, so
16533ccda647Slclee 	 * we set it to an entirely bogus value.
16543ccda647Slclee 	 */
1655f85c7842SSuhasini Peddada 	for (count = 0; count < FD_NUMPART; count++) {
1656342440ecSPrasad Singamsetty 		cl->cl_map[FDISK_P1 + count].dkl_cylno = UINT16_MAX;
1657e8fb11a1Sshidokht 		cl->cl_map[FDISK_P1 + count].dkl_nblk =
1658e8fb11a1Sshidokht 		    cl->cl_fmap[count].fmap_nblk;
16593ccda647Slclee 
1660e8fb11a1Sshidokht 		cl->cl_offset[FDISK_P1 + count] =
1661e8fb11a1Sshidokht 		    cl->cl_fmap[count].fmap_start;
16623ccda647Slclee 	}
16633ccda647Slclee #endif
16643ccda647Slclee 
16653ccda647Slclee 	for (count = 0; count < NDKMAP; count++) {
16663ccda647Slclee #if defined(_SUNOS_VTOC_8)
1667e8fb11a1Sshidokht 		struct dk_map *lp  = &cl->cl_map[count];
1668e8fb11a1Sshidokht 		cl->cl_offset[count] =
1669e8fb11a1Sshidokht 		    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
16703ccda647Slclee #elif defined(_SUNOS_VTOC_16)
1671e8fb11a1Sshidokht 		struct dkl_partition *vp = &cl->cl_vtoc.v_part[count];
16723ccda647Slclee 
1673e8fb11a1Sshidokht 		cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset;
16743ccda647Slclee #else
16753ccda647Slclee #error "No VTOC format defined."
16763ccda647Slclee #endif
16773ccda647Slclee 	}
16783ccda647Slclee 
16793ccda647Slclee 	return (label_error);
16803ccda647Slclee }
16813ccda647Slclee 
16823ccda647Slclee #if defined(_SUNOS_VTOC_16)
16833ccda647Slclee /*
16843ccda647Slclee  *    Function: cmlb_convert_geometry
16853ccda647Slclee  *
16863ccda647Slclee  * Description: Convert physical geometry into a dk_geom structure. In
16873ccda647Slclee  *		other words, make sure we don't wrap 16-bit values.
16883ccda647Slclee  *		e.g. converting from geom_cache to dk_geom
16893ccda647Slclee  *
16903ccda647Slclee  *     Context: Kernel thread only
16913ccda647Slclee  */
16923ccda647Slclee static void
1693e8fb11a1Sshidokht cmlb_convert_geometry(diskaddr_t capacity, struct dk_geom *cl_g)
16943ccda647Slclee {
16953ccda647Slclee 
16963ccda647Slclee 	/* Unlabeled SCSI floppy device */
16973ccda647Slclee 	if (capacity <= 0x1000) {
1698e8fb11a1Sshidokht 		cl_g->dkg_nhead = 2;
1699e8fb11a1Sshidokht 		cl_g->dkg_ncyl = 80;
1700e8fb11a1Sshidokht 		cl_g->dkg_nsect = capacity / (cl_g->dkg_nhead * cl_g->dkg_ncyl);
17013ccda647Slclee 		return;
17023ccda647Slclee 	}
17033ccda647Slclee 
17043ccda647Slclee 	/*
1705342440ecSPrasad Singamsetty 	 * For all devices we calculate cylinders using the heads and sectors
1706342440ecSPrasad Singamsetty 	 * we assign based on capacity of the device.  The algorithm is
1707342440ecSPrasad Singamsetty 	 * designed to be compatible with the way other operating systems
1708342440ecSPrasad Singamsetty 	 * lay out fdisk tables for X86 and to insure that the cylinders never
1709342440ecSPrasad Singamsetty 	 * exceed 65535 to prevent problems with X86 ioctls that report
1710342440ecSPrasad Singamsetty 	 * geometry.
1711342440ecSPrasad Singamsetty 	 * For some smaller disk sizes we report geometry that matches those
1712342440ecSPrasad Singamsetty 	 * used by X86 BIOS usage. For larger disks, we use SPT that are
1713342440ecSPrasad Singamsetty 	 * multiples of 63, since other OSes that are not limited to 16-bits
1714342440ecSPrasad Singamsetty 	 * for cylinders stop at 63 SPT we make do by using multiples of 63 SPT.
1715342440ecSPrasad Singamsetty 	 *
1716342440ecSPrasad Singamsetty 	 * The following table (in order) illustrates some end result
1717342440ecSPrasad Singamsetty 	 * calculations:
17183ccda647Slclee 	 *
1719342440ecSPrasad Singamsetty 	 * Maximum number of blocks 		nhead	nsect
1720342440ecSPrasad Singamsetty 	 *
1721342440ecSPrasad Singamsetty 	 * 2097152 (1GB)			64	32
1722342440ecSPrasad Singamsetty 	 * 16777216 (8GB)			128	32
1723342440ecSPrasad Singamsetty 	 * 1052819775 (502.02GB)		255  	63
1724342440ecSPrasad Singamsetty 	 * 2105639550 (0.98TB)			255	126
1725342440ecSPrasad Singamsetty 	 * 3158459325 (1.47TB)			255  	189
1726342440ecSPrasad Singamsetty 	 * 4211279100 (1.96TB)			255  	252
1727342440ecSPrasad Singamsetty 	 * 5264098875 (2.45TB)			255  	315
1728342440ecSPrasad Singamsetty 	 * ...
17293ccda647Slclee 	 */
17303ccda647Slclee 
1731342440ecSPrasad Singamsetty 	if (capacity <= 0x200000) {
1732342440ecSPrasad Singamsetty 		cl_g->dkg_nhead = 64;
1733342440ecSPrasad Singamsetty 		cl_g->dkg_nsect = 32;
1734342440ecSPrasad Singamsetty 	} else if (capacity <= 0x01000000) {
1735342440ecSPrasad Singamsetty 		cl_g->dkg_nhead = 128;
1736342440ecSPrasad Singamsetty 		cl_g->dkg_nsect = 32;
1737342440ecSPrasad Singamsetty 	} else {
1738342440ecSPrasad Singamsetty 		cl_g->dkg_nhead = 255;
1739342440ecSPrasad Singamsetty 
1740342440ecSPrasad Singamsetty 		/* make nsect be smallest multiple of 63 */
1741342440ecSPrasad Singamsetty 		cl_g->dkg_nsect = ((capacity +
1742342440ecSPrasad Singamsetty 		    (UINT16_MAX * 255 * 63) - 1) /
1743342440ecSPrasad Singamsetty 		    (UINT16_MAX * 255 * 63)) * 63;
1744342440ecSPrasad Singamsetty 
1745342440ecSPrasad Singamsetty 		if (cl_g->dkg_nsect == 0)
1746342440ecSPrasad Singamsetty 			cl_g->dkg_nsect = (UINT16_MAX / 63) * 63;
1747342440ecSPrasad Singamsetty 	}
1748342440ecSPrasad Singamsetty 
17493ccda647Slclee }
17503ccda647Slclee #endif
17513ccda647Slclee 
17523ccda647Slclee /*
17533ccda647Slclee  *    Function: cmlb_resync_geom_caches
17543ccda647Slclee  *
17553ccda647Slclee  * Description: (Re)initialize both geometry caches: the virtual geometry
17563ccda647Slclee  *            information is extracted from the HBA (the "geometry"
17573ccda647Slclee  *            capability), and the physical geometry cache data is
17583ccda647Slclee  *            generated by issuing MODE SENSE commands.
17593ccda647Slclee  *
1760e8fb11a1Sshidokht  *   Arguments:
1761e8fb11a1Sshidokht  *	cl 		driver soft state (unit) structure
1762e8fb11a1Sshidokht  *	capacity	disk capacity in #blocks
1763e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
1764e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
17653ccda647Slclee  *
17663ccda647Slclee  *     Context: Kernel thread only (can sleep).
17673ccda647Slclee  */
17683ccda647Slclee static void
1769e8fb11a1Sshidokht cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity,
1770e8fb11a1Sshidokht     void *tg_cookie)
17713ccda647Slclee {
17723ccda647Slclee 	struct	cmlb_geom 	pgeom;
17733ccda647Slclee 	struct	cmlb_geom	lgeom;
17743ccda647Slclee 	struct 	cmlb_geom	*pgeomp = &pgeom;
17753ccda647Slclee 	unsigned short 		nhead;
17763ccda647Slclee 	unsigned short 		nsect;
17773ccda647Slclee 	int 			spc;
17783ccda647Slclee 	int			ret;
17793ccda647Slclee 
1780e8fb11a1Sshidokht 	ASSERT(cl != NULL);
1781e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
17823ccda647Slclee 
17833ccda647Slclee 	/*
17843ccda647Slclee 	 * Ask the controller for its logical geometry.
17853ccda647Slclee 	 * Note: if the HBA does not support scsi_ifgetcap("geometry"),
17863ccda647Slclee 	 * then the lgeom cache will be invalid.
17873ccda647Slclee 	 */
1788e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
17893ccda647Slclee 	bzero(&lgeom, sizeof (struct cmlb_geom));
1790e8fb11a1Sshidokht 	ret = DK_TG_GETVIRTGEOM(cl, &lgeom, tg_cookie);
1791e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
17923ccda647Slclee 
1793e8fb11a1Sshidokht 	bcopy(&lgeom, &cl->cl_lgeom, sizeof (cl->cl_lgeom));
17943ccda647Slclee 
17953ccda647Slclee 	/*
17963ccda647Slclee 	 * Initialize the pgeom cache from lgeom, so that if MODE SENSE
17973ccda647Slclee 	 * doesn't work, DKIOCG_PHYSGEOM can return reasonable values.
17983ccda647Slclee 	 */
1799e8fb11a1Sshidokht 	if (ret != 0 || cl->cl_lgeom.g_nsect == 0 ||
1800e8fb11a1Sshidokht 	    cl->cl_lgeom.g_nhead == 0) {
18013ccda647Slclee 		/*
18023ccda647Slclee 		 * Note: Perhaps this needs to be more adaptive? The rationale
18033ccda647Slclee 		 * is that, if there's no HBA geometry from the HBA driver, any
18043ccda647Slclee 		 * guess is good, since this is the physical geometry. If MODE
18053ccda647Slclee 		 * SENSE fails this gives a max cylinder size for non-LBA access
18063ccda647Slclee 		 */
18073ccda647Slclee 		nhead = 255;
18083ccda647Slclee 		nsect = 63;
18093ccda647Slclee 	} else {
1810e8fb11a1Sshidokht 		nhead = cl->cl_lgeom.g_nhead;
1811e8fb11a1Sshidokht 		nsect = cl->cl_lgeom.g_nsect;
18123ccda647Slclee 	}
18133ccda647Slclee 
1814e8fb11a1Sshidokht 	if (ISCD(cl)) {
18153ccda647Slclee 		pgeomp->g_nhead = 1;
18163ccda647Slclee 		pgeomp->g_nsect = nsect * nhead;
18173ccda647Slclee 	} else {
18183ccda647Slclee 		pgeomp->g_nhead = nhead;
18193ccda647Slclee 		pgeomp->g_nsect = nsect;
18203ccda647Slclee 	}
18213ccda647Slclee 
18223ccda647Slclee 	spc = pgeomp->g_nhead * pgeomp->g_nsect;
18233ccda647Slclee 	pgeomp->g_capacity = capacity;
18243ccda647Slclee 	pgeomp->g_ncyl = pgeomp->g_capacity / spc;
18253ccda647Slclee 	pgeomp->g_acyl = 0;
18263ccda647Slclee 
18273ccda647Slclee 	/*
18283ccda647Slclee 	 * Retrieve fresh geometry data from the hardware, stash it
18293ccda647Slclee 	 * here temporarily before we rebuild the incore label.
18303ccda647Slclee 	 *
18313ccda647Slclee 	 * We want to use the MODE SENSE commands to derive the
18323ccda647Slclee 	 * physical geometry of the device, but if either command
18333ccda647Slclee 	 * fails, the logical geometry is used as the fallback for
18343ccda647Slclee 	 * disk label geometry.
18353ccda647Slclee 	 */
18363ccda647Slclee 
1837e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
1838e8fb11a1Sshidokht 	(void) DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie);
1839e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
18403ccda647Slclee 
18413ccda647Slclee 	/*
18423ccda647Slclee 	 * Now update the real copy while holding the mutex. This
18433ccda647Slclee 	 * way the global copy is never in an inconsistent state.
18443ccda647Slclee 	 */
1845e8fb11a1Sshidokht 	bcopy(pgeomp, &cl->cl_pgeom,  sizeof (cl->cl_pgeom));
18463ccda647Slclee 
1847e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO, cl, "cmlb_resync_geom_caches: "
18483ccda647Slclee 	    "(cached from lgeom)\n");
1849e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl,
18503ccda647Slclee 	    "   ncyl: %ld; acyl: %d; nhead: %d; nsect: %d\n",
1851e8fb11a1Sshidokht 	    cl->cl_pgeom.g_ncyl, cl->cl_pgeom.g_acyl,
1852e8fb11a1Sshidokht 	    cl->cl_pgeom.g_nhead, cl->cl_pgeom.g_nsect);
1853e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl, "   lbasize: %d; capacity: %ld; "
1854e8fb11a1Sshidokht 	    "intrlv: %d; rpm: %d\n", cl->cl_pgeom.g_secsize,
1855e8fb11a1Sshidokht 	    cl->cl_pgeom.g_capacity, cl->cl_pgeom.g_intrlv,
1856e8fb11a1Sshidokht 	    cl->cl_pgeom.g_rpm);
18573ccda647Slclee }
18583ccda647Slclee 
18593ccda647Slclee 
18603ccda647Slclee /*
18613ccda647Slclee  *    Function: cmlb_read_fdisk
18623ccda647Slclee  *
18633ccda647Slclee  * Description: utility routine to read the fdisk table.
18643ccda647Slclee  *
1865e8fb11a1Sshidokht  *   Arguments:
1866e8fb11a1Sshidokht  *	cl		driver soft state (unit) structure
1867e8fb11a1Sshidokht  *	capacity	disk capacity in #blocks
1868e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
1869e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
18703ccda647Slclee  *
18713ccda647Slclee  * Return Code: 0 for success (includes not reading for no_fdisk_present case
18723ccda647Slclee  *		errnos from tg_rw if failed to read the first block.
18733ccda647Slclee  *
18743ccda647Slclee  *     Context: Kernel thread only (can sleep).
18753ccda647Slclee  */
1876e8fb11a1Sshidokht /*ARGSUSED*/
18773ccda647Slclee static int
1878e8fb11a1Sshidokht cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity, void *tg_cookie)
18793ccda647Slclee {
18803ccda647Slclee #if defined(_NO_FDISK_PRESENT)
18813ccda647Slclee 
1882e8fb11a1Sshidokht 	cl->cl_solaris_offset = 0;
1883e8fb11a1Sshidokht 	cl->cl_solaris_size = capacity;
1884e8fb11a1Sshidokht 	bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
18853ccda647Slclee 	return (0);
18863ccda647Slclee 
18873ccda647Slclee #elif defined(_FIRMWARE_NEEDS_FDISK)
18883ccda647Slclee 
18893ccda647Slclee 	struct ipart	*fdp;
18903ccda647Slclee 	struct mboot	*mbp;
18913ccda647Slclee 	struct ipart	fdisk[FD_NUMPART];
1892f85c7842SSuhasini Peddada 	int		i;
18933ccda647Slclee 	char		sigbuf[2];
18943ccda647Slclee 	caddr_t		bufp;
18953ccda647Slclee 	int		uidx;
18963ccda647Slclee 	int 		rval;
18973ccda647Slclee 	int		lba = 0;
18983ccda647Slclee 	uint_t		solaris_offset;	/* offset to solaris part. */
18993ccda647Slclee 	daddr_t		solaris_size;	/* size of solaris partition */
19003ccda647Slclee 	uint32_t	blocksize;
19013ccda647Slclee 
1902e8fb11a1Sshidokht 	ASSERT(cl != NULL);
1903e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
19043ccda647Slclee 
19053ccda647Slclee 	/*
19063ccda647Slclee 	 * Start off assuming no fdisk table
19073ccda647Slclee 	 */
19083ccda647Slclee 	solaris_offset = 0;
19093ccda647Slclee 	solaris_size   = capacity;
19103ccda647Slclee 
1911e8fb11a1Sshidokht 	blocksize = cl->cl_tgt_blocksize;
19123ccda647Slclee 
19133ccda647Slclee 	bufp = kmem_zalloc(blocksize, KM_SLEEP);
19143ccda647Slclee 
1915e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
1916e8fb11a1Sshidokht 	rval = DK_TG_READ(cl, bufp, 0, blocksize, tg_cookie);
1917e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
19183ccda647Slclee 
19193ccda647Slclee 	if (rval != 0) {
1920e8fb11a1Sshidokht 		cmlb_dbg(CMLB_ERROR,  cl,
19213ccda647Slclee 		    "cmlb_read_fdisk: fdisk read err\n");
1922e8fb11a1Sshidokht 		bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
1923e8fb11a1Sshidokht 		goto done;
19243ccda647Slclee 	}
19253ccda647Slclee 
19263ccda647Slclee 	mbp = (struct mboot *)bufp;
19273ccda647Slclee 
19283ccda647Slclee 	/*
19293ccda647Slclee 	 * The fdisk table does not begin on a 4-byte boundary within the
19303ccda647Slclee 	 * master boot record, so we copy it to an aligned structure to avoid
19313ccda647Slclee 	 * alignment exceptions on some processors.
19323ccda647Slclee 	 */
19333ccda647Slclee 	bcopy(&mbp->parts[0], fdisk, sizeof (fdisk));
19343ccda647Slclee 
19353ccda647Slclee 	/*
19363ccda647Slclee 	 * Check for lba support before verifying sig; sig might not be
19373ccda647Slclee 	 * there, say on a blank disk, but the max_chs mark may still
19383ccda647Slclee 	 * be present.
19393ccda647Slclee 	 *
19403ccda647Slclee 	 * Note: LBA support and BEFs are an x86-only concept but this
19413ccda647Slclee 	 * code should work OK on SPARC as well.
19423ccda647Slclee 	 */
19433ccda647Slclee 
19443ccda647Slclee 	/*
19453ccda647Slclee 	 * First, check for lba-access-ok on root node (or prom root node)
19463ccda647Slclee 	 * if present there, don't need to search fdisk table.
19473ccda647Slclee 	 */
19483ccda647Slclee 	if (ddi_getprop(DDI_DEV_T_ANY, ddi_root_node(), 0,
19493ccda647Slclee 	    "lba-access-ok", 0) != 0) {
19503ccda647Slclee 		/* All drives do LBA; don't search fdisk table */
19513ccda647Slclee 		lba = 1;
19523ccda647Slclee 	} else {
19533ccda647Slclee 		/* Okay, look for mark in fdisk table */
19543ccda647Slclee 		for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) {
19553ccda647Slclee 			/* accumulate "lba" value from all partitions */
19563ccda647Slclee 			lba = (lba || cmlb_has_max_chs_vals(fdp));
19573ccda647Slclee 		}
19583ccda647Slclee 	}
19593ccda647Slclee 
19603ccda647Slclee 	if (lba != 0) {
1961e8fb11a1Sshidokht 		dev_t dev = cmlb_make_device(cl);
19623ccda647Slclee 
1963e8fb11a1Sshidokht 		if (ddi_getprop(dev, CMLB_DEVINFO(cl), DDI_PROP_DONTPASS,
19643ccda647Slclee 		    "lba-access-ok", 0) == 0) {
19653ccda647Slclee 			/* not found; create it */
1966e8fb11a1Sshidokht 			if (ddi_prop_create(dev, CMLB_DEVINFO(cl), 0,
19673ccda647Slclee 			    "lba-access-ok", (caddr_t)NULL, 0) !=
19683ccda647Slclee 			    DDI_PROP_SUCCESS) {
1969e8fb11a1Sshidokht 				cmlb_dbg(CMLB_ERROR,  cl,
19703ccda647Slclee 				    "cmlb_read_fdisk: Can't create lba "
19713ccda647Slclee 				    "property for instance %d\n",
1972e8fb11a1Sshidokht 				    ddi_get_instance(CMLB_DEVINFO(cl)));
19733ccda647Slclee 			}
19743ccda647Slclee 		}
19753ccda647Slclee 	}
19763ccda647Slclee 
19773ccda647Slclee 	bcopy(&mbp->signature, sigbuf, sizeof (sigbuf));
19783ccda647Slclee 
19793ccda647Slclee 	/*
19803ccda647Slclee 	 * Endian-independent signature check
19813ccda647Slclee 	 */
19823ccda647Slclee 	if (((sigbuf[1] & 0xFF) != ((MBB_MAGIC >> 8) & 0xFF)) ||
19833ccda647Slclee 	    (sigbuf[0] != (MBB_MAGIC & 0xFF))) {
1984e8fb11a1Sshidokht 		cmlb_dbg(CMLB_ERROR,  cl,
19853ccda647Slclee 		    "cmlb_read_fdisk: no fdisk\n");
1986e8fb11a1Sshidokht 		bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
19873ccda647Slclee 		goto done;
19883ccda647Slclee 	}
19893ccda647Slclee 
19903ccda647Slclee #ifdef CMLBDEBUG
1991e8fb11a1Sshidokht 	if (cmlb_level_mask & CMLB_LOGMASK_INFO) {
19923ccda647Slclee 		fdp = fdisk;
1993e8fb11a1Sshidokht 		cmlb_dbg(CMLB_INFO,  cl, "cmlb_read_fdisk:\n");
1994e8fb11a1Sshidokht 		cmlb_dbg(CMLB_INFO,  cl, "         relsect    "
19953ccda647Slclee 		    "numsect         sysid       bootid\n");
19963ccda647Slclee 		for (i = 0; i < FD_NUMPART; i++, fdp++) {
1997e8fb11a1Sshidokht 			cmlb_dbg(CMLB_INFO,  cl,
19983ccda647Slclee 			    "    %d:  %8d   %8d     0x%08x     0x%08x\n",
19993ccda647Slclee 			    i, fdp->relsect, fdp->numsect,
20003ccda647Slclee 			    fdp->systid, fdp->bootid);
20013ccda647Slclee 		}
20023ccda647Slclee 	}
20033ccda647Slclee #endif
20043ccda647Slclee 
20053ccda647Slclee 	/*
20063ccda647Slclee 	 * Try to find the unix partition
20073ccda647Slclee 	 */
20083ccda647Slclee 	uidx = -1;
20093ccda647Slclee 	solaris_offset = 0;
20103ccda647Slclee 	solaris_size   = 0;
20113ccda647Slclee 
20123ccda647Slclee 	for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) {
2013342440ecSPrasad Singamsetty 		uint32_t relsect;
2014342440ecSPrasad Singamsetty 		uint32_t numsect;
20153ccda647Slclee 
20163ccda647Slclee 		if (fdp->numsect == 0) {
2017e8fb11a1Sshidokht 			cl->cl_fmap[i].fmap_start = 0;
2018e8fb11a1Sshidokht 			cl->cl_fmap[i].fmap_nblk  = 0;
20193ccda647Slclee 			continue;
20203ccda647Slclee 		}
20213ccda647Slclee 
20223ccda647Slclee 		/*
20233ccda647Slclee 		 * Data in the fdisk table is little-endian.
20243ccda647Slclee 		 */
20253ccda647Slclee 		relsect = LE_32(fdp->relsect);
20263ccda647Slclee 		numsect = LE_32(fdp->numsect);
20273ccda647Slclee 
2028e8fb11a1Sshidokht 		cl->cl_fmap[i].fmap_start = relsect;
2029e8fb11a1Sshidokht 		cl->cl_fmap[i].fmap_nblk  = numsect;
20303ccda647Slclee 
20313ccda647Slclee 		if (fdp->systid != SUNIXOS &&
20323ccda647Slclee 		    fdp->systid != SUNIXOS2 &&
20333ccda647Slclee 		    fdp->systid != EFI_PMBR) {
20343ccda647Slclee 			continue;
20353ccda647Slclee 		}
20363ccda647Slclee 
20373ccda647Slclee 		/*
20383ccda647Slclee 		 * use the last active solaris partition id found
20393ccda647Slclee 		 * (there should only be 1 active partition id)
20403ccda647Slclee 		 *
20413ccda647Slclee 		 * if there are no active solaris partition id
20423ccda647Slclee 		 * then use the first inactive solaris partition id
20433ccda647Slclee 		 */
20443ccda647Slclee 		if ((uidx == -1) || (fdp->bootid == ACTIVE)) {
2045f85c7842SSuhasini Peddada 			uidx = i;
2046f85c7842SSuhasini Peddada 			solaris_offset = relsect;
2047f85c7842SSuhasini Peddada 			solaris_size   = numsect;
2048c26dc428SSheshadri Vasudevan 		}
2049c26dc428SSheshadri Vasudevan 	}
2050f85c7842SSuhasini Peddada 
2051e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl, "fdisk 0x%x 0x%lx",
2052e8fb11a1Sshidokht 	    cl->cl_solaris_offset, cl->cl_solaris_size);
20533ccda647Slclee done:
20543ccda647Slclee 
20553ccda647Slclee 	/*
20563ccda647Slclee 	 * Clear the VTOC info, only if the Solaris partition entry
20573ccda647Slclee 	 * has moved, changed size, been deleted, or if the size of
20583ccda647Slclee 	 * the partition is too small to even fit the label sector.
20593ccda647Slclee 	 */
2060e8fb11a1Sshidokht 	if ((cl->cl_solaris_offset != solaris_offset) ||
2061e8fb11a1Sshidokht 	    (cl->cl_solaris_size != solaris_size) ||
20623ccda647Slclee 	    solaris_size <= DK_LABEL_LOC) {
2063e8fb11a1Sshidokht 		cmlb_dbg(CMLB_INFO,  cl, "fdisk moved 0x%x 0x%lx",
2064e8fb11a1Sshidokht 		    solaris_offset, solaris_size);
2065e8fb11a1Sshidokht 		bzero(&cl->cl_g, sizeof (struct dk_geom));
2066e8fb11a1Sshidokht 		bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
2067e8fb11a1Sshidokht 		bzero(&cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
2068e8fb11a1Sshidokht 		cl->cl_f_geometry_is_valid = FALSE;
2069e8fb11a1Sshidokht 	}
2070e8fb11a1Sshidokht 	cl->cl_solaris_offset = solaris_offset;
2071e8fb11a1Sshidokht 	cl->cl_solaris_size = solaris_size;
20723ccda647Slclee 	kmem_free(bufp, blocksize);
20733ccda647Slclee 	return (rval);
20743ccda647Slclee 
20753ccda647Slclee #else	/* #elif defined(_FIRMWARE_NEEDS_FDISK) */
20763ccda647Slclee #error "fdisk table presence undetermined for this platform."
20773ccda647Slclee #endif	/* #if defined(_NO_FDISK_PRESENT) */
20783ccda647Slclee }
20793ccda647Slclee 
20803ccda647Slclee static void
20813ccda647Slclee cmlb_swap_efi_gpt(efi_gpt_t *e)
20823ccda647Slclee {
20833ccda647Slclee 	_NOTE(ASSUMING_PROTECTED(*e))
20843ccda647Slclee 	e->efi_gpt_Signature = LE_64(e->efi_gpt_Signature);
20853ccda647Slclee 	e->efi_gpt_Revision = LE_32(e->efi_gpt_Revision);
20863ccda647Slclee 	e->efi_gpt_HeaderSize = LE_32(e->efi_gpt_HeaderSize);
20873ccda647Slclee 	e->efi_gpt_HeaderCRC32 = LE_32(e->efi_gpt_HeaderCRC32);
20883ccda647Slclee 	e->efi_gpt_MyLBA = LE_64(e->efi_gpt_MyLBA);
20893ccda647Slclee 	e->efi_gpt_AlternateLBA = LE_64(e->efi_gpt_AlternateLBA);
20903ccda647Slclee 	e->efi_gpt_FirstUsableLBA = LE_64(e->efi_gpt_FirstUsableLBA);
20913ccda647Slclee 	e->efi_gpt_LastUsableLBA = LE_64(e->efi_gpt_LastUsableLBA);
20923ccda647Slclee 	UUID_LE_CONVERT(e->efi_gpt_DiskGUID, e->efi_gpt_DiskGUID);
20933ccda647Slclee 	e->efi_gpt_PartitionEntryLBA = LE_64(e->efi_gpt_PartitionEntryLBA);
20943ccda647Slclee 	e->efi_gpt_NumberOfPartitionEntries =
20953ccda647Slclee 	    LE_32(e->efi_gpt_NumberOfPartitionEntries);
20963ccda647Slclee 	e->efi_gpt_SizeOfPartitionEntry =
20973ccda647Slclee 	    LE_32(e->efi_gpt_SizeOfPartitionEntry);
20983ccda647Slclee 	e->efi_gpt_PartitionEntryArrayCRC32 =
20993ccda647Slclee 	    LE_32(e->efi_gpt_PartitionEntryArrayCRC32);
21003ccda647Slclee }
21013ccda647Slclee 
21023ccda647Slclee static void
21033ccda647Slclee cmlb_swap_efi_gpe(int nparts, efi_gpe_t *p)
21043ccda647Slclee {
21053ccda647Slclee 	int i;
21063ccda647Slclee 
21073ccda647Slclee 	_NOTE(ASSUMING_PROTECTED(*p))
21083ccda647Slclee 	for (i = 0; i < nparts; i++) {
21093ccda647Slclee 		UUID_LE_CONVERT(p[i].efi_gpe_PartitionTypeGUID,
21103ccda647Slclee 		    p[i].efi_gpe_PartitionTypeGUID);
21113ccda647Slclee 		p[i].efi_gpe_StartingLBA = LE_64(p[i].efi_gpe_StartingLBA);
21123ccda647Slclee 		p[i].efi_gpe_EndingLBA = LE_64(p[i].efi_gpe_EndingLBA);
21133ccda647Slclee 		/* PartitionAttrs */
21143ccda647Slclee 	}
21153ccda647Slclee }
21163ccda647Slclee 
21173ccda647Slclee static int
21183ccda647Slclee cmlb_validate_efi(efi_gpt_t *labp)
21193ccda647Slclee {
21203ccda647Slclee 	if (labp->efi_gpt_Signature != EFI_SIGNATURE)
21213ccda647Slclee 		return (EINVAL);
21223ccda647Slclee 	/* at least 96 bytes in this version of the spec. */
21233ccda647Slclee 	if (sizeof (efi_gpt_t) - sizeof (labp->efi_gpt_Reserved2) >
21243ccda647Slclee 	    labp->efi_gpt_HeaderSize)
21253ccda647Slclee 		return (EINVAL);
21263ccda647Slclee 	/* this should be 128 bytes */
21273ccda647Slclee 	if (labp->efi_gpt_SizeOfPartitionEntry != sizeof (efi_gpe_t))
21283ccda647Slclee 		return (EINVAL);
21293ccda647Slclee 	return (0);
21303ccda647Slclee }
21313ccda647Slclee 
2132ab92f716Sshidokht /*
2133ab92f716Sshidokht  * This function returns FALSE if there is a valid MBR signature and no
2134ab92f716Sshidokht  * partition table entries of type EFI_PMBR (0xEE). Otherwise it returns TRUE.
2135ab92f716Sshidokht  *
2136ab92f716Sshidokht  * The EFI spec (1.10 and later) requires having a Protective MBR (PMBR) to
2137ab92f716Sshidokht  * recognize the disk as GPT partitioned. However, some other OS creates an MBR
2138ab92f716Sshidokht  * where a PMBR entry is not the only one. Also, if the first block has been
2139ab92f716Sshidokht  * corrupted, currently best attempt to allow data access would be to try to
2140ab92f716Sshidokht  * check for GPT headers. Hence in case of more than one partition entry, but
2141ab92f716Sshidokht  * at least one EFI_PMBR partition type or no valid magic number, the function
2142ab92f716Sshidokht  * returns TRUE to continue with looking for GPT header.
2143ab92f716Sshidokht  */
2144ab92f716Sshidokht 
2145ab92f716Sshidokht static int
2146342440ecSPrasad Singamsetty cmlb_check_efi_mbr(uchar_t *buf, int *is_mbr)
2147ab92f716Sshidokht {
2148ab92f716Sshidokht 	struct ipart	*fdp;
2149ab92f716Sshidokht 	struct mboot	*mbp = (struct mboot *)buf;
2150ab92f716Sshidokht 	struct ipart	fdisk[FD_NUMPART];
2151ab92f716Sshidokht 	int		i;
2152ab92f716Sshidokht 
2153342440ecSPrasad Singamsetty 	if (is_mbr != NULL)
2154342440ecSPrasad Singamsetty 		*is_mbr = TRUE;
2155342440ecSPrasad Singamsetty 
2156342440ecSPrasad Singamsetty 	if (LE_16(mbp->signature) != MBB_MAGIC) {
2157342440ecSPrasad Singamsetty 		if (is_mbr != NULL)
2158*7e70b434SShidokht Yadegari 			*is_mbr = FALSE;
2159ab92f716Sshidokht 		return (TRUE);
2160342440ecSPrasad Singamsetty 	}
2161ab92f716Sshidokht 
2162ab92f716Sshidokht 	bcopy(&mbp->parts[0], fdisk, sizeof (fdisk));
2163ab92f716Sshidokht 
2164ab92f716Sshidokht 	for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) {
2165ab92f716Sshidokht 		if (fdp->systid == EFI_PMBR)
2166ab92f716Sshidokht 			return (TRUE);
2167ab92f716Sshidokht 	}
2168ab92f716Sshidokht 
2169ab92f716Sshidokht 	return (FALSE);
2170ab92f716Sshidokht }
2171ab92f716Sshidokht 
21723ccda647Slclee static int
2173e8fb11a1Sshidokht cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags,
2174e8fb11a1Sshidokht     void *tg_cookie)
21753ccda647Slclee {
21763ccda647Slclee 	int		i;
21773ccda647Slclee 	int		rval = 0;
21783ccda647Slclee 	efi_gpe_t	*partitions;
21793ccda647Slclee 	uchar_t		*buf;
21803ccda647Slclee 	uint_t		lbasize;	/* is really how much to read */
2181e8fb11a1Sshidokht 	diskaddr_t	cap = 0;
21823ccda647Slclee 	uint_t		nparts;
21833ccda647Slclee 	diskaddr_t	gpe_lba;
2184af007057Syl 	diskaddr_t	alternate_lba;
21851cec2d8cSshidokht 	int		iofailed = 0;
2186e8fb11a1Sshidokht 	struct uuid	uuid_type_reserved = EFI_RESERVED;
2187342440ecSPrasad Singamsetty #if defined(_FIRMWARE_NEEDS_FDISK)
2188342440ecSPrasad Singamsetty 		int 		is_mbr;
2189342440ecSPrasad Singamsetty #endif
21903ccda647Slclee 
2191e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
21923ccda647Slclee 
2193e8fb11a1Sshidokht 	if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) {
2194e8fb11a1Sshidokht 		rval = EINVAL;
2195e8fb11a1Sshidokht 		goto done_err1;
2196e8fb11a1Sshidokht 	}
2197e8fb11a1Sshidokht 
2198e8fb11a1Sshidokht 
2199e8fb11a1Sshidokht 	lbasize = cl->cl_sys_blocksize;
2200e8fb11a1Sshidokht 
2201e8fb11a1Sshidokht 	cl->cl_reserved = -1;
2202e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
22033ccda647Slclee 
22043ccda647Slclee 	buf = kmem_zalloc(EFI_MIN_ARRAY_SIZE, KM_SLEEP);
22053ccda647Slclee 
2206342440ecSPrasad Singamsetty 	rval = DK_TG_READ(cl, buf,  0, lbasize, tg_cookie);
22073ccda647Slclee 	if (rval) {
22081cec2d8cSshidokht 		iofailed = 1;
22093ccda647Slclee 		goto done_err;
22103ccda647Slclee 	}
22113ccda647Slclee 	if (((struct dk_label *)buf)->dkl_magic == DKL_MAGIC) {
22123ccda647Slclee 		/* not ours */
22133ccda647Slclee 		rval = ESRCH;
22143ccda647Slclee 		goto done_err;
22153ccda647Slclee 	}
22163ccda647Slclee 
2217342440ecSPrasad Singamsetty #if defined(_FIRMWARE_NEEDS_FDISK)
2218342440ecSPrasad Singamsetty 	if (cmlb_check_efi_mbr(buf, &is_mbr) == FALSE) {
2219342440ecSPrasad Singamsetty 		if (is_mbr == TRUE)
2220342440ecSPrasad Singamsetty 			rval = ESRCH;
2221342440ecSPrasad Singamsetty 		else
2222342440ecSPrasad Singamsetty 			rval = EINVAL;
2223342440ecSPrasad Singamsetty 		goto done_err;
2224342440ecSPrasad Singamsetty 	}
2225342440ecSPrasad Singamsetty #else
2226342440ecSPrasad Singamsetty 	if (cmlb_check_efi_mbr(buf, NULL) == FALSE) {
2227ab92f716Sshidokht 		rval = EINVAL;
2228ab92f716Sshidokht 		goto done_err;
2229ab92f716Sshidokht 	}
2230ab92f716Sshidokht 
2231342440ecSPrasad Singamsetty #endif
2232342440ecSPrasad Singamsetty 
2233e8fb11a1Sshidokht 	rval = DK_TG_READ(cl, buf, 1, lbasize, tg_cookie);
22343ccda647Slclee 	if (rval) {
22351cec2d8cSshidokht 		iofailed = 1;
22363ccda647Slclee 		goto done_err;
22373ccda647Slclee 	}
22383ccda647Slclee 	cmlb_swap_efi_gpt((efi_gpt_t *)buf);
22393ccda647Slclee 
22403ccda647Slclee 	if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0) {
22413ccda647Slclee 		/*
22423ccda647Slclee 		 * Couldn't read the primary, try the backup.  Our
22433ccda647Slclee 		 * capacity at this point could be based on CHS, so
22443ccda647Slclee 		 * check what the device reports.
22453ccda647Slclee 		 */
2246e8fb11a1Sshidokht 		rval = DK_TG_GETCAP(cl, &cap, tg_cookie);
22473ccda647Slclee 		if (rval) {
22481cec2d8cSshidokht 			iofailed = 1;
22493ccda647Slclee 			goto done_err;
22503ccda647Slclee 		}
2251e8fb11a1Sshidokht 
2252e8fb11a1Sshidokht 		/*
2253e8fb11a1Sshidokht 		 * CMLB_OFF_BY_ONE case, we check the next to last block first
2254e8fb11a1Sshidokht 		 * for backup GPT header, otherwise check the last block.
2255e8fb11a1Sshidokht 		 */
2256e8fb11a1Sshidokht 
2257e8fb11a1Sshidokht 		if ((rval = DK_TG_READ(cl, buf,
2258e8fb11a1Sshidokht 		    cap - ((cl->cl_alter_behavior & CMLB_OFF_BY_ONE) ? 2 : 1),
2259e8fb11a1Sshidokht 		    lbasize, tg_cookie))
2260e8fb11a1Sshidokht 		    != 0) {
22611cec2d8cSshidokht 			iofailed = 1;
22623ccda647Slclee 			goto done_err;
22633ccda647Slclee 		}
22643ccda647Slclee 		cmlb_swap_efi_gpt((efi_gpt_t *)buf);
2265e8fb11a1Sshidokht 
2266e8fb11a1Sshidokht 		if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0) {
2267e8fb11a1Sshidokht 
2268e8fb11a1Sshidokht 			if (!(cl->cl_alter_behavior & CMLB_OFF_BY_ONE))
2269e8fb11a1Sshidokht 				goto done_err;
2270e8fb11a1Sshidokht 			if ((rval = DK_TG_READ(cl, buf, cap - 1, lbasize,
2271e8fb11a1Sshidokht 			    tg_cookie)) != 0)
2272e8fb11a1Sshidokht 				goto done_err;
2273e8fb11a1Sshidokht 			cmlb_swap_efi_gpt((efi_gpt_t *)buf);
2274e8fb11a1Sshidokht 			if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0)
2275e8fb11a1Sshidokht 				goto done_err;
2276e8fb11a1Sshidokht 		}
2277e8fb11a1Sshidokht 		if (!(flags & CMLB_SILENT))
2278e8fb11a1Sshidokht 			cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
2279e8fb11a1Sshidokht 			    "primary label corrupt; using backup\n");
22803ccda647Slclee 	}
22813ccda647Slclee 
22823ccda647Slclee 	nparts = ((efi_gpt_t *)buf)->efi_gpt_NumberOfPartitionEntries;
22833ccda647Slclee 	gpe_lba = ((efi_gpt_t *)buf)->efi_gpt_PartitionEntryLBA;
2284af007057Syl 	alternate_lba = ((efi_gpt_t *)buf)->efi_gpt_AlternateLBA;
22853ccda647Slclee 
2286e8fb11a1Sshidokht 	rval = DK_TG_READ(cl, buf, gpe_lba, EFI_MIN_ARRAY_SIZE, tg_cookie);
22873ccda647Slclee 	if (rval) {
22881cec2d8cSshidokht 		iofailed = 1;
22893ccda647Slclee 		goto done_err;
22903ccda647Slclee 	}
22913ccda647Slclee 	partitions = (efi_gpe_t *)buf;
22923ccda647Slclee 
22933ccda647Slclee 	if (nparts > MAXPART) {
22943ccda647Slclee 		nparts = MAXPART;
22953ccda647Slclee 	}
22963ccda647Slclee 	cmlb_swap_efi_gpe(nparts, partitions);
22973ccda647Slclee 
2298e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
22993ccda647Slclee 
23003ccda647Slclee 	/* Fill in partition table. */
23013ccda647Slclee 	for (i = 0; i < nparts; i++) {
23023ccda647Slclee 		if (partitions->efi_gpe_StartingLBA != 0 ||
23033ccda647Slclee 		    partitions->efi_gpe_EndingLBA != 0) {
2304e8fb11a1Sshidokht 			cl->cl_map[i].dkl_cylno =
23053ccda647Slclee 			    partitions->efi_gpe_StartingLBA;
2306e8fb11a1Sshidokht 			cl->cl_map[i].dkl_nblk =
23073ccda647Slclee 			    partitions->efi_gpe_EndingLBA -
23083ccda647Slclee 			    partitions->efi_gpe_StartingLBA + 1;
2309e8fb11a1Sshidokht 			cl->cl_offset[i] =
23103ccda647Slclee 			    partitions->efi_gpe_StartingLBA;
23113ccda647Slclee 		}
2312e8fb11a1Sshidokht 
2313e8fb11a1Sshidokht 		if (cl->cl_reserved == -1) {
2314e8fb11a1Sshidokht 			if (bcmp(&partitions->efi_gpe_PartitionTypeGUID,
2315e8fb11a1Sshidokht 			    &uuid_type_reserved, sizeof (struct uuid)) == 0) {
2316e8fb11a1Sshidokht 				cl->cl_reserved = i;
2317e8fb11a1Sshidokht 			}
2318e8fb11a1Sshidokht 		}
23193ccda647Slclee 		if (i == WD_NODE) {
23203ccda647Slclee 			/*
23213ccda647Slclee 			 * minor number 7 corresponds to the whole disk
2322af007057Syl 			 * if the disk capacity is expanded after disk is
2323af007057Syl 			 * labeled, minor number 7 represents the capacity
2324af007057Syl 			 * indicated by the disk label.
23253ccda647Slclee 			 */
2326e8fb11a1Sshidokht 			cl->cl_map[i].dkl_cylno = 0;
2327af007057Syl 			if (alternate_lba == 1) {
2328af007057Syl 				/*
2329af007057Syl 				 * We are using backup label. Since we can
2330af007057Syl 				 * find a valid label at the end of disk,
2331af007057Syl 				 * the disk capacity is not expanded.
2332af007057Syl 				 */
2333af007057Syl 				cl->cl_map[i].dkl_nblk = capacity;
2334af007057Syl 			} else {
2335af007057Syl 				cl->cl_map[i].dkl_nblk = alternate_lba + 1;
2336af007057Syl 			}
2337e8fb11a1Sshidokht 			cl->cl_offset[i] = 0;
23383ccda647Slclee 		}
23393ccda647Slclee 		partitions++;
23403ccda647Slclee 	}
2341e8fb11a1Sshidokht 	cl->cl_solaris_offset = 0;
2342e8fb11a1Sshidokht 	cl->cl_solaris_size = capacity;
2343342440ecSPrasad Singamsetty 	cl->cl_label_from_media = CMLB_LABEL_EFI;
2344e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = TRUE;
2345e8fb11a1Sshidokht 
2346e8fb11a1Sshidokht 	/* clear the vtoc label */
2347e8fb11a1Sshidokht 	bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
2348e8fb11a1Sshidokht 
23493ccda647Slclee 	kmem_free(buf, EFI_MIN_ARRAY_SIZE);
23503ccda647Slclee 	return (0);
23513ccda647Slclee 
23523ccda647Slclee done_err:
23533ccda647Slclee 	kmem_free(buf, EFI_MIN_ARRAY_SIZE);
2354e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
2355e8fb11a1Sshidokht done_err1:
23563ccda647Slclee 	/*
23573ccda647Slclee 	 * if we didn't find something that could look like a VTOC
23583ccda647Slclee 	 * and the disk is over 1TB, we know there isn't a valid label.
23593ccda647Slclee 	 * Otherwise let cmlb_uselabel decide what to do.  We only
23603ccda647Slclee 	 * want to invalidate this if we're certain the label isn't
23613ccda647Slclee 	 * valid because cmlb_prop_op will now fail, which in turn
23623ccda647Slclee 	 * causes things like opens and stats on the partition to fail.
23633ccda647Slclee 	 */
2364342440ecSPrasad Singamsetty 	if ((capacity > CMLB_EXTVTOC_LIMIT) && (rval != ESRCH) && !iofailed) {
2365e8fb11a1Sshidokht 		cl->cl_f_geometry_is_valid = FALSE;
23663ccda647Slclee 	}
23673ccda647Slclee 	return (rval);
23683ccda647Slclee }
23693ccda647Slclee 
23703ccda647Slclee 
23713ccda647Slclee /*
23723ccda647Slclee  *    Function: cmlb_uselabel
23733ccda647Slclee  *
23743ccda647Slclee  * Description: Validate the disk label and update the relevant data (geometry,
23753ccda647Slclee  *		partition, vtoc, and capacity data) in the cmlb_lun struct.
23763ccda647Slclee  *		Marks the geometry of the unit as being valid.
23773ccda647Slclee  *
2378e8fb11a1Sshidokht  *   Arguments: cl: unit struct.
23793ccda647Slclee  *		dk_label: disk label
23803ccda647Slclee  *
23813ccda647Slclee  * Return Code: CMLB_LABEL_IS_VALID: Label read from disk is OK; geometry,
23823ccda647Slclee  *		partition, vtoc, and capacity data are good.
23833ccda647Slclee  *
23843ccda647Slclee  *		CMLB_LABEL_IS_INVALID: Magic number or checksum error in the
23853ccda647Slclee  *		label; or computed capacity does not jibe with capacity
23863ccda647Slclee  *		reported from the READ CAPACITY command.
23873ccda647Slclee  *
23883ccda647Slclee  *     Context: Kernel thread only (can sleep).
23893ccda647Slclee  */
23903ccda647Slclee static int
2391e8fb11a1Sshidokht cmlb_uselabel(struct cmlb_lun *cl, struct dk_label *labp, int flags)
23923ccda647Slclee {
23933ccda647Slclee 	short		*sp;
23943ccda647Slclee 	short		sum;
23953ccda647Slclee 	short		count;
23963ccda647Slclee 	int		label_error = CMLB_LABEL_IS_VALID;
23973ccda647Slclee 	int		i;
23983ccda647Slclee 	diskaddr_t	label_capacity;
2399342440ecSPrasad Singamsetty 	uint32_t	part_end;
24003ccda647Slclee 	diskaddr_t	track_capacity;
24013ccda647Slclee #if defined(_SUNOS_VTOC_16)
24023ccda647Slclee 	struct	dkl_partition	*vpartp;
24033ccda647Slclee #endif
2404e8fb11a1Sshidokht 	ASSERT(cl != NULL);
2405e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
24063ccda647Slclee 
24073ccda647Slclee 	/* Validate the magic number of the label. */
24083ccda647Slclee 	if (labp->dkl_magic != DKL_MAGIC) {
24093ccda647Slclee #if defined(__sparc)
2410e8fb11a1Sshidokht 		if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
2411e8fb11a1Sshidokht 			if (!(flags & CMLB_SILENT))
2412e8fb11a1Sshidokht 				cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
2413e8fb11a1Sshidokht 				    CE_WARN,
2414e8fb11a1Sshidokht 				    "Corrupt label; wrong magic number\n");
24153ccda647Slclee 		}
24163ccda647Slclee #endif
24173ccda647Slclee 		return (CMLB_LABEL_IS_INVALID);
24183ccda647Slclee 	}
24193ccda647Slclee 
24203ccda647Slclee 	/* Validate the checksum of the label. */
24213ccda647Slclee 	sp  = (short *)labp;
24223ccda647Slclee 	sum = 0;
24233ccda647Slclee 	count = sizeof (struct dk_label) / sizeof (short);
24243ccda647Slclee 	while (count--)	 {
24253ccda647Slclee 		sum ^= *sp++;
24263ccda647Slclee 	}
24273ccda647Slclee 
24283ccda647Slclee 	if (sum != 0) {
24293ccda647Slclee #if defined(_SUNOS_VTOC_16)
2430e8fb11a1Sshidokht 		if (!ISCD(cl)) {
24313ccda647Slclee #elif defined(_SUNOS_VTOC_8)
2432e8fb11a1Sshidokht 		if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
24333ccda647Slclee #endif
2434e8fb11a1Sshidokht 			if (!(flags & CMLB_SILENT))
2435e8fb11a1Sshidokht 				cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
2436e8fb11a1Sshidokht 				    CE_WARN,
2437e8fb11a1Sshidokht 				    "Corrupt label - label checksum failed\n");
24383ccda647Slclee 		}
24393ccda647Slclee 		return (CMLB_LABEL_IS_INVALID);
24403ccda647Slclee 	}
24413ccda647Slclee 
24423ccda647Slclee 
24433ccda647Slclee 	/*
24443ccda647Slclee 	 * Fill in geometry structure with data from label.
24453ccda647Slclee 	 */
2446e8fb11a1Sshidokht 	bzero(&cl->cl_g, sizeof (struct dk_geom));
2447e8fb11a1Sshidokht 	cl->cl_g.dkg_ncyl   = labp->dkl_ncyl;
2448e8fb11a1Sshidokht 	cl->cl_g.dkg_acyl   = labp->dkl_acyl;
2449e8fb11a1Sshidokht 	cl->cl_g.dkg_bcyl   = 0;
2450e8fb11a1Sshidokht 	cl->cl_g.dkg_nhead  = labp->dkl_nhead;
2451e8fb11a1Sshidokht 	cl->cl_g.dkg_nsect  = labp->dkl_nsect;
2452e8fb11a1Sshidokht 	cl->cl_g.dkg_intrlv = labp->dkl_intrlv;
24533ccda647Slclee 
24543ccda647Slclee #if defined(_SUNOS_VTOC_8)
2455e8fb11a1Sshidokht 	cl->cl_g.dkg_gap1   = labp->dkl_gap1;
2456e8fb11a1Sshidokht 	cl->cl_g.dkg_gap2   = labp->dkl_gap2;
2457e8fb11a1Sshidokht 	cl->cl_g.dkg_bhead  = labp->dkl_bhead;
24583ccda647Slclee #endif
24593ccda647Slclee #if defined(_SUNOS_VTOC_16)
2460e8fb11a1Sshidokht 	cl->cl_dkg_skew = labp->dkl_skew;
24613ccda647Slclee #endif
24623ccda647Slclee 
24633ccda647Slclee #if defined(__i386) || defined(__amd64)
2464e8fb11a1Sshidokht 	cl->cl_g.dkg_apc = labp->dkl_apc;
24653ccda647Slclee #endif
24663ccda647Slclee 
24673ccda647Slclee 	/*
24683ccda647Slclee 	 * Currently we rely on the values in the label being accurate. If
24693ccda647Slclee 	 * dkl_rpm or dkl_pcly are zero in the label, use a default value.
24703ccda647Slclee 	 *
24713ccda647Slclee 	 * Note: In the future a MODE SENSE may be used to retrieve this data,
24723ccda647Slclee 	 * although this command is optional in SCSI-2.
24733ccda647Slclee 	 */
2474e8fb11a1Sshidokht 	cl->cl_g.dkg_rpm  = (labp->dkl_rpm  != 0) ? labp->dkl_rpm  : 3600;
2475e8fb11a1Sshidokht 	cl->cl_g.dkg_pcyl = (labp->dkl_pcyl != 0) ? labp->dkl_pcyl :
2476e8fb11a1Sshidokht 	    (cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl);
24773ccda647Slclee 
24783ccda647Slclee 	/*
24793ccda647Slclee 	 * The Read and Write reinstruct values may not be valid
24803ccda647Slclee 	 * for older disks.
24813ccda647Slclee 	 */
2482e8fb11a1Sshidokht 	cl->cl_g.dkg_read_reinstruct  = labp->dkl_read_reinstruct;
2483e8fb11a1Sshidokht 	cl->cl_g.dkg_write_reinstruct = labp->dkl_write_reinstruct;
24843ccda647Slclee 
24853ccda647Slclee 	/* Fill in partition table. */
24863ccda647Slclee #if defined(_SUNOS_VTOC_8)
24873ccda647Slclee 	for (i = 0; i < NDKMAP; i++) {
2488e8fb11a1Sshidokht 		cl->cl_map[i].dkl_cylno = labp->dkl_map[i].dkl_cylno;
2489e8fb11a1Sshidokht 		cl->cl_map[i].dkl_nblk  = labp->dkl_map[i].dkl_nblk;
24903ccda647Slclee 	}
24913ccda647Slclee #endif
24923ccda647Slclee #if  defined(_SUNOS_VTOC_16)
24933ccda647Slclee 	vpartp		= labp->dkl_vtoc.v_part;
24943ccda647Slclee 	track_capacity	= labp->dkl_nhead * labp->dkl_nsect;
24953ccda647Slclee 
2496e8fb11a1Sshidokht 	/* Prevent divide by zero */
2497e8fb11a1Sshidokht 	if (track_capacity == 0) {
2498e8fb11a1Sshidokht 		if (!(flags & CMLB_SILENT))
2499e8fb11a1Sshidokht 			cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
2500e8fb11a1Sshidokht 			    "Corrupt label - zero nhead or nsect value\n");
2501e8fb11a1Sshidokht 
2502e8fb11a1Sshidokht 		return (CMLB_LABEL_IS_INVALID);
2503e8fb11a1Sshidokht 	}
2504e8fb11a1Sshidokht 
25053ccda647Slclee 	for (i = 0; i < NDKMAP; i++, vpartp++) {
2506e8fb11a1Sshidokht 		cl->cl_map[i].dkl_cylno = vpartp->p_start / track_capacity;
2507e8fb11a1Sshidokht 		cl->cl_map[i].dkl_nblk  = vpartp->p_size;
25083ccda647Slclee 	}
25093ccda647Slclee #endif
25103ccda647Slclee 
25113ccda647Slclee 	/* Fill in VTOC Structure. */
2512e8fb11a1Sshidokht 	bcopy(&labp->dkl_vtoc, &cl->cl_vtoc, sizeof (struct dk_vtoc));
25133ccda647Slclee #if defined(_SUNOS_VTOC_8)
25143ccda647Slclee 	/*
25153ccda647Slclee 	 * The 8-slice vtoc does not include the ascii label; save it into
25163ccda647Slclee 	 * the device's soft state structure here.
25173ccda647Slclee 	 */
2518e8fb11a1Sshidokht 	bcopy(labp->dkl_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII);
25193ccda647Slclee #endif
25203ccda647Slclee 
25213ccda647Slclee 	/* Now look for a valid capacity. */
2522e8fb11a1Sshidokht 	track_capacity	= (cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect);
2523e8fb11a1Sshidokht 	label_capacity	= (cl->cl_g.dkg_ncyl  * track_capacity);
25243ccda647Slclee 
2525e8fb11a1Sshidokht 	if (cl->cl_g.dkg_acyl) {
25263ccda647Slclee #if defined(__i386) || defined(__amd64)
25273ccda647Slclee 		/* we may have > 1 alts cylinder */
2528e8fb11a1Sshidokht 		label_capacity += (track_capacity * cl->cl_g.dkg_acyl);
25293ccda647Slclee #else
25303ccda647Slclee 		label_capacity += track_capacity;
25313ccda647Slclee #endif
25323ccda647Slclee 	}
25333ccda647Slclee 
2534e8fb11a1Sshidokht 	/*
2535e8fb11a1Sshidokht 	 * Force check here to ensure the computed capacity is valid.
2536e8fb11a1Sshidokht 	 * If capacity is zero, it indicates an invalid label and
2537e8fb11a1Sshidokht 	 * we should abort updating the relevant data then.
2538e8fb11a1Sshidokht 	 */
2539e8fb11a1Sshidokht 	if (label_capacity == 0) {
2540e8fb11a1Sshidokht 		if (!(flags & CMLB_SILENT))
2541e8fb11a1Sshidokht 			cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
2542e8fb11a1Sshidokht 			    "Corrupt label - no valid capacity could be "
2543e8fb11a1Sshidokht 			    "retrieved\n");
2544e8fb11a1Sshidokht 
2545e8fb11a1Sshidokht 		return (CMLB_LABEL_IS_INVALID);
2546e8fb11a1Sshidokht 	}
2547e8fb11a1Sshidokht 
2548e8fb11a1Sshidokht 	/* Mark the geometry as valid. */
2549e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = TRUE;
2550e8fb11a1Sshidokht 
25513ccda647Slclee 	/*
25523ccda647Slclee 	 * if we got invalidated when mutex exit and entered again,
25533ccda647Slclee 	 * if blockcount different than when we came in, need to
25543ccda647Slclee 	 * retry from beginning of cmlb_validate_geometry.
25553ccda647Slclee 	 * revisit this on next phase of utilizing this for
25563ccda647Slclee 	 * sd.
25573ccda647Slclee 	 */
25583ccda647Slclee 
2559e8fb11a1Sshidokht 	if (label_capacity <= cl->cl_blockcount) {
25603ccda647Slclee #if defined(_SUNOS_VTOC_8)
25613ccda647Slclee 		/*
25623ccda647Slclee 		 * We can't let this happen on drives that are subdivided
25633ccda647Slclee 		 * into logical disks (i.e., that have an fdisk table).
2564e8fb11a1Sshidokht 		 * The cl_blockcount field should always hold the full media
25653ccda647Slclee 		 * size in sectors, period.  This code would overwrite
2566e8fb11a1Sshidokht 		 * cl_blockcount with the size of the Solaris fdisk partition.
25673ccda647Slclee 		 */
2568e8fb11a1Sshidokht 		cmlb_dbg(CMLB_ERROR,  cl,
25693ccda647Slclee 		    "cmlb_uselabel: Label %d blocks; Drive %d blocks\n",
2570e8fb11a1Sshidokht 		    label_capacity, cl->cl_blockcount);
2571e8fb11a1Sshidokht 		cl->cl_solaris_size = label_capacity;
25723ccda647Slclee 
25733ccda647Slclee #endif	/* defined(_SUNOS_VTOC_8) */
25743ccda647Slclee 		goto done;
25753ccda647Slclee 	}
25763ccda647Slclee 
2577e8fb11a1Sshidokht 	if (ISCD(cl)) {
25783ccda647Slclee 		/* For CDROMs, we trust that the data in the label is OK. */
25793ccda647Slclee #if defined(_SUNOS_VTOC_8)
25803ccda647Slclee 		for (i = 0; i < NDKMAP; i++) {
25813ccda647Slclee 			part_end = labp->dkl_nhead * labp->dkl_nsect *
25823ccda647Slclee 			    labp->dkl_map[i].dkl_cylno +
25833ccda647Slclee 			    labp->dkl_map[i].dkl_nblk  - 1;
25843ccda647Slclee 
25853ccda647Slclee 			if ((labp->dkl_map[i].dkl_nblk) &&
2586e8fb11a1Sshidokht 			    (part_end > cl->cl_blockcount)) {
2587e8fb11a1Sshidokht 				cl->cl_f_geometry_is_valid = FALSE;
25883ccda647Slclee 				break;
25893ccda647Slclee 			}
25903ccda647Slclee 		}
25913ccda647Slclee #endif
25923ccda647Slclee #if defined(_SUNOS_VTOC_16)
25933ccda647Slclee 		vpartp = &(labp->dkl_vtoc.v_part[0]);
25943ccda647Slclee 		for (i = 0; i < NDKMAP; i++, vpartp++) {
25953ccda647Slclee 			part_end = vpartp->p_start + vpartp->p_size;
25963ccda647Slclee 			if ((vpartp->p_size > 0) &&
2597e8fb11a1Sshidokht 			    (part_end > cl->cl_blockcount)) {
2598e8fb11a1Sshidokht 				cl->cl_f_geometry_is_valid = FALSE;
25993ccda647Slclee 				break;
26003ccda647Slclee 			}
26013ccda647Slclee 		}
26023ccda647Slclee #endif
26033ccda647Slclee 	} else {
2604e8fb11a1Sshidokht 		/* label_capacity > cl->cl_blockcount */
2605e8fb11a1Sshidokht 		if (!(flags & CMLB_SILENT)) {
2606e8fb11a1Sshidokht 			cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
2607e8fb11a1Sshidokht 			    "Corrupt label - bad geometry\n");
2608e8fb11a1Sshidokht 			cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_CONT,
2609e8fb11a1Sshidokht 			    "Label says %llu blocks; Drive says %llu blocks\n",
2610e8fb11a1Sshidokht 			    label_capacity, cl->cl_blockcount);
2611e8fb11a1Sshidokht 		}
2612e8fb11a1Sshidokht 		cl->cl_f_geometry_is_valid = FALSE;
26133ccda647Slclee 		label_error = CMLB_LABEL_IS_INVALID;
26143ccda647Slclee 	}
26153ccda647Slclee 
26163ccda647Slclee done:
26173ccda647Slclee 
2618e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl, "cmlb_uselabel: (label geometry)\n");
2619e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl,
26203ccda647Slclee 	    "   ncyl: %d; acyl: %d; nhead: %d; nsect: %d\n",
2621e8fb11a1Sshidokht 	    cl->cl_g.dkg_ncyl,  cl->cl_g.dkg_acyl,
2622e8fb11a1Sshidokht 	    cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
26233ccda647Slclee 
2624e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl,
26253ccda647Slclee 	    "   label_capacity: %d; intrlv: %d; rpm: %d\n",
2626e8fb11a1Sshidokht 	    cl->cl_blockcount, cl->cl_g.dkg_intrlv, cl->cl_g.dkg_rpm);
2627e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl, "   wrt_reinstr: %d; rd_reinstr: %d\n",
2628e8fb11a1Sshidokht 	    cl->cl_g.dkg_write_reinstruct, cl->cl_g.dkg_read_reinstruct);
26293ccda647Slclee 
2630e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
26313ccda647Slclee 
26323ccda647Slclee 	return (label_error);
26333ccda647Slclee }
26343ccda647Slclee 
26353ccda647Slclee 
26363ccda647Slclee /*
26373ccda647Slclee  *    Function: cmlb_build_default_label
26383ccda647Slclee  *
26393ccda647Slclee  * Description: Generate a default label for those devices that do not have
26403ccda647Slclee  *		one, e.g., new media, removable cartridges, etc..
26413ccda647Slclee  *
26423ccda647Slclee  *     Context: Kernel thread only
26433ccda647Slclee  */
2644e8fb11a1Sshidokht /*ARGSUSED*/
26453ccda647Slclee static void
2646e8fb11a1Sshidokht cmlb_build_default_label(struct cmlb_lun *cl, void *tg_cookie)
26473ccda647Slclee {
26483ccda647Slclee #if defined(_SUNOS_VTOC_16)
26493ccda647Slclee 	uint_t	phys_spc;
26503ccda647Slclee 	uint_t	disksize;
2651e8fb11a1Sshidokht 	struct  dk_geom cl_g;
2652e8fb11a1Sshidokht 	diskaddr_t capacity;
26533ccda647Slclee #endif
26543ccda647Slclee 
2655e8fb11a1Sshidokht 	ASSERT(cl != NULL);
2656e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
26573ccda647Slclee 
26583ccda647Slclee #if defined(_SUNOS_VTOC_8)
26593ccda647Slclee 	/*
26603ccda647Slclee 	 * Note: This is a legacy check for non-removable devices on VTOC_8
26613ccda647Slclee 	 * only. This may be a valid check for VTOC_16 as well.
2662e8fb11a1Sshidokht 	 * Once we understand why there is this difference between SPARC and
2663e8fb11a1Sshidokht 	 * x86 platform, we could remove this legacy check.
26643ccda647Slclee 	 */
2665e8fb11a1Sshidokht 	if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
26663ccda647Slclee 		return;
26673ccda647Slclee 	}
26683ccda647Slclee #endif
26693ccda647Slclee 
2670e8fb11a1Sshidokht 	bzero(&cl->cl_g, sizeof (struct dk_geom));
2671e8fb11a1Sshidokht 	bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
2672e8fb11a1Sshidokht 	bzero(&cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
26733ccda647Slclee 
26743ccda647Slclee #if defined(_SUNOS_VTOC_8)
26753ccda647Slclee 
26763ccda647Slclee 	/*
26773ccda647Slclee 	 * It's a REMOVABLE media, therefore no label (on sparc, anyway).
26783ccda647Slclee 	 * But it is still necessary to set up various geometry information,
26793ccda647Slclee 	 * and we are doing this here.
26803ccda647Slclee 	 */
26813ccda647Slclee 
26823ccda647Slclee 	/*
26833ccda647Slclee 	 * For the rpm, we use the minimum for the disk.  For the head, cyl,
26843ccda647Slclee 	 * and number of sector per track, if the capacity <= 1GB, head = 64,
26853ccda647Slclee 	 * sect = 32.  else head = 255, sect 63 Note: the capacity should be
26863ccda647Slclee 	 * equal to C*H*S values.  This will cause some truncation of size due
26873ccda647Slclee 	 * to round off errors. For CD-ROMs, this truncation can have adverse
26883ccda647Slclee 	 * side effects, so returning ncyl and nhead as 1. The nsect will
26893ccda647Slclee 	 * overflow for most of CD-ROMs as nsect is of type ushort. (4190569)
26903ccda647Slclee 	 */
2691e8fb11a1Sshidokht 	cl->cl_solaris_size = cl->cl_blockcount;
2692e8fb11a1Sshidokht 	if (ISCD(cl)) {
26933ccda647Slclee 		tg_attribute_t tgattribute;
26943ccda647Slclee 		int is_writable;
26953ccda647Slclee 		/*
26963ccda647Slclee 		 * Preserve the old behavior for non-writable
26973ccda647Slclee 		 * medias. Since dkg_nsect is a ushort, it
26983ccda647Slclee 		 * will lose bits as cdroms have more than
26993ccda647Slclee 		 * 65536 sectors. So if we recalculate
27003ccda647Slclee 		 * capacity, it will become much shorter.
27013ccda647Slclee 		 * But the dkg_* information is not
27023ccda647Slclee 		 * used for CDROMs so it is OK. But for
27033ccda647Slclee 		 * Writable CDs we need this information
27043ccda647Slclee 		 * to be valid (for newfs say). So we
27053ccda647Slclee 		 * make nsect and nhead > 1 that way
27063ccda647Slclee 		 * nsect can still stay within ushort limit
27073ccda647Slclee 		 * without losing any bits.
27083ccda647Slclee 		 */
27093ccda647Slclee 
27103ccda647Slclee 		bzero(&tgattribute, sizeof (tg_attribute_t));
27113ccda647Slclee 
2712e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
2713e8fb11a1Sshidokht 		is_writable =
2714e8fb11a1Sshidokht 		    (DK_TG_GETATTRIBUTE(cl, &tgattribute, tg_cookie) == 0) ?
27153ccda647Slclee 		    tgattribute.media_is_writable : 1;
2716e8fb11a1Sshidokht 		mutex_enter(CMLB_MUTEX(cl));
27173ccda647Slclee 
27183ccda647Slclee 		if (is_writable) {
2719e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 64;
2720e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = 32;
2721e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32);
2722342440ecSPrasad Singamsetty 			cl->cl_solaris_size = (diskaddr_t)cl->cl_g.dkg_ncyl *
2723e8fb11a1Sshidokht 			    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
27243ccda647Slclee 		} else {
2725e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl  = 1;
2726e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 1;
2727e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = cl->cl_blockcount;
27283ccda647Slclee 		}
27293ccda647Slclee 	} else {
2730e8fb11a1Sshidokht 		if (cl->cl_blockcount <= 0x1000) {
27313ccda647Slclee 			/* unlabeled SCSI floppy device */
2732e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 2;
2733e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl = 80;
2734e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = cl->cl_blockcount / (2 * 80);
2735e8fb11a1Sshidokht 		} else if (cl->cl_blockcount <= 0x200000) {
2736e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 64;
2737e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = 32;
2738e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl  = cl->cl_blockcount / (64 * 32);
27393ccda647Slclee 		} else {
2740e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 255;
274198a65dd4Sshidokht 
274298a65dd4Sshidokht 			cl->cl_g.dkg_nsect = ((cl->cl_blockcount +
274398a65dd4Sshidokht 			    (UINT16_MAX * 255 * 63) - 1) /
274498a65dd4Sshidokht 			    (UINT16_MAX * 255 * 63)) * 63;
274598a65dd4Sshidokht 
274698a65dd4Sshidokht 			if (cl->cl_g.dkg_nsect == 0)
274798a65dd4Sshidokht 				cl->cl_g.dkg_nsect = (UINT16_MAX / 63) * 63;
274898a65dd4Sshidokht 
274998a65dd4Sshidokht 			cl->cl_g.dkg_ncyl = cl->cl_blockcount /
275098a65dd4Sshidokht 			    (255 * cl->cl_g.dkg_nsect);
27513ccda647Slclee 		}
275298a65dd4Sshidokht 
2753e8fb11a1Sshidokht 		cl->cl_solaris_size =
2754342440ecSPrasad Singamsetty 		    (diskaddr_t)cl->cl_g.dkg_ncyl * cl->cl_g.dkg_nhead *
2755342440ecSPrasad Singamsetty 		    cl->cl_g.dkg_nsect;
27563ccda647Slclee 
27573ccda647Slclee 	}
27583ccda647Slclee 
2759e8fb11a1Sshidokht 	cl->cl_g.dkg_acyl	= 0;
2760e8fb11a1Sshidokht 	cl->cl_g.dkg_bcyl	= 0;
2761e8fb11a1Sshidokht 	cl->cl_g.dkg_rpm	= 200;
2762e8fb11a1Sshidokht 	cl->cl_asciilabel[0]	= '\0';
2763e8fb11a1Sshidokht 	cl->cl_g.dkg_pcyl	= cl->cl_g.dkg_ncyl;
27643ccda647Slclee 
2765e8fb11a1Sshidokht 	cl->cl_map[0].dkl_cylno = 0;
2766e8fb11a1Sshidokht 	cl->cl_map[0].dkl_nblk  = cl->cl_solaris_size;
27673ccda647Slclee 
2768e8fb11a1Sshidokht 	cl->cl_map[2].dkl_cylno = 0;
2769e8fb11a1Sshidokht 	cl->cl_map[2].dkl_nblk  = cl->cl_solaris_size;
27703ccda647Slclee 
27713ccda647Slclee #elif defined(_SUNOS_VTOC_16)
27723ccda647Slclee 
2773e8fb11a1Sshidokht 	if (cl->cl_solaris_size == 0) {
27743ccda647Slclee 		/*
27753ccda647Slclee 		 * Got fdisk table but no solaris entry therefore
27763ccda647Slclee 		 * don't create a default label
27773ccda647Slclee 		 */
2778e8fb11a1Sshidokht 		cl->cl_f_geometry_is_valid = TRUE;
27793ccda647Slclee 		return;
27803ccda647Slclee 	}
27813ccda647Slclee 
27823ccda647Slclee 	/*
27833ccda647Slclee 	 * For CDs we continue to use the physical geometry to calculate
27843ccda647Slclee 	 * number of cylinders. All other devices must convert the
27853ccda647Slclee 	 * physical geometry (cmlb_geom) to values that will fit
27863ccda647Slclee 	 * in a dk_geom structure.
27873ccda647Slclee 	 */
2788e8fb11a1Sshidokht 	if (ISCD(cl)) {
2789e8fb11a1Sshidokht 		phys_spc = cl->cl_pgeom.g_nhead * cl->cl_pgeom.g_nsect;
27903ccda647Slclee 	} else {
27913ccda647Slclee 		/* Convert physical geometry to disk geometry */
2792e8fb11a1Sshidokht 		bzero(&cl_g, sizeof (struct dk_geom));
2793e8fb11a1Sshidokht 
2794e8fb11a1Sshidokht 		/*
2795e8fb11a1Sshidokht 		 * Refer to comments related to off-by-1 at the
2796e8fb11a1Sshidokht 		 * header of this file.
2797b9ccdc5aScth 		 * Before calculating geometry, capacity should be
2798e8fb11a1Sshidokht 		 * decreased by 1.
2799e8fb11a1Sshidokht 		 */
2800e8fb11a1Sshidokht 
2801e8fb11a1Sshidokht 		if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE)
2802e8fb11a1Sshidokht 			capacity = cl->cl_blockcount - 1;
2803e8fb11a1Sshidokht 		else
2804e8fb11a1Sshidokht 			capacity = cl->cl_blockcount;
2805e8fb11a1Sshidokht 
2806e8fb11a1Sshidokht 
2807e8fb11a1Sshidokht 		cmlb_convert_geometry(capacity, &cl_g);
2808e8fb11a1Sshidokht 		bcopy(&cl_g, &cl->cl_g, sizeof (cl->cl_g));
2809e8fb11a1Sshidokht 		phys_spc = cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
28103ccda647Slclee 	}
28113ccda647Slclee 
2812e8fb11a1Sshidokht 	ASSERT(phys_spc != 0);
2813e8fb11a1Sshidokht 	cl->cl_g.dkg_pcyl = cl->cl_solaris_size / phys_spc;
2814843e1988Sjohnlev 	if (cl->cl_alter_behavior & CMLB_FAKE_LABEL_ONE_PARTITION) {
2815843e1988Sjohnlev 		/* disable devid */
2816843e1988Sjohnlev 		cl->cl_g.dkg_ncyl = cl->cl_g.dkg_pcyl;
2817843e1988Sjohnlev 		disksize = cl->cl_solaris_size;
2818843e1988Sjohnlev 	} else {
2819843e1988Sjohnlev 		cl->cl_g.dkg_acyl = DK_ACYL;
2820843e1988Sjohnlev 		cl->cl_g.dkg_ncyl = cl->cl_g.dkg_pcyl - DK_ACYL;
2821843e1988Sjohnlev 		disksize = cl->cl_g.dkg_ncyl * phys_spc;
2822843e1988Sjohnlev 	}
28233ccda647Slclee 
2824e8fb11a1Sshidokht 	if (ISCD(cl)) {
28253ccda647Slclee 		/*
28263ccda647Slclee 		 * CD's don't use the "heads * sectors * cyls"-type of
28273ccda647Slclee 		 * geometry, but instead use the entire capacity of the media.
28283ccda647Slclee 		 */
2829e8fb11a1Sshidokht 		disksize = cl->cl_solaris_size;
2830e8fb11a1Sshidokht 		cl->cl_g.dkg_nhead = 1;
2831e8fb11a1Sshidokht 		cl->cl_g.dkg_nsect = 1;
2832e8fb11a1Sshidokht 		cl->cl_g.dkg_rpm =
2833e8fb11a1Sshidokht 		    (cl->cl_pgeom.g_rpm == 0) ? 200 : cl->cl_pgeom.g_rpm;
28343ccda647Slclee 
2835e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[0].p_start = 0;
2836e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[0].p_size  = disksize;
2837e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[0].p_tag   = V_BACKUP;
2838e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[0].p_flag  = V_UNMNT;
28393ccda647Slclee 
2840e8fb11a1Sshidokht 		cl->cl_map[0].dkl_cylno = 0;
2841e8fb11a1Sshidokht 		cl->cl_map[0].dkl_nblk  = disksize;
2842e8fb11a1Sshidokht 		cl->cl_offset[0] = 0;
28433ccda647Slclee 
28443ccda647Slclee 	} else {
28453ccda647Slclee 		/*
28463ccda647Slclee 		 * Hard disks and removable media cartridges
28473ccda647Slclee 		 */
2848e8fb11a1Sshidokht 		cl->cl_g.dkg_rpm =
2849e8fb11a1Sshidokht 		    (cl->cl_pgeom.g_rpm == 0) ? 3600: cl->cl_pgeom.g_rpm;
2850e8fb11a1Sshidokht 		cl->cl_vtoc.v_sectorsz = cl->cl_sys_blocksize;
28513ccda647Slclee 
28523ccda647Slclee 		/* Add boot slice */
2853e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[8].p_start = 0;
2854e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[8].p_size  = phys_spc;
2855e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[8].p_tag   = V_BOOT;
2856e8fb11a1Sshidokht 		cl->cl_vtoc.v_part[8].p_flag  = V_UNMNT;
28573ccda647Slclee 
2858e8fb11a1Sshidokht 		cl->cl_map[8].dkl_cylno = 0;
2859e8fb11a1Sshidokht 		cl->cl_map[8].dkl_nblk  = phys_spc;
2860e8fb11a1Sshidokht 		cl->cl_offset[8] = 0;
28613ccda647Slclee 
2862e8fb11a1Sshidokht 		if ((cl->cl_alter_behavior &
28633ccda647Slclee 		    CMLB_CREATE_ALTSLICE_VTOC_16_DTYPE_DIRECT) &&
2864e8fb11a1Sshidokht 		    cl->cl_device_type == DTYPE_DIRECT) {
2865e8fb11a1Sshidokht 			cl->cl_vtoc.v_part[9].p_start = phys_spc;
2866e8fb11a1Sshidokht 			cl->cl_vtoc.v_part[9].p_size  = 2 * phys_spc;
2867e8fb11a1Sshidokht 			cl->cl_vtoc.v_part[9].p_tag   = V_ALTSCTR;
2868e8fb11a1Sshidokht 			cl->cl_vtoc.v_part[9].p_flag  = 0;
2869e8fb11a1Sshidokht 
2870e8fb11a1Sshidokht 			cl->cl_map[9].dkl_cylno = 1;
2871e8fb11a1Sshidokht 			cl->cl_map[9].dkl_nblk  = 2 * phys_spc;
2872e8fb11a1Sshidokht 			cl->cl_offset[9] = phys_spc;
28733ccda647Slclee 		}
28743ccda647Slclee 	}
28753ccda647Slclee 
2876e8fb11a1Sshidokht 	cl->cl_g.dkg_apc = 0;
28773ccda647Slclee 
28783ccda647Slclee 	/* Add backup slice */
2879e8fb11a1Sshidokht 	cl->cl_vtoc.v_part[2].p_start = 0;
2880e8fb11a1Sshidokht 	cl->cl_vtoc.v_part[2].p_size  = disksize;
2881e8fb11a1Sshidokht 	cl->cl_vtoc.v_part[2].p_tag   = V_BACKUP;
2882e8fb11a1Sshidokht 	cl->cl_vtoc.v_part[2].p_flag  = V_UNMNT;
28833ccda647Slclee 
2884e8fb11a1Sshidokht 	cl->cl_map[2].dkl_cylno = 0;
2885e8fb11a1Sshidokht 	cl->cl_map[2].dkl_nblk  = disksize;
2886e8fb11a1Sshidokht 	cl->cl_offset[2] = 0;
28873ccda647Slclee 
2888843e1988Sjohnlev 	/*
2889843e1988Sjohnlev 	 * single slice (s0) covering the entire disk
2890843e1988Sjohnlev 	 */
2891843e1988Sjohnlev 	if (cl->cl_alter_behavior & CMLB_FAKE_LABEL_ONE_PARTITION) {
2892843e1988Sjohnlev 		cl->cl_vtoc.v_part[0].p_start = 0;
2893843e1988Sjohnlev 		cl->cl_vtoc.v_part[0].p_tag   = V_UNASSIGNED;
2894843e1988Sjohnlev 		cl->cl_vtoc.v_part[0].p_flag  = 0;
2895843e1988Sjohnlev 		cl->cl_vtoc.v_part[0].p_size  = disksize;
2896843e1988Sjohnlev 		cl->cl_map[0].dkl_cylno = 0;
2897843e1988Sjohnlev 		cl->cl_map[0].dkl_nblk  = disksize;
2898843e1988Sjohnlev 		cl->cl_offset[0] = 0;
2899843e1988Sjohnlev 	}
2900843e1988Sjohnlev 
2901e8fb11a1Sshidokht 	(void) sprintf(cl->cl_vtoc.v_asciilabel, "DEFAULT cyl %d alt %d"
2902e8fb11a1Sshidokht 	    " hd %d sec %d", cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
2903e8fb11a1Sshidokht 	    cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
29043ccda647Slclee 
29053ccda647Slclee #else
29063ccda647Slclee #error "No VTOC format defined."
29073ccda647Slclee #endif
29083ccda647Slclee 
2909e8fb11a1Sshidokht 	cl->cl_g.dkg_read_reinstruct  = 0;
2910e8fb11a1Sshidokht 	cl->cl_g.dkg_write_reinstruct = 0;
29113ccda647Slclee 
2912e8fb11a1Sshidokht 	cl->cl_g.dkg_intrlv = 1;
29133ccda647Slclee 
2914e8fb11a1Sshidokht 	cl->cl_vtoc.v_sanity  = VTOC_SANE;
2915c813bb04SGabriel Carrillo 	cl->cl_vtoc.v_nparts = V_NUMPAR;
2916c813bb04SGabriel Carrillo 	cl->cl_vtoc.v_version = V_VERSION;
29173ccda647Slclee 
2918e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = TRUE;
2919342440ecSPrasad Singamsetty 	cl->cl_label_from_media = CMLB_LABEL_UNDEF;
29203ccda647Slclee 
2921e8fb11a1Sshidokht 	cmlb_dbg(CMLB_INFO,  cl,
29223ccda647Slclee 	    "cmlb_build_default_label: Default label created: "
29233ccda647Slclee 	    "cyl: %d\tacyl: %d\tnhead: %d\tnsect: %d\tcap: %d\n",
2924e8fb11a1Sshidokht 	    cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl, cl->cl_g.dkg_nhead,
2925e8fb11a1Sshidokht 	    cl->cl_g.dkg_nsect, cl->cl_blockcount);
29263ccda647Slclee }
29273ccda647Slclee 
29283ccda647Slclee 
29293ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
29303ccda647Slclee /*
29313ccda647Slclee  * Max CHS values, as they are encoded into bytes, for 1022/254/63
29323ccda647Slclee  */
29333ccda647Slclee #define	LBA_MAX_SECT	(63 | ((1022 & 0x300) >> 2))
29343ccda647Slclee #define	LBA_MAX_CYL	(1022 & 0xFF)
29353ccda647Slclee #define	LBA_MAX_HEAD	(254)
29363ccda647Slclee 
29373ccda647Slclee 
29383ccda647Slclee /*
29393ccda647Slclee  *    Function: cmlb_has_max_chs_vals
29403ccda647Slclee  *
29413ccda647Slclee  * Description: Return TRUE if Cylinder-Head-Sector values are all at maximum.
29423ccda647Slclee  *
29433ccda647Slclee  *   Arguments: fdp - ptr to CHS info
29443ccda647Slclee  *
29453ccda647Slclee  * Return Code: True or false
29463ccda647Slclee  *
29473ccda647Slclee  *     Context: Any.
29483ccda647Slclee  */
29493ccda647Slclee static int
29503ccda647Slclee cmlb_has_max_chs_vals(struct ipart *fdp)
29513ccda647Slclee {
29523ccda647Slclee 	return ((fdp->begcyl  == LBA_MAX_CYL)	&&
29533ccda647Slclee 	    (fdp->beghead == LBA_MAX_HEAD)	&&
29543ccda647Slclee 	    (fdp->begsect == LBA_MAX_SECT)	&&
29553ccda647Slclee 	    (fdp->endcyl  == LBA_MAX_CYL)	&&
29563ccda647Slclee 	    (fdp->endhead == LBA_MAX_HEAD)	&&
29573ccda647Slclee 	    (fdp->endsect == LBA_MAX_SECT));
29583ccda647Slclee }
29593ccda647Slclee #endif
29603ccda647Slclee 
29613ccda647Slclee /*
29623ccda647Slclee  *    Function: cmlb_dkio_get_geometry
29633ccda647Slclee  *
29643ccda647Slclee  * Description: This routine is the driver entry point for handling user
29653ccda647Slclee  *		requests to get the device geometry (DKIOCGGEOM).
29663ccda647Slclee  *
29673ccda647Slclee  *   Arguments:
2968e8fb11a1Sshidokht  *	arg		pointer to user provided dk_geom structure specifying
29693ccda647Slclee  *			the controller's notion of the current geometry.
2970e8fb11a1Sshidokht  *
2971e8fb11a1Sshidokht  *	flag 		this argument is a pass through to ddi_copyxxx()
2972e8fb11a1Sshidokht  *			directly from the mode argument of ioctl().
2973e8fb11a1Sshidokht  *
2974e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
2975e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
29763ccda647Slclee  *
29773ccda647Slclee  * Return Code: 0
29783ccda647Slclee  *		EFAULT
29793ccda647Slclee  *		ENXIO
29803ccda647Slclee  *		EIO
29813ccda647Slclee  */
29823ccda647Slclee static int
2983e8fb11a1Sshidokht cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag,
2984e8fb11a1Sshidokht     void *tg_cookie)
29853ccda647Slclee {
29863ccda647Slclee 	struct dk_geom	*tmp_geom = NULL;
29873ccda647Slclee 	int		rval = 0;
29883ccda647Slclee 
29893ccda647Slclee 	/*
29903ccda647Slclee 	 * cmlb_validate_geometry does not spin a disk up
2991e8fb11a1Sshidokht 	 * if it was spcl down. We need to make sure it
29923ccda647Slclee 	 * is ready.
29933ccda647Slclee 	 */
2994e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
2995e8fb11a1Sshidokht 	rval = cmlb_validate_geometry(cl, 1, 0, tg_cookie);
29963ccda647Slclee #if defined(_SUNOS_VTOC_8)
29973ccda647Slclee 	if (rval == EINVAL &&
2998e8fb11a1Sshidokht 	    cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) {
29993ccda647Slclee 		/*
30003ccda647Slclee 		 * This is to return a default label geometry even when we
30013ccda647Slclee 		 * do not really assume a default label for the device.
30023ccda647Slclee 		 * dad driver utilizes this.
30033ccda647Slclee 		 */
3004342440ecSPrasad Singamsetty 		if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
3005e8fb11a1Sshidokht 			cmlb_setup_default_geometry(cl, tg_cookie);
30063ccda647Slclee 			rval = 0;
30073ccda647Slclee 		}
30083ccda647Slclee 	}
30093ccda647Slclee #endif
30103ccda647Slclee 	if (rval) {
3011e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
30123ccda647Slclee 		return (rval);
30133ccda647Slclee 	}
30143ccda647Slclee 
30153ccda647Slclee #if defined(__i386) || defined(__amd64)
3016e8fb11a1Sshidokht 	if (cl->cl_solaris_size == 0) {
3017e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
30183ccda647Slclee 		return (EIO);
30193ccda647Slclee 	}
30203ccda647Slclee #endif
30213ccda647Slclee 
30223ccda647Slclee 	/*
30233ccda647Slclee 	 * Make a local copy of the soft state geometry to avoid some potential
30243ccda647Slclee 	 * race conditions associated with holding the mutex and updating the
30253ccda647Slclee 	 * write_reinstruct value
30263ccda647Slclee 	 */
30273ccda647Slclee 	tmp_geom = kmem_zalloc(sizeof (struct dk_geom), KM_SLEEP);
3028e8fb11a1Sshidokht 	bcopy(&cl->cl_g, tmp_geom, sizeof (struct dk_geom));
30293ccda647Slclee 
30303ccda647Slclee 	if (tmp_geom->dkg_write_reinstruct == 0) {
30313ccda647Slclee 		tmp_geom->dkg_write_reinstruct =
30323ccda647Slclee 		    (int)((int)(tmp_geom->dkg_nsect * tmp_geom->dkg_rpm *
30333ccda647Slclee 		    cmlb_rot_delay) / (int)60000);
30343ccda647Slclee 	}
3035e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
30363ccda647Slclee 
30373ccda647Slclee 	rval = ddi_copyout(tmp_geom, (void *)arg, sizeof (struct dk_geom),
30383ccda647Slclee 	    flag);
30393ccda647Slclee 	if (rval != 0) {
30403ccda647Slclee 		rval = EFAULT;
30413ccda647Slclee 	}
30423ccda647Slclee 
30433ccda647Slclee 	kmem_free(tmp_geom, sizeof (struct dk_geom));
30443ccda647Slclee 	return (rval);
30453ccda647Slclee 
30463ccda647Slclee }
30473ccda647Slclee 
30483ccda647Slclee 
30493ccda647Slclee /*
30503ccda647Slclee  *    Function: cmlb_dkio_set_geometry
30513ccda647Slclee  *
30523ccda647Slclee  * Description: This routine is the driver entry point for handling user
30533ccda647Slclee  *		requests to set the device geometry (DKIOCSGEOM). The actual
30543ccda647Slclee  *		device geometry is not updated, just the driver "notion" of it.
30553ccda647Slclee  *
30563ccda647Slclee  *   Arguments:
3057e8fb11a1Sshidokht  *	arg		pointer to user provided dk_geom structure used to set
30583ccda647Slclee  *			the controller's notion of the current geometry.
3059e8fb11a1Sshidokht  *
3060e8fb11a1Sshidokht  *	flag 		this argument is a pass through to ddi_copyxxx()
3061e8fb11a1Sshidokht  *			directly from the mode argument of ioctl().
3062e8fb11a1Sshidokht  *
3063e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
3064e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
30653ccda647Slclee  *
30663ccda647Slclee  * Return Code: 0
30673ccda647Slclee  *		EFAULT
30683ccda647Slclee  *		ENXIO
30693ccda647Slclee  *		EIO
30703ccda647Slclee  */
30713ccda647Slclee static int
3072e8fb11a1Sshidokht cmlb_dkio_set_geometry(struct cmlb_lun *cl, caddr_t arg, int flag)
30733ccda647Slclee {
30743ccda647Slclee 	struct dk_geom	*tmp_geom;
30753ccda647Slclee 	struct dk_map	*lp;
30763ccda647Slclee 	int		rval = 0;
30773ccda647Slclee 	int		i;
30783ccda647Slclee 
30793ccda647Slclee 
30803ccda647Slclee #if defined(__i386) || defined(__amd64)
3081e8fb11a1Sshidokht 	if (cl->cl_solaris_size == 0) {
30823ccda647Slclee 		return (EIO);
30833ccda647Slclee 	}
30843ccda647Slclee #endif
30853ccda647Slclee 	/*
30863ccda647Slclee 	 * We need to copy the user specified geometry into local
30873ccda647Slclee 	 * storage and then update the softstate. We don't want to hold
30883ccda647Slclee 	 * the mutex and copyin directly from the user to the soft state
30893ccda647Slclee 	 */
30903ccda647Slclee 	tmp_geom = (struct dk_geom *)
30913ccda647Slclee 	    kmem_zalloc(sizeof (struct dk_geom), KM_SLEEP);
30923ccda647Slclee 	rval = ddi_copyin(arg, tmp_geom, sizeof (struct dk_geom), flag);
30933ccda647Slclee 	if (rval != 0) {
30943ccda647Slclee 		kmem_free(tmp_geom, sizeof (struct dk_geom));
30953ccda647Slclee 		return (EFAULT);
30963ccda647Slclee 	}
30973ccda647Slclee 
3098e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
3099e8fb11a1Sshidokht 	bcopy(tmp_geom, &cl->cl_g, sizeof (struct dk_geom));
31003ccda647Slclee 	for (i = 0; i < NDKMAP; i++) {
3101e8fb11a1Sshidokht 		lp  = &cl->cl_map[i];
3102e8fb11a1Sshidokht 		cl->cl_offset[i] =
3103e8fb11a1Sshidokht 		    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
31043ccda647Slclee #if defined(__i386) || defined(__amd64)
3105e8fb11a1Sshidokht 		cl->cl_offset[i] += cl->cl_solaris_offset;
31063ccda647Slclee #endif
31073ccda647Slclee 	}
3108e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = FALSE;
3109e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
31103ccda647Slclee 	kmem_free(tmp_geom, sizeof (struct dk_geom));
31113ccda647Slclee 
31123ccda647Slclee 	return (rval);
31133ccda647Slclee }
31143ccda647Slclee 
31153ccda647Slclee /*
31163ccda647Slclee  *    Function: cmlb_dkio_get_partition
31173ccda647Slclee  *
31183ccda647Slclee  * Description: This routine is the driver entry point for handling user
31193ccda647Slclee  *		requests to get the partition table (DKIOCGAPART).
31203ccda647Slclee  *
31213ccda647Slclee  *   Arguments:
3122e8fb11a1Sshidokht  *	arg		pointer to user provided dk_allmap structure specifying
31233ccda647Slclee  *			the controller's notion of the current partition table.
3124e8fb11a1Sshidokht  *
3125e8fb11a1Sshidokht  *	flag		this argument is a pass through to ddi_copyxxx()
3126e8fb11a1Sshidokht  *			directly from the mode argument of ioctl().
3127e8fb11a1Sshidokht  *
3128e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
3129e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
31303ccda647Slclee  *
31313ccda647Slclee  * Return Code: 0
31323ccda647Slclee  *		EFAULT
31333ccda647Slclee  *		ENXIO
31343ccda647Slclee  *		EIO
31353ccda647Slclee  */
31363ccda647Slclee static int
3137e8fb11a1Sshidokht cmlb_dkio_get_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
3138e8fb11a1Sshidokht     void *tg_cookie)
31393ccda647Slclee {
31403ccda647Slclee 	int		rval = 0;
31413ccda647Slclee 	int		size;
31423ccda647Slclee 
31433ccda647Slclee 	/*
31443ccda647Slclee 	 * Make sure the geometry is valid before getting the partition
31453ccda647Slclee 	 * information.
31463ccda647Slclee 	 */
3147e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
3148e8fb11a1Sshidokht 	if ((rval = cmlb_validate_geometry(cl, 1, 0, tg_cookie)) != 0) {
3149e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
31503ccda647Slclee 		return (rval);
31513ccda647Slclee 	}
3152e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
31533ccda647Slclee 
31543ccda647Slclee #if defined(__i386) || defined(__amd64)
3155e8fb11a1Sshidokht 	if (cl->cl_solaris_size == 0) {
31563ccda647Slclee 		return (EIO);
31573ccda647Slclee 	}
31583ccda647Slclee #endif
31593ccda647Slclee 
31603ccda647Slclee #ifdef _MULTI_DATAMODEL
31613ccda647Slclee 	switch (ddi_model_convert_from(flag & FMODELS)) {
31623ccda647Slclee 	case DDI_MODEL_ILP32: {
31633ccda647Slclee 		struct dk_map32 dk_map32[NDKMAP];
31643ccda647Slclee 		int		i;
31653ccda647Slclee 
31663ccda647Slclee 		for (i = 0; i < NDKMAP; i++) {
3167e8fb11a1Sshidokht 			dk_map32[i].dkl_cylno = cl->cl_map[i].dkl_cylno;
3168e8fb11a1Sshidokht 			dk_map32[i].dkl_nblk  = cl->cl_map[i].dkl_nblk;
31693ccda647Slclee 		}
31703ccda647Slclee 		size = NDKMAP * sizeof (struct dk_map32);
31713ccda647Slclee 		rval = ddi_copyout(dk_map32, (void *)arg, size, flag);
31723ccda647Slclee 		if (rval != 0) {
31733ccda647Slclee 			rval = EFAULT;
31743ccda647Slclee 		}
31753ccda647Slclee 		break;
31763ccda647Slclee 	}
31773ccda647Slclee 	case DDI_MODEL_NONE:
31783ccda647Slclee 		size = NDKMAP * sizeof (struct dk_map);
3179e8fb11a1Sshidokht 		rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag);
31803ccda647Slclee 		if (rval != 0) {
31813ccda647Slclee 			rval = EFAULT;
31823ccda647Slclee 		}
31833ccda647Slclee 		break;
31843ccda647Slclee 	}
31853ccda647Slclee #else /* ! _MULTI_DATAMODEL */
31863ccda647Slclee 	size = NDKMAP * sizeof (struct dk_map);
3187e8fb11a1Sshidokht 	rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag);
31883ccda647Slclee 	if (rval != 0) {
31893ccda647Slclee 		rval = EFAULT;
31903ccda647Slclee 	}
31913ccda647Slclee #endif /* _MULTI_DATAMODEL */
31923ccda647Slclee 	return (rval);
31933ccda647Slclee }
31943ccda647Slclee 
31953ccda647Slclee /*
31963ccda647Slclee  *    Function: cmlb_dkio_set_partition
31973ccda647Slclee  *
31983ccda647Slclee  * Description: This routine is the driver entry point for handling user
31993ccda647Slclee  *		requests to set the partition table (DKIOCSAPART). The actual
32003ccda647Slclee  *		device partition is not updated.
32013ccda647Slclee  *
32023ccda647Slclee  *   Arguments:
32033ccda647Slclee  *		arg  - pointer to user provided dk_allmap structure used to set
32043ccda647Slclee  *			the controller's notion of the partition table.
32053ccda647Slclee  *		flag - this argument is a pass through to ddi_copyxxx()
32063ccda647Slclee  *		       directly from the mode argument of ioctl().
32073ccda647Slclee  *
32083ccda647Slclee  * Return Code: 0
32093ccda647Slclee  *		EINVAL
32103ccda647Slclee  *		EFAULT
32113ccda647Slclee  *		ENXIO
32123ccda647Slclee  *		EIO
32133ccda647Slclee  */
32143ccda647Slclee static int
3215e8fb11a1Sshidokht cmlb_dkio_set_partition(struct cmlb_lun *cl, caddr_t arg, int flag)
32163ccda647Slclee {
32173ccda647Slclee 	struct dk_map	dk_map[NDKMAP];
32183ccda647Slclee 	struct dk_map	*lp;
32193ccda647Slclee 	int		rval = 0;
32203ccda647Slclee 	int		size;
32213ccda647Slclee 	int		i;
32223ccda647Slclee #if defined(_SUNOS_VTOC_16)
32233ccda647Slclee 	struct dkl_partition	*vp;
32243ccda647Slclee #endif
32253ccda647Slclee 
32263ccda647Slclee 	/*
32273ccda647Slclee 	 * Set the map for all logical partitions.  We lock
32283ccda647Slclee 	 * the priority just to make sure an interrupt doesn't
32293ccda647Slclee 	 * come in while the map is half updated.
32303ccda647Slclee 	 */
3231e8fb11a1Sshidokht 	_NOTE(DATA_READABLE_WITHOUT_LOCK(cmlb_lun::cl_solaris_size))
3232e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
32333ccda647Slclee 
3234342440ecSPrasad Singamsetty 	if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
3235e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
32363ccda647Slclee 		return (ENOTSUP);
32373ccda647Slclee 	}
3238e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
3239e8fb11a1Sshidokht 	if (cl->cl_solaris_size == 0) {
32403ccda647Slclee 		return (EIO);
32413ccda647Slclee 	}
32423ccda647Slclee 
32433ccda647Slclee #ifdef _MULTI_DATAMODEL
32443ccda647Slclee 	switch (ddi_model_convert_from(flag & FMODELS)) {
32453ccda647Slclee 	case DDI_MODEL_ILP32: {
32463ccda647Slclee 		struct dk_map32 dk_map32[NDKMAP];
32473ccda647Slclee 
32483ccda647Slclee 		size = NDKMAP * sizeof (struct dk_map32);
32493ccda647Slclee 		rval = ddi_copyin((void *)arg, dk_map32, size, flag);
32503ccda647Slclee 		if (rval != 0) {
32513ccda647Slclee 			return (EFAULT);
32523ccda647Slclee 		}
32533ccda647Slclee 		for (i = 0; i < NDKMAP; i++) {
32543ccda647Slclee 			dk_map[i].dkl_cylno = dk_map32[i].dkl_cylno;
32553ccda647Slclee 			dk_map[i].dkl_nblk  = dk_map32[i].dkl_nblk;
32563ccda647Slclee 		}
32573ccda647Slclee 		break;
32583ccda647Slclee 	}
32593ccda647Slclee 	case DDI_MODEL_NONE:
32603ccda647Slclee 		size = NDKMAP * sizeof (struct dk_map);
32613ccda647Slclee 		rval = ddi_copyin((void *)arg, dk_map, size, flag);
32623ccda647Slclee 		if (rval != 0) {
32633ccda647Slclee 			return (EFAULT);
32643ccda647Slclee 		}
32653ccda647Slclee 		break;
32663ccda647Slclee 	}
32673ccda647Slclee #else /* ! _MULTI_DATAMODEL */
32683ccda647Slclee 	size = NDKMAP * sizeof (struct dk_map);
32693ccda647Slclee 	rval = ddi_copyin((void *)arg, dk_map, size, flag);
32703ccda647Slclee 	if (rval != 0) {
32713ccda647Slclee 		return (EFAULT);
32723ccda647Slclee 	}
32733ccda647Slclee #endif /* _MULTI_DATAMODEL */
32743ccda647Slclee 
3275e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
32763ccda647Slclee 	/* Note: The size used in this bcopy is set based upon the data model */
3277e8fb11a1Sshidokht 	bcopy(dk_map, cl->cl_map, size);
32783ccda647Slclee #if defined(_SUNOS_VTOC_16)
3279e8fb11a1Sshidokht 	vp = (struct dkl_partition *)&(cl->cl_vtoc);
32803ccda647Slclee #endif	/* defined(_SUNOS_VTOC_16) */
32813ccda647Slclee 	for (i = 0; i < NDKMAP; i++) {
3282e8fb11a1Sshidokht 		lp  = &cl->cl_map[i];
3283e8fb11a1Sshidokht 		cl->cl_offset[i] =
3284e8fb11a1Sshidokht 		    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
32853ccda647Slclee #if defined(_SUNOS_VTOC_16)
3286e8fb11a1Sshidokht 		vp->p_start = cl->cl_offset[i];
32873ccda647Slclee 		vp->p_size = lp->dkl_nblk;
32883ccda647Slclee 		vp++;
32893ccda647Slclee #endif	/* defined(_SUNOS_VTOC_16) */
32903ccda647Slclee #if defined(__i386) || defined(__amd64)
3291e8fb11a1Sshidokht 		cl->cl_offset[i] += cl->cl_solaris_offset;
32923ccda647Slclee #endif
32933ccda647Slclee 	}
3294e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
32953ccda647Slclee 	return (rval);
32963ccda647Slclee }
32973ccda647Slclee 
32983ccda647Slclee 
32993ccda647Slclee /*
33003ccda647Slclee  *    Function: cmlb_dkio_get_vtoc
33013ccda647Slclee  *
33023ccda647Slclee  * Description: This routine is the driver entry point for handling user
33033ccda647Slclee  *		requests to get the current volume table of contents
33043ccda647Slclee  *		(DKIOCGVTOC).
33053ccda647Slclee  *
33063ccda647Slclee  *   Arguments:
3307e8fb11a1Sshidokht  *	arg		pointer to user provided vtoc structure specifying
33083ccda647Slclee  *			the current vtoc.
3309e8fb11a1Sshidokht  *
3310e8fb11a1Sshidokht  *	flag		this argument is a pass through to ddi_copyxxx()
3311e8fb11a1Sshidokht  *			directly from the mode argument of ioctl().
3312e8fb11a1Sshidokht  *
3313e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
3314e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
33153ccda647Slclee  *
33163ccda647Slclee  * Return Code: 0
33173ccda647Slclee  *		EFAULT
33183ccda647Slclee  *		ENXIO
33193ccda647Slclee  *		EIO
33203ccda647Slclee  */
33213ccda647Slclee static int
3322e8fb11a1Sshidokht cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
33233ccda647Slclee {
33243ccda647Slclee #if defined(_SUNOS_VTOC_8)
33253ccda647Slclee 	struct vtoc	user_vtoc;
33263ccda647Slclee #endif	/* defined(_SUNOS_VTOC_8) */
33273ccda647Slclee 	int		rval = 0;
33283ccda647Slclee 
3329e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
3330342440ecSPrasad Singamsetty 	if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
3331342440ecSPrasad Singamsetty 		mutex_exit(CMLB_MUTEX(cl));
3332342440ecSPrasad Singamsetty 		return (EOVERFLOW);
3333342440ecSPrasad Singamsetty 	}
3334342440ecSPrasad Singamsetty 
3335e8fb11a1Sshidokht 	rval = cmlb_validate_geometry(cl, 1, 0, tg_cookie);
33363ccda647Slclee 
33373ccda647Slclee #if defined(_SUNOS_VTOC_8)
33383ccda647Slclee 	if (rval == EINVAL &&
3339e8fb11a1Sshidokht 	    (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8)) {
33403ccda647Slclee 		/*
33413ccda647Slclee 		 * This is to return a default label even when we do not
33423ccda647Slclee 		 * really assume a default label for the device.
33433ccda647Slclee 		 * dad driver utilizes this.
33443ccda647Slclee 		 */
3345342440ecSPrasad Singamsetty 		if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
3346e8fb11a1Sshidokht 			cmlb_setup_default_geometry(cl, tg_cookie);
33473ccda647Slclee 			rval = 0;
33483ccda647Slclee 		}
33493ccda647Slclee 	}
33503ccda647Slclee #endif
33513ccda647Slclee 	if (rval) {
3352e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
33533ccda647Slclee 		return (rval);
33543ccda647Slclee 	}
33553ccda647Slclee 
33563ccda647Slclee #if defined(_SUNOS_VTOC_8)
3357e8fb11a1Sshidokht 	cmlb_build_user_vtoc(cl, &user_vtoc);
3358e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
33593ccda647Slclee 
33603ccda647Slclee #ifdef _MULTI_DATAMODEL
33613ccda647Slclee 	switch (ddi_model_convert_from(flag & FMODELS)) {
33623ccda647Slclee 	case DDI_MODEL_ILP32: {
33633ccda647Slclee 		struct vtoc32 user_vtoc32;
33643ccda647Slclee 
33653ccda647Slclee 		vtoctovtoc32(user_vtoc, user_vtoc32);
33663ccda647Slclee 		if (ddi_copyout(&user_vtoc32, (void *)arg,
33673ccda647Slclee 		    sizeof (struct vtoc32), flag)) {
33683ccda647Slclee 			return (EFAULT);
33693ccda647Slclee 		}
33703ccda647Slclee 		break;
33713ccda647Slclee 	}
33723ccda647Slclee 
33733ccda647Slclee 	case DDI_MODEL_NONE:
33743ccda647Slclee 		if (ddi_copyout(&user_vtoc, (void *)arg,
33753ccda647Slclee 		    sizeof (struct vtoc), flag)) {
33763ccda647Slclee 			return (EFAULT);
33773ccda647Slclee 		}
33783ccda647Slclee 		break;
33793ccda647Slclee 	}
33803ccda647Slclee #else /* ! _MULTI_DATAMODEL */
33813ccda647Slclee 	if (ddi_copyout(&user_vtoc, (void *)arg, sizeof (struct vtoc), flag)) {
33823ccda647Slclee 		return (EFAULT);
33833ccda647Slclee 	}
33843ccda647Slclee #endif /* _MULTI_DATAMODEL */
33853ccda647Slclee 
33863ccda647Slclee #elif defined(_SUNOS_VTOC_16)
3387e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
33883ccda647Slclee 
33893ccda647Slclee #ifdef _MULTI_DATAMODEL
33903ccda647Slclee 	/*
3391e8fb11a1Sshidokht 	 * The cl_vtoc structure is a "struct dk_vtoc"  which is always
33923ccda647Slclee 	 * 32-bit to maintain compatibility with existing on-disk
33933ccda647Slclee 	 * structures.  Thus, we need to convert the structure when copying
33943ccda647Slclee 	 * it out to a datamodel-dependent "struct vtoc" in a 64-bit
33953ccda647Slclee 	 * program.  If the target is a 32-bit program, then no conversion
33963ccda647Slclee 	 * is necessary.
33973ccda647Slclee 	 */
33983ccda647Slclee 	/* LINTED: logical expression always true: op "||" */
3399e8fb11a1Sshidokht 	ASSERT(sizeof (cl->cl_vtoc) == sizeof (struct vtoc32));
34003ccda647Slclee 	switch (ddi_model_convert_from(flag & FMODELS)) {
34013ccda647Slclee 	case DDI_MODEL_ILP32:
3402e8fb11a1Sshidokht 		if (ddi_copyout(&(cl->cl_vtoc), (void *)arg,
3403e8fb11a1Sshidokht 		    sizeof (cl->cl_vtoc), flag)) {
34043ccda647Slclee 			return (EFAULT);
34053ccda647Slclee 		}
34063ccda647Slclee 		break;
34073ccda647Slclee 
34083ccda647Slclee 	case DDI_MODEL_NONE: {
34093ccda647Slclee 		struct vtoc user_vtoc;
34103ccda647Slclee 
3411e8fb11a1Sshidokht 		vtoc32tovtoc(cl->cl_vtoc, user_vtoc);
34123ccda647Slclee 		if (ddi_copyout(&user_vtoc, (void *)arg,
34133ccda647Slclee 		    sizeof (struct vtoc), flag)) {
34143ccda647Slclee 			return (EFAULT);
34153ccda647Slclee 		}
34163ccda647Slclee 		break;
34173ccda647Slclee 	}
34183ccda647Slclee 	}
34193ccda647Slclee #else /* ! _MULTI_DATAMODEL */
3420e8fb11a1Sshidokht 	if (ddi_copyout(&(cl->cl_vtoc), (void *)arg, sizeof (cl->cl_vtoc),
34213ccda647Slclee 	    flag)) {
34223ccda647Slclee 		return (EFAULT);
34233ccda647Slclee 	}
34243ccda647Slclee #endif /* _MULTI_DATAMODEL */
34253ccda647Slclee #else
34263ccda647Slclee #error "No VTOC format defined."
34273ccda647Slclee #endif
34283ccda647Slclee 
34293ccda647Slclee 	return (rval);
34303ccda647Slclee }
34313ccda647Slclee 
3432342440ecSPrasad Singamsetty 
3433342440ecSPrasad Singamsetty /*
3434342440ecSPrasad Singamsetty  *    Function: cmlb_dkio_get_extvtoc
3435342440ecSPrasad Singamsetty  */
3436342440ecSPrasad Singamsetty static int
3437342440ecSPrasad Singamsetty cmlb_dkio_get_extvtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
3438342440ecSPrasad Singamsetty     void *tg_cookie)
3439342440ecSPrasad Singamsetty {
3440342440ecSPrasad Singamsetty 	struct extvtoc	ext_vtoc;
3441342440ecSPrasad Singamsetty #if defined(_SUNOS_VTOC_8)
3442342440ecSPrasad Singamsetty 	struct vtoc	user_vtoc;
3443342440ecSPrasad Singamsetty #endif	/* defined(_SUNOS_VTOC_8) */
3444342440ecSPrasad Singamsetty 	int		rval = 0;
3445342440ecSPrasad Singamsetty 
3446342440ecSPrasad Singamsetty 	bzero(&ext_vtoc, sizeof (struct extvtoc));
3447342440ecSPrasad Singamsetty 	mutex_enter(CMLB_MUTEX(cl));
3448342440ecSPrasad Singamsetty 	rval = cmlb_validate_geometry(cl, 1, 0, tg_cookie);
3449342440ecSPrasad Singamsetty 
3450342440ecSPrasad Singamsetty #if defined(_SUNOS_VTOC_8)
3451342440ecSPrasad Singamsetty 	if (rval == EINVAL &&
3452342440ecSPrasad Singamsetty 	    (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8)) {
3453342440ecSPrasad Singamsetty 		/*
3454342440ecSPrasad Singamsetty 		 * This is to return a default label even when we do not
3455342440ecSPrasad Singamsetty 		 * really assume a default label for the device.
3456342440ecSPrasad Singamsetty 		 * dad driver utilizes this.
3457342440ecSPrasad Singamsetty 		 */
3458342440ecSPrasad Singamsetty 		if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
3459342440ecSPrasad Singamsetty 			cmlb_setup_default_geometry(cl, tg_cookie);
3460342440ecSPrasad Singamsetty 			rval = 0;
3461342440ecSPrasad Singamsetty 		}
3462342440ecSPrasad Singamsetty 	}
3463342440ecSPrasad Singamsetty #endif
3464342440ecSPrasad Singamsetty 	if (rval) {
3465342440ecSPrasad Singamsetty 		mutex_exit(CMLB_MUTEX(cl));
3466342440ecSPrasad Singamsetty 		return (rval);
3467342440ecSPrasad Singamsetty 	}
3468342440ecSPrasad Singamsetty 
3469342440ecSPrasad Singamsetty #if defined(_SUNOS_VTOC_8)
3470342440ecSPrasad Singamsetty 	cmlb_build_user_vtoc(cl, &user_vtoc);
3471342440ecSPrasad Singamsetty 	mutex_exit(CMLB_MUTEX(cl));
3472342440ecSPrasad Singamsetty 
3473342440ecSPrasad Singamsetty 	/*
3474342440ecSPrasad Singamsetty 	 * Checking callers data model does not make much sense here
3475342440ecSPrasad Singamsetty 	 * since extvtoc will always be equivalent to 64bit vtoc.
3476342440ecSPrasad Singamsetty 	 * What is important is whether the kernel is in 32 or 64 bit
3477342440ecSPrasad Singamsetty 	 */
3478342440ecSPrasad Singamsetty 
3479342440ecSPrasad Singamsetty #ifdef _LP64
3480342440ecSPrasad Singamsetty 		if (ddi_copyout(&user_vtoc, (void *)arg,
3481342440ecSPrasad Singamsetty 		    sizeof (struct extvtoc), flag)) {
3482342440ecSPrasad Singamsetty 			return (EFAULT);
3483342440ecSPrasad Singamsetty 		}
3484342440ecSPrasad Singamsetty #else
3485342440ecSPrasad Singamsetty 		vtoc32tovtoc(user_vtoc, ext_vtoc);
3486342440ecSPrasad Singamsetty 		if (ddi_copyout(&ext_vtoc, (void *)arg,
3487342440ecSPrasad Singamsetty 		    sizeof (struct extvtoc), flag)) {
3488342440ecSPrasad Singamsetty 			return (EFAULT);
3489342440ecSPrasad Singamsetty 		}
3490342440ecSPrasad Singamsetty #endif
3491342440ecSPrasad Singamsetty 
3492342440ecSPrasad Singamsetty #elif defined(_SUNOS_VTOC_16)
3493342440ecSPrasad Singamsetty 	/*
3494342440ecSPrasad Singamsetty 	 * The cl_vtoc structure is a "struct dk_vtoc"  which is always
3495342440ecSPrasad Singamsetty 	 * 32-bit to maintain compatibility with existing on-disk
3496342440ecSPrasad Singamsetty 	 * structures.  Thus, we need to convert the structure when copying
3497342440ecSPrasad Singamsetty 	 * it out to extvtoc
3498342440ecSPrasad Singamsetty 	 */
3499342440ecSPrasad Singamsetty 	vtoc32tovtoc(cl->cl_vtoc, ext_vtoc);
35001fad2c0eSXiao Raymond Li 	mutex_exit(CMLB_MUTEX(cl));
3501342440ecSPrasad Singamsetty 
3502342440ecSPrasad Singamsetty 	if (ddi_copyout(&ext_vtoc, (void *)arg, sizeof (struct extvtoc), flag))
3503342440ecSPrasad Singamsetty 		return (EFAULT);
3504342440ecSPrasad Singamsetty #else
3505342440ecSPrasad Singamsetty #error "No VTOC format defined."
3506342440ecSPrasad Singamsetty #endif
3507342440ecSPrasad Singamsetty 
3508342440ecSPrasad Singamsetty 	return (rval);
3509342440ecSPrasad Singamsetty }
35103ccda647Slclee static int
3511e8fb11a1Sshidokht cmlb_dkio_get_efi(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
35123ccda647Slclee {
35133ccda647Slclee 	dk_efi_t	user_efi;
35143ccda647Slclee 	int		rval = 0;
35153ccda647Slclee 	void		*buffer;
3516e8fb11a1Sshidokht 	diskaddr_t	tgt_lba;
35173ccda647Slclee 
35183ccda647Slclee 	if (ddi_copyin(arg, &user_efi, sizeof (dk_efi_t), flag))
35193ccda647Slclee 		return (EFAULT);
35203ccda647Slclee 
35213ccda647Slclee 	user_efi.dki_data = (void *)(uintptr_t)user_efi.dki_data_64;
35223ccda647Slclee 
3523e8fb11a1Sshidokht 	tgt_lba = user_efi.dki_lba;
3524e8fb11a1Sshidokht 
3525e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
3526e8fb11a1Sshidokht 	if ((cmlb_check_update_blockcount(cl, tg_cookie) != 0) ||
3527e8fb11a1Sshidokht 	    (cl->cl_tgt_blocksize == 0)) {
3528e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
3529e8fb11a1Sshidokht 		return (EINVAL);
3530e8fb11a1Sshidokht 	}
3531e8fb11a1Sshidokht 	if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize)
3532e8fb11a1Sshidokht 		tgt_lba = tgt_lba * cl->cl_tgt_blocksize /
3533e8fb11a1Sshidokht 		    cl->cl_sys_blocksize;
3534e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
3535e8fb11a1Sshidokht 
35363ccda647Slclee 	buffer = kmem_alloc(user_efi.dki_length, KM_SLEEP);
3537e8fb11a1Sshidokht 	rval = DK_TG_READ(cl, buffer, tgt_lba, user_efi.dki_length, tg_cookie);
35383ccda647Slclee 	if (rval == 0 && ddi_copyout(buffer, user_efi.dki_data,
35393ccda647Slclee 	    user_efi.dki_length, flag) != 0)
35403ccda647Slclee 		rval = EFAULT;
35413ccda647Slclee 
35423ccda647Slclee 	kmem_free(buffer, user_efi.dki_length);
35433ccda647Slclee 	return (rval);
35443ccda647Slclee }
35453ccda647Slclee 
3546e8fb11a1Sshidokht #if defined(_SUNOS_VTOC_8)
35473ccda647Slclee /*
35483ccda647Slclee  *    Function: cmlb_build_user_vtoc
35493ccda647Slclee  *
35503ccda647Slclee  * Description: This routine populates a pass by reference variable with the
35513ccda647Slclee  *		current volume table of contents.
35523ccda647Slclee  *
3553e8fb11a1Sshidokht  *   Arguments: cl - driver soft state (unit) structure
35543ccda647Slclee  *		user_vtoc - pointer to vtoc structure to be populated
35553ccda647Slclee  */
35563ccda647Slclee static void
3557e8fb11a1Sshidokht cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc)
35583ccda647Slclee {
35593ccda647Slclee 	struct dk_map2		*lpart;
35603ccda647Slclee 	struct dk_map		*lmap;
35613ccda647Slclee 	struct partition	*vpart;
3562342440ecSPrasad Singamsetty 	uint32_t		nblks;
35633ccda647Slclee 	int			i;
35643ccda647Slclee 
3565e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
35663ccda647Slclee 
35673ccda647Slclee 	/*
35683ccda647Slclee 	 * Return vtoc structure fields in the provided VTOC area, addressed
35693ccda647Slclee 	 * by *vtoc.
35703ccda647Slclee 	 */
35713ccda647Slclee 	bzero(user_vtoc, sizeof (struct vtoc));
3572e8fb11a1Sshidokht 	user_vtoc->v_bootinfo[0] = cl->cl_vtoc.v_bootinfo[0];
3573e8fb11a1Sshidokht 	user_vtoc->v_bootinfo[1] = cl->cl_vtoc.v_bootinfo[1];
3574e8fb11a1Sshidokht 	user_vtoc->v_bootinfo[2] = cl->cl_vtoc.v_bootinfo[2];
35753ccda647Slclee 	user_vtoc->v_sanity	= VTOC_SANE;
3576e8fb11a1Sshidokht 	user_vtoc->v_version	= cl->cl_vtoc.v_version;
3577e8fb11a1Sshidokht 	bcopy(cl->cl_vtoc.v_volume, user_vtoc->v_volume, LEN_DKL_VVOL);
3578e8fb11a1Sshidokht 	user_vtoc->v_sectorsz = cl->cl_sys_blocksize;
3579e8fb11a1Sshidokht 	user_vtoc->v_nparts = cl->cl_vtoc.v_nparts;
35803ccda647Slclee 
35813ccda647Slclee 	for (i = 0; i < 10; i++)
3582e8fb11a1Sshidokht 		user_vtoc->v_reserved[i] = cl->cl_vtoc.v_reserved[i];
35833ccda647Slclee 
35843ccda647Slclee 	/*
35853ccda647Slclee 	 * Convert partitioning information.
35863ccda647Slclee 	 *
35873ccda647Slclee 	 * Note the conversion from starting cylinder number
35883ccda647Slclee 	 * to starting sector number.
35893ccda647Slclee 	 */
3590e8fb11a1Sshidokht 	lmap = cl->cl_map;
3591e8fb11a1Sshidokht 	lpart = (struct dk_map2 *)cl->cl_vtoc.v_part;
35923ccda647Slclee 	vpart = user_vtoc->v_part;
35933ccda647Slclee 
3594e8fb11a1Sshidokht 	nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead;
35953ccda647Slclee 
35963ccda647Slclee 	for (i = 0; i < V_NUMPAR; i++) {
35973ccda647Slclee 		vpart->p_tag	= lpart->p_tag;
35983ccda647Slclee 		vpart->p_flag	= lpart->p_flag;
35993ccda647Slclee 		vpart->p_start	= lmap->dkl_cylno * nblks;
36003ccda647Slclee 		vpart->p_size	= lmap->dkl_nblk;
36013ccda647Slclee 		lmap++;
36023ccda647Slclee 		lpart++;
36033ccda647Slclee 		vpart++;
36043ccda647Slclee 
36053ccda647Slclee 		/* (4364927) */
3606e8fb11a1Sshidokht 		user_vtoc->timestamp[i] = (time_t)cl->cl_vtoc.v_timestamp[i];
36073ccda647Slclee 	}
36083ccda647Slclee 
3609e8fb11a1Sshidokht 	bcopy(cl->cl_asciilabel, user_vtoc->v_asciilabel, LEN_DKL_ASCII);
36103ccda647Slclee }
3611e8fb11a1Sshidokht #endif
36123ccda647Slclee 
36133ccda647Slclee static int
3614e8fb11a1Sshidokht cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
3615e8fb11a1Sshidokht     void *tg_cookie)
36163ccda647Slclee {
36173ccda647Slclee 	struct partition64	p64;
36183ccda647Slclee 	int			rval = 0;
36193ccda647Slclee 	uint_t			nparts;
36203ccda647Slclee 	efi_gpe_t		*partitions;
36213ccda647Slclee 	efi_gpt_t		*buffer;
36223ccda647Slclee 	diskaddr_t		gpe_lba;
36233ccda647Slclee 
36243ccda647Slclee 	if (ddi_copyin((const void *)arg, &p64,
36253ccda647Slclee 	    sizeof (struct partition64), flag)) {
36263ccda647Slclee 		return (EFAULT);
36273ccda647Slclee 	}
36283ccda647Slclee 
36293ccda647Slclee 	buffer = kmem_alloc(EFI_MIN_ARRAY_SIZE, KM_SLEEP);
3630e8fb11a1Sshidokht 	rval = DK_TG_READ(cl, buffer, 1, DEV_BSIZE, tg_cookie);
36313ccda647Slclee 	if (rval != 0)
36323ccda647Slclee 		goto done_error;
36333ccda647Slclee 
36343ccda647Slclee 	cmlb_swap_efi_gpt(buffer);
36353ccda647Slclee 
36363ccda647Slclee 	if ((rval = cmlb_validate_efi(buffer)) != 0)
36373ccda647Slclee 		goto done_error;
36383ccda647Slclee 
36393ccda647Slclee 	nparts = buffer->efi_gpt_NumberOfPartitionEntries;
36403ccda647Slclee 	gpe_lba = buffer->efi_gpt_PartitionEntryLBA;
36413ccda647Slclee 	if (p64.p_partno > nparts) {
36423ccda647Slclee 		/* couldn't find it */
36433ccda647Slclee 		rval = ESRCH;
36443ccda647Slclee 		goto done_error;
36453ccda647Slclee 	}
36463ccda647Slclee 	/*
36473ccda647Slclee 	 * if we're dealing with a partition that's out of the normal
36483ccda647Slclee 	 * 16K block, adjust accordingly
36493ccda647Slclee 	 */
36503ccda647Slclee 	gpe_lba += p64.p_partno / sizeof (efi_gpe_t);
3651e8fb11a1Sshidokht 	rval = DK_TG_READ(cl, buffer, gpe_lba, EFI_MIN_ARRAY_SIZE, tg_cookie);
36523ccda647Slclee 
36533ccda647Slclee 	if (rval) {
36543ccda647Slclee 		goto done_error;
36553ccda647Slclee 	}
36563ccda647Slclee 	partitions = (efi_gpe_t *)buffer;
36573ccda647Slclee 
36583ccda647Slclee 	cmlb_swap_efi_gpe(nparts, partitions);
36593ccda647Slclee 
36603ccda647Slclee 	partitions += p64.p_partno;
36613ccda647Slclee 	bcopy(&partitions->efi_gpe_PartitionTypeGUID, &p64.p_type,
36623ccda647Slclee 	    sizeof (struct uuid));
36633ccda647Slclee 	p64.p_start = partitions->efi_gpe_StartingLBA;
36643ccda647Slclee 	p64.p_size = partitions->efi_gpe_EndingLBA -
3665e8fb11a1Sshidokht 	    p64.p_start + 1;
36663ccda647Slclee 
36673ccda647Slclee 	if (ddi_copyout(&p64, (void *)arg, sizeof (struct partition64), flag))
36683ccda647Slclee 		rval = EFAULT;
36693ccda647Slclee 
36703ccda647Slclee done_error:
36713ccda647Slclee 	kmem_free(buffer, EFI_MIN_ARRAY_SIZE);
36723ccda647Slclee 	return (rval);
36733ccda647Slclee }
36743ccda647Slclee 
36753ccda647Slclee 
36763ccda647Slclee /*
36773ccda647Slclee  *    Function: cmlb_dkio_set_vtoc
36783ccda647Slclee  *
36793ccda647Slclee  * Description: This routine is the driver entry point for handling user
36803ccda647Slclee  *		requests to set the current volume table of contents
36813ccda647Slclee  *		(DKIOCSVTOC).
36823ccda647Slclee  *
3683e8fb11a1Sshidokht  *   Arguments:
3684e8fb11a1Sshidokht  *	dev		the device number
3685e8fb11a1Sshidokht  *	arg		pointer to user provided vtoc structure used to set the
36863ccda647Slclee  *			current vtoc.
3687e8fb11a1Sshidokht  *
3688e8fb11a1Sshidokht  *	flag		this argument is a pass through to ddi_copyxxx()
3689e8fb11a1Sshidokht  *			directly from the mode argument of ioctl().
3690e8fb11a1Sshidokht  *
3691e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
3692e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
36933ccda647Slclee  *
36943ccda647Slclee  * Return Code: 0
36953ccda647Slclee  *		EFAULT
36963ccda647Slclee  *		ENXIO
36973ccda647Slclee  *		EINVAL
36983ccda647Slclee  *		ENOTSUP
36993ccda647Slclee  */
37003ccda647Slclee static int
3701e8fb11a1Sshidokht cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag,
3702e8fb11a1Sshidokht     void *tg_cookie)
37033ccda647Slclee {
37043ccda647Slclee 	struct vtoc	user_vtoc;
37053ccda647Slclee 	int		rval = 0;
370606bbe1e0Sedp 	boolean_t	internal;
370706bbe1e0Sedp 
370806bbe1e0Sedp 	internal = ((cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
37093ccda647Slclee 
37103ccda647Slclee #ifdef _MULTI_DATAMODEL
37113ccda647Slclee 	switch (ddi_model_convert_from(flag & FMODELS)) {
37123ccda647Slclee 	case DDI_MODEL_ILP32: {
37133ccda647Slclee 		struct vtoc32 user_vtoc32;
37143ccda647Slclee 
37153ccda647Slclee 		if (ddi_copyin((const void *)arg, &user_vtoc32,
37163ccda647Slclee 		    sizeof (struct vtoc32), flag)) {
37173ccda647Slclee 			return (EFAULT);
37183ccda647Slclee 		}
37193ccda647Slclee 		vtoc32tovtoc(user_vtoc32, user_vtoc);
37203ccda647Slclee 		break;
37213ccda647Slclee 	}
37223ccda647Slclee 
37233ccda647Slclee 	case DDI_MODEL_NONE:
37243ccda647Slclee 		if (ddi_copyin((const void *)arg, &user_vtoc,
37253ccda647Slclee 		    sizeof (struct vtoc), flag)) {
37263ccda647Slclee 			return (EFAULT);
37273ccda647Slclee 		}
37283ccda647Slclee 		break;
37293ccda647Slclee 	}
37303ccda647Slclee #else /* ! _MULTI_DATAMODEL */
37313ccda647Slclee 	if (ddi_copyin((const void *)arg, &user_vtoc,
37323ccda647Slclee 	    sizeof (struct vtoc), flag)) {
37333ccda647Slclee 		return (EFAULT);
37343ccda647Slclee 	}
37353ccda647Slclee #endif /* _MULTI_DATAMODEL */
37363ccda647Slclee 
3737e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
3738342440ecSPrasad Singamsetty 
3739342440ecSPrasad Singamsetty 	if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
3740e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
3741342440ecSPrasad Singamsetty 		return (EOVERFLOW);
37423ccda647Slclee 	}
3743e8fb11a1Sshidokht 
3744e8fb11a1Sshidokht #if defined(__i386) || defined(__amd64)
3745e8fb11a1Sshidokht 	if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) {
3746e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
37473ccda647Slclee 		return (EINVAL);
37483ccda647Slclee 	}
3749e8fb11a1Sshidokht #endif
37503ccda647Slclee 
3751e8fb11a1Sshidokht 	if (cl->cl_g.dkg_ncyl == 0) {
3752e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
3753e8fb11a1Sshidokht 		return (EINVAL);
3754e8fb11a1Sshidokht 	}
3755e8fb11a1Sshidokht 
3756e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
3757e8fb11a1Sshidokht 	cmlb_clear_efi(cl, tg_cookie);
3758e8fb11a1Sshidokht 	ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
3759e8fb11a1Sshidokht 	ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
376048794f22SSriram Popuri 
376148794f22SSriram Popuri 	/*
376248794f22SSriram Popuri 	 * cmlb_dkio_set_vtoc creates duplicate minor nodes when
376348794f22SSriram Popuri 	 * relabeling an SMI disk. To avoid that we remove them
376448794f22SSriram Popuri 	 * before creating.
376548794f22SSriram Popuri 	 * It should be OK to remove a non-existed minor node.
376648794f22SSriram Popuri 	 */
376748794f22SSriram Popuri 	ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
376848794f22SSriram Popuri 	ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
376948794f22SSriram Popuri 
377006bbe1e0Sedp 	(void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
37713ccda647Slclee 	    S_IFBLK, (CMLBUNIT(dev) << CMLBUNIT_SHIFT) | WD_NODE,
377206bbe1e0Sedp 	    cl->cl_node_type, NULL, internal);
377306bbe1e0Sedp 	(void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
37743ccda647Slclee 	    S_IFCHR, (CMLBUNIT(dev) << CMLBUNIT_SHIFT) | WD_NODE,
377506bbe1e0Sedp 	    cl->cl_node_type, NULL, internal);
3776e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
37773ccda647Slclee 
3778e8fb11a1Sshidokht 	if ((rval = cmlb_build_label_vtoc(cl, &user_vtoc)) == 0) {
3779e8fb11a1Sshidokht 		if ((rval = cmlb_write_label(cl, tg_cookie)) == 0) {
3780e8fb11a1Sshidokht 			if (cmlb_validate_geometry(cl, 1, 0, tg_cookie) != 0) {
3781e8fb11a1Sshidokht 				cmlb_dbg(CMLB_ERROR, cl,
37823ccda647Slclee 				    "cmlb_dkio_set_vtoc: "
37833ccda647Slclee 				    "Failed validate geometry\n");
37843ccda647Slclee 			}
3785342440ecSPrasad Singamsetty 			cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
37863ccda647Slclee 		}
37873ccda647Slclee 	}
3788e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
37893ccda647Slclee 	return (rval);
37903ccda647Slclee }
37913ccda647Slclee 
3792342440ecSPrasad Singamsetty /*
3793342440ecSPrasad Singamsetty  *    Function: cmlb_dkio_set_extvtoc
3794342440ecSPrasad Singamsetty  */
3795342440ecSPrasad Singamsetty static int
3796342440ecSPrasad Singamsetty cmlb_dkio_set_extvtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag,
3797342440ecSPrasad Singamsetty     void *tg_cookie)
3798342440ecSPrasad Singamsetty {
3799342440ecSPrasad Singamsetty 	int		rval = 0;
3800342440ecSPrasad Singamsetty 	struct vtoc	user_vtoc;
3801*7e70b434SShidokht Yadegari 	boolean_t	internal;
3802*7e70b434SShidokht Yadegari 
3803342440ecSPrasad Singamsetty 
3804342440ecSPrasad Singamsetty 	/*
3805342440ecSPrasad Singamsetty 	 * Checking callers data model does not make much sense here
3806342440ecSPrasad Singamsetty 	 * since extvtoc will always be equivalent to 64bit vtoc.
3807342440ecSPrasad Singamsetty 	 * What is important is whether the kernel is in 32 or 64 bit
3808342440ecSPrasad Singamsetty 	 */
3809342440ecSPrasad Singamsetty 
3810342440ecSPrasad Singamsetty #ifdef _LP64
3811342440ecSPrasad Singamsetty 	if (ddi_copyin((const void *)arg, &user_vtoc,
3812342440ecSPrasad Singamsetty 		    sizeof (struct extvtoc), flag)) {
3813342440ecSPrasad Singamsetty 			return (EFAULT);
3814342440ecSPrasad Singamsetty 	}
3815342440ecSPrasad Singamsetty #else
3816342440ecSPrasad Singamsetty 	struct	extvtoc	user_extvtoc;
3817342440ecSPrasad Singamsetty 	if (ddi_copyin((const void *)arg, &user_extvtoc,
3818342440ecSPrasad Singamsetty 		    sizeof (struct extvtoc), flag)) {
3819342440ecSPrasad Singamsetty 			return (EFAULT);
3820342440ecSPrasad Singamsetty 	}
3821342440ecSPrasad Singamsetty 
3822342440ecSPrasad Singamsetty 	vtoctovtoc32(user_extvtoc, user_vtoc);
3823342440ecSPrasad Singamsetty #endif
3824342440ecSPrasad Singamsetty 
3825*7e70b434SShidokht Yadegari 	internal = ((cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
3826342440ecSPrasad Singamsetty 	mutex_enter(CMLB_MUTEX(cl));
3827342440ecSPrasad Singamsetty #if defined(__i386) || defined(__amd64)
3828342440ecSPrasad Singamsetty 	if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) {
3829342440ecSPrasad Singamsetty 		mutex_exit(CMLB_MUTEX(cl));
3830342440ecSPrasad Singamsetty 		return (EINVAL);
3831342440ecSPrasad Singamsetty 	}
3832342440ecSPrasad Singamsetty #endif
3833342440ecSPrasad Singamsetty 
3834342440ecSPrasad Singamsetty 	if (cl->cl_g.dkg_ncyl == 0) {
3835342440ecSPrasad Singamsetty 		mutex_exit(CMLB_MUTEX(cl));
3836342440ecSPrasad Singamsetty 		return (EINVAL);
3837342440ecSPrasad Singamsetty 	}
3838342440ecSPrasad Singamsetty 
3839342440ecSPrasad Singamsetty 	mutex_exit(CMLB_MUTEX(cl));
3840342440ecSPrasad Singamsetty 	cmlb_clear_efi(cl, tg_cookie);
3841342440ecSPrasad Singamsetty 	ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
3842342440ecSPrasad Singamsetty 	ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
3843*7e70b434SShidokht Yadegari 	(void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
3844342440ecSPrasad Singamsetty 	    S_IFBLK, (CMLBUNIT(dev) << CMLBUNIT_SHIFT) | WD_NODE,
3845*7e70b434SShidokht Yadegari 	    cl->cl_node_type, NULL, internal);
3846*7e70b434SShidokht Yadegari 	(void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
3847342440ecSPrasad Singamsetty 	    S_IFCHR, (CMLBUNIT(dev) << CMLBUNIT_SHIFT) | WD_NODE,
3848*7e70b434SShidokht Yadegari 	    cl->cl_node_type, NULL, internal);
3849*7e70b434SShidokht Yadegari 
3850342440ecSPrasad Singamsetty 	mutex_enter(CMLB_MUTEX(cl));
3851342440ecSPrasad Singamsetty 
3852342440ecSPrasad Singamsetty 	if ((rval = cmlb_build_label_vtoc(cl, &user_vtoc)) == 0) {
3853342440ecSPrasad Singamsetty 		if ((rval = cmlb_write_label(cl, tg_cookie)) == 0) {
3854342440ecSPrasad Singamsetty 			if (cmlb_validate_geometry(cl, 1, 0, tg_cookie) != 0) {
3855342440ecSPrasad Singamsetty 				cmlb_dbg(CMLB_ERROR, cl,
3856342440ecSPrasad Singamsetty 				    "cmlb_dkio_set_vtoc: "
3857342440ecSPrasad Singamsetty 				    "Failed validate geometry\n");
3858342440ecSPrasad Singamsetty 			}
3859342440ecSPrasad Singamsetty 		}
3860342440ecSPrasad Singamsetty 	}
3861342440ecSPrasad Singamsetty 	mutex_exit(CMLB_MUTEX(cl));
3862342440ecSPrasad Singamsetty 	return (rval);
3863342440ecSPrasad Singamsetty }
38643ccda647Slclee 
38653ccda647Slclee /*
38663ccda647Slclee  *    Function: cmlb_build_label_vtoc
38673ccda647Slclee  *
38683ccda647Slclee  * Description: This routine updates the driver soft state current volume table
38693ccda647Slclee  *		of contents based on a user specified vtoc.
38703ccda647Slclee  *
3871e8fb11a1Sshidokht  *   Arguments: cl - driver soft state (unit) structure
38723ccda647Slclee  *		user_vtoc - pointer to vtoc structure specifying vtoc to be used
38733ccda647Slclee  *			    to update the driver soft state.
38743ccda647Slclee  *
38753ccda647Slclee  * Return Code: 0
38763ccda647Slclee  *		EINVAL
38773ccda647Slclee  */
38783ccda647Slclee static int
3879e8fb11a1Sshidokht cmlb_build_label_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc)
38803ccda647Slclee {
38813ccda647Slclee 	struct dk_map		*lmap;
38823ccda647Slclee 	struct partition	*vpart;
3883342440ecSPrasad Singamsetty 	uint_t			nblks;
38843ccda647Slclee #if defined(_SUNOS_VTOC_8)
38853ccda647Slclee 	int			ncyl;
38863ccda647Slclee 	struct dk_map2		*lpart;
38873ccda647Slclee #endif	/* defined(_SUNOS_VTOC_8) */
38883ccda647Slclee 	int			i;
38893ccda647Slclee 
3890e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
38913ccda647Slclee 
38923ccda647Slclee 	/* Sanity-check the vtoc */
38933ccda647Slclee 	if (user_vtoc->v_sanity != VTOC_SANE ||
3894e8fb11a1Sshidokht 	    user_vtoc->v_sectorsz != cl->cl_sys_blocksize ||
38953ccda647Slclee 	    user_vtoc->v_nparts != V_NUMPAR) {
3896e8fb11a1Sshidokht 		cmlb_dbg(CMLB_INFO,  cl,
38973ccda647Slclee 		    "cmlb_build_label_vtoc: vtoc not valid\n");
38983ccda647Slclee 		return (EINVAL);
38993ccda647Slclee 	}
39003ccda647Slclee 
3901e8fb11a1Sshidokht 	nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead;
39023ccda647Slclee 	if (nblks == 0) {
3903e8fb11a1Sshidokht 		cmlb_dbg(CMLB_INFO,  cl,
39043ccda647Slclee 		    "cmlb_build_label_vtoc: geom nblks is 0\n");
39053ccda647Slclee 		return (EINVAL);
39063ccda647Slclee 	}
39073ccda647Slclee 
39083ccda647Slclee #if defined(_SUNOS_VTOC_8)
39093ccda647Slclee 	vpart = user_vtoc->v_part;
39103ccda647Slclee 	for (i = 0; i < V_NUMPAR; i++) {
3911342440ecSPrasad Singamsetty 		if (((unsigned)vpart->p_start % nblks) != 0) {
3912e8fb11a1Sshidokht 			cmlb_dbg(CMLB_INFO,  cl,
39133ccda647Slclee 			    "cmlb_build_label_vtoc: p_start not multiply of"
39143ccda647Slclee 			    "nblks part %d p_start %d nblks %d\n", i,
39153ccda647Slclee 			    vpart->p_start, nblks);
39163ccda647Slclee 			return (EINVAL);
39173ccda647Slclee 		}
3918342440ecSPrasad Singamsetty 		ncyl = (unsigned)vpart->p_start / nblks;
3919342440ecSPrasad Singamsetty 		ncyl += (unsigned)vpart->p_size / nblks;
3920342440ecSPrasad Singamsetty 		if (((unsigned)vpart->p_size % nblks) != 0) {
39213ccda647Slclee 			ncyl++;
39223ccda647Slclee 		}
3923e8fb11a1Sshidokht 		if (ncyl > (int)cl->cl_g.dkg_ncyl) {
3924e8fb11a1Sshidokht 			cmlb_dbg(CMLB_INFO,  cl,
39253ccda647Slclee 			    "cmlb_build_label_vtoc: ncyl %d  > dkg_ncyl %d"
39263ccda647Slclee 			    "p_size %ld p_start %ld nblks %d  part number %d"
39273ccda647Slclee 			    "tag %d\n",
3928e8fb11a1Sshidokht 			    ncyl, cl->cl_g.dkg_ncyl, vpart->p_size,
39293ccda647Slclee 			    vpart->p_start, nblks,
39303ccda647Slclee 			    i, vpart->p_tag);
39313ccda647Slclee 
39323ccda647Slclee 			return (EINVAL);
39333ccda647Slclee 		}
39343ccda647Slclee 		vpart++;
39353ccda647Slclee 	}
39363ccda647Slclee #endif	/* defined(_SUNOS_VTOC_8) */
39373ccda647Slclee 
39383ccda647Slclee 	/* Put appropriate vtoc structure fields into the disk label */
39393ccda647Slclee #if defined(_SUNOS_VTOC_16)
39403ccda647Slclee 	/*
39413ccda647Slclee 	 * The vtoc is always a 32bit data structure to maintain the
39423ccda647Slclee 	 * on-disk format. Convert "in place" instead of doing bcopy.
39433ccda647Slclee 	 */
3944e8fb11a1Sshidokht 	vtoctovtoc32((*user_vtoc), (*((struct vtoc32 *)&(cl->cl_vtoc))));
39453ccda647Slclee 
39463ccda647Slclee 	/*
39473ccda647Slclee 	 * in the 16-slice vtoc, starting sectors are expressed in
39483ccda647Slclee 	 * numbers *relative* to the start of the Solaris fdisk partition.
39493ccda647Slclee 	 */
3950e8fb11a1Sshidokht 	lmap = cl->cl_map;
39513ccda647Slclee 	vpart = user_vtoc->v_part;
39523ccda647Slclee 
39533ccda647Slclee 	for (i = 0; i < (int)user_vtoc->v_nparts; i++, lmap++, vpart++) {
3954342440ecSPrasad Singamsetty 		lmap->dkl_cylno = (unsigned)vpart->p_start / nblks;
3955342440ecSPrasad Singamsetty 		lmap->dkl_nblk = (unsigned)vpart->p_size;
39563ccda647Slclee 	}
39573ccda647Slclee 
39583ccda647Slclee #elif defined(_SUNOS_VTOC_8)
39593ccda647Slclee 
3960e8fb11a1Sshidokht 	cl->cl_vtoc.v_bootinfo[0] = (uint32_t)user_vtoc->v_bootinfo[0];
3961e8fb11a1Sshidokht 	cl->cl_vtoc.v_bootinfo[1] = (uint32_t)user_vtoc->v_bootinfo[1];
3962e8fb11a1Sshidokht 	cl->cl_vtoc.v_bootinfo[2] = (uint32_t)user_vtoc->v_bootinfo[2];
39633ccda647Slclee 
3964e8fb11a1Sshidokht 	cl->cl_vtoc.v_sanity = (uint32_t)user_vtoc->v_sanity;
3965e8fb11a1Sshidokht 	cl->cl_vtoc.v_version = (uint32_t)user_vtoc->v_version;
39663ccda647Slclee 
3967e8fb11a1Sshidokht 	bcopy(user_vtoc->v_volume, cl->cl_vtoc.v_volume, LEN_DKL_VVOL);
39683ccda647Slclee 
3969e8fb11a1Sshidokht 	cl->cl_vtoc.v_nparts = user_vtoc->v_nparts;
39703ccda647Slclee 
39713ccda647Slclee 	for (i = 0; i < 10; i++)
3972e8fb11a1Sshidokht 		cl->cl_vtoc.v_reserved[i] =  user_vtoc->v_reserved[i];
39733ccda647Slclee 
39743ccda647Slclee 	/*
39753ccda647Slclee 	 * Note the conversion from starting sector number
39763ccda647Slclee 	 * to starting cylinder number.
39773ccda647Slclee 	 * Return error if division results in a remainder.
39783ccda647Slclee 	 */
3979e8fb11a1Sshidokht 	lmap = cl->cl_map;
3980e8fb11a1Sshidokht 	lpart = cl->cl_vtoc.v_part;
39813ccda647Slclee 	vpart = user_vtoc->v_part;
39823ccda647Slclee 
39833ccda647Slclee 	for (i = 0; i < (int)user_vtoc->v_nparts; i++) {
39843ccda647Slclee 		lpart->p_tag  = vpart->p_tag;
39853ccda647Slclee 		lpart->p_flag = vpart->p_flag;
3986342440ecSPrasad Singamsetty 		lmap->dkl_cylno = (unsigned)vpart->p_start / nblks;
3987342440ecSPrasad Singamsetty 		lmap->dkl_nblk = (unsigned)vpart->p_size;
39883ccda647Slclee 
39893ccda647Slclee 		lmap++;
39903ccda647Slclee 		lpart++;
39913ccda647Slclee 		vpart++;
39923ccda647Slclee 
39933ccda647Slclee 		/* (4387723) */
39943ccda647Slclee #ifdef _LP64
39953ccda647Slclee 		if (user_vtoc->timestamp[i] > TIME32_MAX) {
3996e8fb11a1Sshidokht 			cl->cl_vtoc.v_timestamp[i] = TIME32_MAX;
39973ccda647Slclee 		} else {
3998e8fb11a1Sshidokht 			cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i];
39993ccda647Slclee 		}
40003ccda647Slclee #else
4001e8fb11a1Sshidokht 		cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i];
40023ccda647Slclee #endif
40033ccda647Slclee 	}
40043ccda647Slclee 
4005e8fb11a1Sshidokht 	bcopy(user_vtoc->v_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII);
40063ccda647Slclee #else
40073ccda647Slclee #error "No VTOC format defined."
40083ccda647Slclee #endif
40093ccda647Slclee 	return (0);
40103ccda647Slclee }
40113ccda647Slclee 
40123ccda647Slclee /*
40133ccda647Slclee  *    Function: cmlb_clear_efi
40143ccda647Slclee  *
40153ccda647Slclee  * Description: This routine clears all EFI labels.
40163ccda647Slclee  *
4017e8fb11a1Sshidokht  *   Arguments:
4018e8fb11a1Sshidokht  *	cl		 driver soft state (unit) structure
40193ccda647Slclee  *
4020e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
4021e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
40223ccda647Slclee  * Return Code: void
40233ccda647Slclee  */
40243ccda647Slclee static void
4025e8fb11a1Sshidokht cmlb_clear_efi(struct cmlb_lun *cl, void *tg_cookie)
40263ccda647Slclee {
40273ccda647Slclee 	efi_gpt_t	*gpt;
40283ccda647Slclee 	diskaddr_t	cap;
40293ccda647Slclee 	int		rval;
40303ccda647Slclee 
4031e8fb11a1Sshidokht 	ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
4032e8fb11a1Sshidokht 
4033e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
4034e8fb11a1Sshidokht 	cl->cl_reserved = -1;
4035e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
40363ccda647Slclee 
40373ccda647Slclee 	gpt = kmem_alloc(sizeof (efi_gpt_t), KM_SLEEP);
40383ccda647Slclee 
4039e8fb11a1Sshidokht 	if (DK_TG_READ(cl, gpt, 1, DEV_BSIZE, tg_cookie) != 0) {
40403ccda647Slclee 		goto done;
40413ccda647Slclee 	}
40423ccda647Slclee 
40433ccda647Slclee 	cmlb_swap_efi_gpt(gpt);
40443ccda647Slclee 	rval = cmlb_validate_efi(gpt);
40453ccda647Slclee 	if (rval == 0) {
40463ccda647Slclee 		/* clear primary */
40473ccda647Slclee 		bzero(gpt, sizeof (efi_gpt_t));
4048e8fb11a1Sshidokht 		if (rval = DK_TG_WRITE(cl, gpt, 1, EFI_LABEL_SIZE, tg_cookie)) {
4049e8fb11a1Sshidokht 			cmlb_dbg(CMLB_INFO,  cl,
4050e8fb11a1Sshidokht 			    "cmlb_clear_efi: clear primary label failed\n");
40513ccda647Slclee 		}
40523ccda647Slclee 	}
40533ccda647Slclee 	/* the backup */
4054e8fb11a1Sshidokht 	rval = DK_TG_GETCAP(cl, &cap, tg_cookie);
40553ccda647Slclee 	if (rval) {
40563ccda647Slclee 		goto done;
40573ccda647Slclee 	}
40583ccda647Slclee 
4059e8fb11a1Sshidokht 	if ((rval = DK_TG_READ(cl, gpt, cap - 1, EFI_LABEL_SIZE, tg_cookie))
4060e8fb11a1Sshidokht 	    != 0) {
40613ccda647Slclee 		goto done;
40623ccda647Slclee 	}
40633ccda647Slclee 	cmlb_swap_efi_gpt(gpt);
40643ccda647Slclee 	rval = cmlb_validate_efi(gpt);
40653ccda647Slclee 	if (rval == 0) {
40663ccda647Slclee 		/* clear backup */
4067e8fb11a1Sshidokht 		cmlb_dbg(CMLB_TRACE,  cl,
40683ccda647Slclee 		    "cmlb_clear_efi clear backup@%lu\n", cap - 1);
40693ccda647Slclee 		bzero(gpt, sizeof (efi_gpt_t));
4070e8fb11a1Sshidokht 		if ((rval = DK_TG_WRITE(cl,  gpt, cap - 1, EFI_LABEL_SIZE,
4071e8fb11a1Sshidokht 		    tg_cookie))) {
4072e8fb11a1Sshidokht 			cmlb_dbg(CMLB_INFO,  cl,
4073e8fb11a1Sshidokht 			    "cmlb_clear_efi: clear backup label failed\n");
4074e8fb11a1Sshidokht 		}
4075e8fb11a1Sshidokht 	} else {
4076e8fb11a1Sshidokht 		/*
4077e8fb11a1Sshidokht 		 * Refer to comments related to off-by-1 at the
4078e8fb11a1Sshidokht 		 * header of this file
4079e8fb11a1Sshidokht 		 */
4080e8fb11a1Sshidokht 		if ((rval = DK_TG_READ(cl, gpt, cap - 2,
4081e8fb11a1Sshidokht 		    EFI_LABEL_SIZE, tg_cookie)) != 0) {
4082e8fb11a1Sshidokht 			goto done;
4083e8fb11a1Sshidokht 		}
4084e8fb11a1Sshidokht 		cmlb_swap_efi_gpt(gpt);
4085e8fb11a1Sshidokht 		rval = cmlb_validate_efi(gpt);
4086e8fb11a1Sshidokht 		if (rval == 0) {
4087e8fb11a1Sshidokht 			/* clear legacy backup EFI label */
4088e8fb11a1Sshidokht 			cmlb_dbg(CMLB_TRACE,  cl,
4089e8fb11a1Sshidokht 			    "cmlb_clear_efi clear legacy backup@%lu\n",
4090e8fb11a1Sshidokht 			    cap - 2);
4091e8fb11a1Sshidokht 			bzero(gpt, sizeof (efi_gpt_t));
4092e8fb11a1Sshidokht 			if ((rval = DK_TG_WRITE(cl,  gpt, cap - 2,
4093e8fb11a1Sshidokht 			    EFI_LABEL_SIZE, tg_cookie))) {
4094e8fb11a1Sshidokht 				cmlb_dbg(CMLB_INFO,  cl,
4095e8fb11a1Sshidokht 				"cmlb_clear_efi: clear legacy backup label "
4096e8fb11a1Sshidokht 				"failed\n");
4097e8fb11a1Sshidokht 			}
40983ccda647Slclee 		}
40993ccda647Slclee 	}
41003ccda647Slclee 
41013ccda647Slclee done:
41023ccda647Slclee 	kmem_free(gpt, sizeof (efi_gpt_t));
41033ccda647Slclee }
41043ccda647Slclee 
41053ccda647Slclee /*
41063ccda647Slclee  *    Function: cmlb_set_vtoc
41073ccda647Slclee  *
41083ccda647Slclee  * Description: This routine writes data to the appropriate positions
41093ccda647Slclee  *
4110e8fb11a1Sshidokht  *   Arguments:
4111e8fb11a1Sshidokht  *	cl		driver soft state (unit) structure
4112e8fb11a1Sshidokht  *
4113e8fb11a1Sshidokht  *	dkl		the data to be written
4114e8fb11a1Sshidokht  *
4115e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
4116e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
41173ccda647Slclee  *
41183ccda647Slclee  * Return: void
41193ccda647Slclee  */
41203ccda647Slclee static int
4121e8fb11a1Sshidokht cmlb_set_vtoc(struct cmlb_lun *cl, struct dk_label *dkl, void *tg_cookie)
41223ccda647Slclee {
41233ccda647Slclee 	uint_t	label_addr;
41243ccda647Slclee 	int	sec;
4125342440ecSPrasad Singamsetty 	diskaddr_t	blk;
41263ccda647Slclee 	int	head;
41273ccda647Slclee 	int	cyl;
41283ccda647Slclee 	int	rval;
41293ccda647Slclee 
41303ccda647Slclee #if defined(__i386) || defined(__amd64)
4131e8fb11a1Sshidokht 	label_addr = cl->cl_solaris_offset + DK_LABEL_LOC;
41323ccda647Slclee #else
41333ccda647Slclee 	/* Write the primary label at block 0 of the solaris partition. */
41343ccda647Slclee 	label_addr = 0;
41353ccda647Slclee #endif
41363ccda647Slclee 
4137e8fb11a1Sshidokht 	rval = DK_TG_WRITE(cl, dkl, label_addr, cl->cl_sys_blocksize,
4138e8fb11a1Sshidokht 	    tg_cookie);
41393ccda647Slclee 
41403ccda647Slclee 	if (rval != 0) {
41413ccda647Slclee 		return (rval);
41423ccda647Slclee 	}
41433ccda647Slclee 
41443ccda647Slclee 	/*
41453ccda647Slclee 	 * Calculate where the backup labels go.  They are always on
41463ccda647Slclee 	 * the last alternate cylinder, but some older drives put them
41473ccda647Slclee 	 * on head 2 instead of the last head.	They are always on the
41483ccda647Slclee 	 * first 5 odd sectors of the appropriate track.
41493ccda647Slclee 	 *
41503ccda647Slclee 	 * We have no choice at this point, but to believe that the
41513ccda647Slclee 	 * disk label is valid.	 Use the geometry of the disk
41523ccda647Slclee 	 * as described in the label.
41533ccda647Slclee 	 */
41543ccda647Slclee 	cyl  = dkl->dkl_ncyl  + dkl->dkl_acyl - 1;
41553ccda647Slclee 	head = dkl->dkl_nhead - 1;
41563ccda647Slclee 
41573ccda647Slclee 	/*
41583ccda647Slclee 	 * Write and verify the backup labels. Make sure we don't try to
41593ccda647Slclee 	 * write past the last cylinder.
41603ccda647Slclee 	 */
41613ccda647Slclee 	for (sec = 1; ((sec < 5 * 2 + 1) && (sec < dkl->dkl_nsect)); sec += 2) {
4162342440ecSPrasad Singamsetty 		blk = (diskaddr_t)(
41633ccda647Slclee 		    (cyl * ((dkl->dkl_nhead * dkl->dkl_nsect) - dkl->dkl_apc)) +
41643ccda647Slclee 		    (head * dkl->dkl_nsect) + sec);
41653ccda647Slclee #if defined(__i386) || defined(__amd64)
4166e8fb11a1Sshidokht 		blk += cl->cl_solaris_offset;
41673ccda647Slclee #endif
4168e8fb11a1Sshidokht 		rval = DK_TG_WRITE(cl, dkl, blk, cl->cl_sys_blocksize,
4169e8fb11a1Sshidokht 		    tg_cookie);
4170e8fb11a1Sshidokht 		cmlb_dbg(CMLB_INFO,  cl,
4171342440ecSPrasad Singamsetty 		"cmlb_set_vtoc: wrote backup label %llx\n", blk);
41723ccda647Slclee 		if (rval != 0) {
41733ccda647Slclee 			goto exit;
41743ccda647Slclee 		}
41753ccda647Slclee 	}
41763ccda647Slclee exit:
41773ccda647Slclee 	return (rval);
41783ccda647Slclee }
41793ccda647Slclee 
41803ccda647Slclee /*
41813ccda647Slclee  *    Function: cmlb_clear_vtoc
41823ccda647Slclee  *
41833ccda647Slclee  * Description: This routine clears out the VTOC labels.
41843ccda647Slclee  *
4185e8fb11a1Sshidokht  *   Arguments:
4186e8fb11a1Sshidokht  *	cl		driver soft state (unit) structure
4187e8fb11a1Sshidokht  *
4188e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
4189e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
41903ccda647Slclee  *
41913ccda647Slclee  * Return: void
41923ccda647Slclee  */
41933ccda647Slclee static void
4194e8fb11a1Sshidokht cmlb_clear_vtoc(struct cmlb_lun *cl, void *tg_cookie)
41953ccda647Slclee {
41963ccda647Slclee 	struct dk_label		*dkl;
41973ccda647Slclee 
4198e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
41993ccda647Slclee 	dkl = kmem_zalloc(sizeof (struct dk_label), KM_SLEEP);
4200e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
42013ccda647Slclee 	/*
42023ccda647Slclee 	 * cmlb_set_vtoc uses these fields in order to figure out
42033ccda647Slclee 	 * where to overwrite the backup labels
42043ccda647Slclee 	 */
4205e8fb11a1Sshidokht 	dkl->dkl_apc    = cl->cl_g.dkg_apc;
4206e8fb11a1Sshidokht 	dkl->dkl_ncyl   = cl->cl_g.dkg_ncyl;
4207e8fb11a1Sshidokht 	dkl->dkl_acyl   = cl->cl_g.dkg_acyl;
4208e8fb11a1Sshidokht 	dkl->dkl_nhead  = cl->cl_g.dkg_nhead;
4209e8fb11a1Sshidokht 	dkl->dkl_nsect  = cl->cl_g.dkg_nsect;
4210e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
4211e8fb11a1Sshidokht 	(void) cmlb_set_vtoc(cl, dkl, tg_cookie);
42123ccda647Slclee 	kmem_free(dkl, sizeof (struct dk_label));
42133ccda647Slclee 
4214e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
42153ccda647Slclee }
42163ccda647Slclee 
42173ccda647Slclee /*
42183ccda647Slclee  *    Function: cmlb_write_label
42193ccda647Slclee  *
42203ccda647Slclee  * Description: This routine will validate and write the driver soft state vtoc
42213ccda647Slclee  *		contents to the device.
42223ccda647Slclee  *
4223e8fb11a1Sshidokht  *   Arguments:
4224e8fb11a1Sshidokht  *	cl		cmlb handle
4225e8fb11a1Sshidokht  *
4226e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
4227e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
4228e8fb11a1Sshidokht  *
42293ccda647Slclee  *
42303ccda647Slclee  * Return Code: the code returned by cmlb_send_scsi_cmd()
42313ccda647Slclee  *		0
42323ccda647Slclee  *		EINVAL
42333ccda647Slclee  *		ENXIO
42343ccda647Slclee  *		ENOMEM
42353ccda647Slclee  */
42363ccda647Slclee static int
4237e8fb11a1Sshidokht cmlb_write_label(struct cmlb_lun *cl, void *tg_cookie)
42383ccda647Slclee {
42393ccda647Slclee 	struct dk_label	*dkl;
42403ccda647Slclee 	short		sum;
42413ccda647Slclee 	short		*sp;
42423ccda647Slclee 	int		i;
42433ccda647Slclee 	int		rval;
42443ccda647Slclee 
4245e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
4246e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
42473ccda647Slclee 	dkl = kmem_zalloc(sizeof (struct dk_label), KM_SLEEP);
4248e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
4249e8fb11a1Sshidokht 
4250e8fb11a1Sshidokht 	bcopy(&cl->cl_vtoc, &dkl->dkl_vtoc, sizeof (struct dk_vtoc));
4251e8fb11a1Sshidokht 	dkl->dkl_rpm	= cl->cl_g.dkg_rpm;
4252e8fb11a1Sshidokht 	dkl->dkl_pcyl	= cl->cl_g.dkg_pcyl;
4253e8fb11a1Sshidokht 	dkl->dkl_apc	= cl->cl_g.dkg_apc;
4254e8fb11a1Sshidokht 	dkl->dkl_intrlv = cl->cl_g.dkg_intrlv;
4255e8fb11a1Sshidokht 	dkl->dkl_ncyl	= cl->cl_g.dkg_ncyl;
4256e8fb11a1Sshidokht 	dkl->dkl_acyl	= cl->cl_g.dkg_acyl;
4257e8fb11a1Sshidokht 	dkl->dkl_nhead	= cl->cl_g.dkg_nhead;
4258e8fb11a1Sshidokht 	dkl->dkl_nsect	= cl->cl_g.dkg_nsect;
42593ccda647Slclee 
42603ccda647Slclee #if defined(_SUNOS_VTOC_8)
4261e8fb11a1Sshidokht 	dkl->dkl_obs1	= cl->cl_g.dkg_obs1;
4262e8fb11a1Sshidokht 	dkl->dkl_obs2	= cl->cl_g.dkg_obs2;
4263e8fb11a1Sshidokht 	dkl->dkl_obs3	= cl->cl_g.dkg_obs3;
42643ccda647Slclee 	for (i = 0; i < NDKMAP; i++) {
4265e8fb11a1Sshidokht 		dkl->dkl_map[i].dkl_cylno = cl->cl_map[i].dkl_cylno;
4266e8fb11a1Sshidokht 		dkl->dkl_map[i].dkl_nblk  = cl->cl_map[i].dkl_nblk;
42673ccda647Slclee 	}
4268e8fb11a1Sshidokht 	bcopy(cl->cl_asciilabel, dkl->dkl_asciilabel, LEN_DKL_ASCII);
42693ccda647Slclee #elif defined(_SUNOS_VTOC_16)
4270e8fb11a1Sshidokht 	dkl->dkl_skew	= cl->cl_dkg_skew;
42713ccda647Slclee #else
42723ccda647Slclee #error "No VTOC format defined."
42733ccda647Slclee #endif
42743ccda647Slclee 
42753ccda647Slclee 	dkl->dkl_magic			= DKL_MAGIC;
4276e8fb11a1Sshidokht 	dkl->dkl_write_reinstruct	= cl->cl_g.dkg_write_reinstruct;
4277e8fb11a1Sshidokht 	dkl->dkl_read_reinstruct	= cl->cl_g.dkg_read_reinstruct;
42783ccda647Slclee 
42793ccda647Slclee 	/* Construct checksum for the new disk label */
42803ccda647Slclee 	sum = 0;
42813ccda647Slclee 	sp = (short *)dkl;
42823ccda647Slclee 	i = sizeof (struct dk_label) / sizeof (short);
42833ccda647Slclee 	while (i--) {
42843ccda647Slclee 		sum ^= *sp++;
42853ccda647Slclee 	}
42863ccda647Slclee 	dkl->dkl_cksum = sum;
42873ccda647Slclee 
4288e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
42893ccda647Slclee 
4290e8fb11a1Sshidokht 	rval = cmlb_set_vtoc(cl, dkl, tg_cookie);
42913ccda647Slclee exit:
42923ccda647Slclee 	kmem_free(dkl, sizeof (struct dk_label));
4293e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
42943ccda647Slclee 	return (rval);
42953ccda647Slclee }
42963ccda647Slclee 
42973ccda647Slclee static int
4298e8fb11a1Sshidokht cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag,
4299e8fb11a1Sshidokht     void *tg_cookie)
43003ccda647Slclee {
43013ccda647Slclee 	dk_efi_t	user_efi;
43023ccda647Slclee 	int		rval = 0;
43033ccda647Slclee 	void		*buffer;
4304e8fb11a1Sshidokht 	diskaddr_t	tgt_lba;
430506bbe1e0Sedp 	boolean_t	internal;
43063ccda647Slclee 
43073ccda647Slclee 	if (ddi_copyin(arg, &user_efi, sizeof (dk_efi_t), flag))
43083ccda647Slclee 		return (EFAULT);
43093ccda647Slclee 
431006bbe1e0Sedp 	internal = ((cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
431106bbe1e0Sedp 
43123ccda647Slclee 	user_efi.dki_data = (void *)(uintptr_t)user_efi.dki_data_64;
43133ccda647Slclee 
43143ccda647Slclee 	buffer = kmem_alloc(user_efi.dki_length, KM_SLEEP);
43153ccda647Slclee 	if (ddi_copyin(user_efi.dki_data, buffer, user_efi.dki_length, flag)) {
43163ccda647Slclee 		rval = EFAULT;
43173ccda647Slclee 	} else {
43183ccda647Slclee 		/*
43193ccda647Slclee 		 * let's clear the vtoc labels and clear the softstate
43203ccda647Slclee 		 * vtoc.
43213ccda647Slclee 		 */
4322e8fb11a1Sshidokht 		mutex_enter(CMLB_MUTEX(cl));
4323e8fb11a1Sshidokht 		if (cl->cl_vtoc.v_sanity == VTOC_SANE) {
4324e8fb11a1Sshidokht 			cmlb_dbg(CMLB_TRACE,  cl,
4325e8fb11a1Sshidokht 			    "cmlb_dkio_set_efi: CLEAR VTOC\n");
4326342440ecSPrasad Singamsetty 			if (cl->cl_label_from_media == CMLB_LABEL_VTOC)
4327e8fb11a1Sshidokht 				cmlb_clear_vtoc(cl, tg_cookie);
4328e8fb11a1Sshidokht 			bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
4329e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
4330e8fb11a1Sshidokht 			ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
4331e8fb11a1Sshidokht 			ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
433206bbe1e0Sedp 			(void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd",
43333ccda647Slclee 			    S_IFBLK,
43343ccda647Slclee 			    (CMLBUNIT(dev) << CMLBUNIT_SHIFT) | WD_NODE,
433506bbe1e0Sedp 			    cl->cl_node_type, NULL, internal);
433606bbe1e0Sedp 			(void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd,raw",
43373ccda647Slclee 			    S_IFCHR,
43383ccda647Slclee 			    (CMLBUNIT(dev) << CMLBUNIT_SHIFT) | WD_NODE,
433906bbe1e0Sedp 			    cl->cl_node_type, NULL, internal);
43403ccda647Slclee 		} else
4341e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
4342e8fb11a1Sshidokht 
4343e8fb11a1Sshidokht 		tgt_lba = user_efi.dki_lba;
4344e8fb11a1Sshidokht 
4345e8fb11a1Sshidokht 		mutex_enter(CMLB_MUTEX(cl));
4346e8fb11a1Sshidokht 		if ((cmlb_check_update_blockcount(cl, tg_cookie) != 0) ||
4347e8fb11a1Sshidokht 		    (cl->cl_tgt_blocksize == 0)) {
4348e8fb11a1Sshidokht 			kmem_free(buffer, user_efi.dki_length);
4349e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
4350e8fb11a1Sshidokht 			return (EINVAL);
4351e8fb11a1Sshidokht 		}
4352e8fb11a1Sshidokht 		if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize)
4353e8fb11a1Sshidokht 			tgt_lba = tgt_lba *
4354e8fb11a1Sshidokht 			    cl->cl_tgt_blocksize / cl->cl_sys_blocksize;
4355e8fb11a1Sshidokht 
4356e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
4357e8fb11a1Sshidokht 		rval = DK_TG_WRITE(cl, buffer, tgt_lba, user_efi.dki_length,
4358e8fb11a1Sshidokht 		    tg_cookie);
4359e8fb11a1Sshidokht 
43603ccda647Slclee 		if (rval == 0) {
4361e8fb11a1Sshidokht 			mutex_enter(CMLB_MUTEX(cl));
4362e8fb11a1Sshidokht 			cl->cl_f_geometry_is_valid = FALSE;
4363e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
43643ccda647Slclee 		}
43653ccda647Slclee 	}
43663ccda647Slclee 	kmem_free(buffer, user_efi.dki_length);
43673ccda647Slclee 	return (rval);
43683ccda647Slclee }
43693ccda647Slclee 
43703ccda647Slclee /*
43713ccda647Slclee  *    Function: cmlb_dkio_get_mboot
43723ccda647Slclee  *
43733ccda647Slclee  * Description: This routine is the driver entry point for handling user
43743ccda647Slclee  *		requests to get the current device mboot (DKIOCGMBOOT)
43753ccda647Slclee  *
43763ccda647Slclee  *   Arguments:
4377e8fb11a1Sshidokht  *	arg		pointer to user provided mboot structure specifying
43783ccda647Slclee  *			the current mboot.
4379e8fb11a1Sshidokht  *
4380e8fb11a1Sshidokht  *	flag		this argument is a pass through to ddi_copyxxx()
4381e8fb11a1Sshidokht  *			directly from the mode argument of ioctl().
4382e8fb11a1Sshidokht  *
4383e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
4384e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
43853ccda647Slclee  *
43863ccda647Slclee  * Return Code: 0
43873ccda647Slclee  *		EINVAL
43883ccda647Slclee  *		EFAULT
43893ccda647Slclee  *		ENXIO
43903ccda647Slclee  */
43913ccda647Slclee static int
4392e8fb11a1Sshidokht cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
43933ccda647Slclee {
43943ccda647Slclee 	struct mboot	*mboot;
43953ccda647Slclee 	int		rval;
43963ccda647Slclee 	size_t		buffer_size;
43973ccda647Slclee 
43983ccda647Slclee 
43993ccda647Slclee #if defined(_SUNOS_VTOC_8)
4400e8fb11a1Sshidokht 	if ((!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) || (arg == NULL)) {
44013ccda647Slclee #elif defined(_SUNOS_VTOC_16)
44023ccda647Slclee 	if (arg == NULL) {
44033ccda647Slclee #endif
44043ccda647Slclee 		return (EINVAL);
44053ccda647Slclee 	}
44063ccda647Slclee 
44073ccda647Slclee 	/*
44083ccda647Slclee 	 * Read the mboot block, located at absolute block 0 on the target.
44093ccda647Slclee 	 */
44103ccda647Slclee 	buffer_size = sizeof (struct mboot);
44113ccda647Slclee 
4412e8fb11a1Sshidokht 	cmlb_dbg(CMLB_TRACE,  cl,
44133ccda647Slclee 	    "cmlb_dkio_get_mboot: allocation size: 0x%x\n", buffer_size);
44143ccda647Slclee 
44153ccda647Slclee 	mboot = kmem_zalloc(buffer_size, KM_SLEEP);
4416e8fb11a1Sshidokht 	if ((rval = DK_TG_READ(cl, mboot, 0, buffer_size, tg_cookie)) == 0) {
44173ccda647Slclee 		if (ddi_copyout(mboot, (void *)arg,
44183ccda647Slclee 		    sizeof (struct mboot), flag) != 0) {
44193ccda647Slclee 			rval = EFAULT;
44203ccda647Slclee 		}
44213ccda647Slclee 	}
44223ccda647Slclee 	kmem_free(mboot, buffer_size);
44233ccda647Slclee 	return (rval);
44243ccda647Slclee }
44253ccda647Slclee 
44263ccda647Slclee 
44273ccda647Slclee /*
44283ccda647Slclee  *    Function: cmlb_dkio_set_mboot
44293ccda647Slclee  *
44303ccda647Slclee  * Description: This routine is the driver entry point for handling user
44313ccda647Slclee  *		requests to validate and set the device master boot
44323ccda647Slclee  *		(DKIOCSMBOOT).
44333ccda647Slclee  *
44343ccda647Slclee  *   Arguments:
4435e8fb11a1Sshidokht  *	arg		pointer to user provided mboot structure used to set the
44363ccda647Slclee  *			master boot.
4437e8fb11a1Sshidokht  *
4438e8fb11a1Sshidokht  *	flag		this argument is a pass through to ddi_copyxxx()
4439e8fb11a1Sshidokht  *			directly from the mode argument of ioctl().
4440e8fb11a1Sshidokht  *
4441e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
4442e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
44433ccda647Slclee  *
44443ccda647Slclee  * Return Code: 0
44453ccda647Slclee  *		EINVAL
44463ccda647Slclee  *		EFAULT
44473ccda647Slclee  *		ENXIO
44483ccda647Slclee  */
44493ccda647Slclee static int
4450e8fb11a1Sshidokht cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
44513ccda647Slclee {
44523ccda647Slclee 	struct mboot	*mboot = NULL;
44533ccda647Slclee 	int		rval;
44543ccda647Slclee 	ushort_t	magic;
44553ccda647Slclee 
44563ccda647Slclee 
4457e8fb11a1Sshidokht 	ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
44583ccda647Slclee 
44593ccda647Slclee #if defined(_SUNOS_VTOC_8)
4460e8fb11a1Sshidokht 	if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
44613ccda647Slclee 		return (EINVAL);
44623ccda647Slclee 	}
44633ccda647Slclee #endif
44643ccda647Slclee 
44653ccda647Slclee 	if (arg == NULL) {
44663ccda647Slclee 		return (EINVAL);
44673ccda647Slclee 	}
44683ccda647Slclee 
44693ccda647Slclee 	mboot = kmem_zalloc(sizeof (struct mboot), KM_SLEEP);
44703ccda647Slclee 
44713ccda647Slclee 	if (ddi_copyin((const void *)arg, mboot,
44723ccda647Slclee 	    sizeof (struct mboot), flag) != 0) {
44733ccda647Slclee 		kmem_free(mboot, (size_t)(sizeof (struct mboot)));
44743ccda647Slclee 		return (EFAULT);
44753ccda647Slclee 	}
44763ccda647Slclee 
44773ccda647Slclee 	/* Is this really a master boot record? */
44783ccda647Slclee 	magic = LE_16(mboot->signature);
44793ccda647Slclee 	if (magic != MBB_MAGIC) {
44803ccda647Slclee 		kmem_free(mboot, (size_t)(sizeof (struct mboot)));
44813ccda647Slclee 		return (EINVAL);
44823ccda647Slclee 	}
44833ccda647Slclee 
4484e8fb11a1Sshidokht 	rval = DK_TG_WRITE(cl, mboot, 0, cl->cl_sys_blocksize, tg_cookie);
44853ccda647Slclee 
4486e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
44873ccda647Slclee #if defined(__i386) || defined(__amd64)
44883ccda647Slclee 	if (rval == 0) {
44893ccda647Slclee 		/*
44903ccda647Slclee 		 * mboot has been written successfully.
44913ccda647Slclee 		 * update the fdisk and vtoc tables in memory
44923ccda647Slclee 		 */
4493e8fb11a1Sshidokht 		rval = cmlb_update_fdisk_and_vtoc(cl, tg_cookie);
4494e8fb11a1Sshidokht 		if ((cl->cl_f_geometry_is_valid == FALSE) || (rval != 0)) {
4495e8fb11a1Sshidokht 			mutex_exit(CMLB_MUTEX(cl));
44963ccda647Slclee 			kmem_free(mboot, (size_t)(sizeof (struct mboot)));
44973ccda647Slclee 			return (rval);
44983ccda647Slclee 		}
44993ccda647Slclee 	}
4500e8fb11a1Sshidokht 
4501e8fb11a1Sshidokht #ifdef __lock_lint
4502e8fb11a1Sshidokht 	cmlb_setup_default_geometry(cl, tg_cookie);
4503e8fb11a1Sshidokht #endif
4504e8fb11a1Sshidokht 
45053ccda647Slclee #else
45063ccda647Slclee 	if (rval == 0) {
45073ccda647Slclee 		/*
45083ccda647Slclee 		 * mboot has been written successfully.
45093ccda647Slclee 		 * set up the default geometry and VTOC
45103ccda647Slclee 		 */
4511342440ecSPrasad Singamsetty 		if (cl->cl_blockcount <= CMLB_EXTVTOC_LIMIT)
4512e8fb11a1Sshidokht 			cmlb_setup_default_geometry(cl, tg_cookie);
45133ccda647Slclee 	}
45143ccda647Slclee #endif
4515342440ecSPrasad Singamsetty 	cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
4516e8fb11a1Sshidokht 	mutex_exit(CMLB_MUTEX(cl));
45173ccda647Slclee 	kmem_free(mboot, (size_t)(sizeof (struct mboot)));
45183ccda647Slclee 	return (rval);
45193ccda647Slclee }
45203ccda647Slclee 
45213ccda647Slclee 
45223ccda647Slclee /*
45233ccda647Slclee  *    Function: cmlb_setup_default_geometry
45243ccda647Slclee  *
45253ccda647Slclee  * Description: This local utility routine sets the default geometry as part of
45263ccda647Slclee  *		setting the device mboot.
45273ccda647Slclee  *
4528e8fb11a1Sshidokht  *   Arguments:
4529e8fb11a1Sshidokht  *	cl		driver soft state (unit) structure
4530e8fb11a1Sshidokht  *
4531e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
4532e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
4533e8fb11a1Sshidokht  *
45343ccda647Slclee  *
45353ccda647Slclee  * Note: This may be redundant with cmlb_build_default_label.
45363ccda647Slclee  */
45373ccda647Slclee static void
4538e8fb11a1Sshidokht cmlb_setup_default_geometry(struct cmlb_lun *cl, void *tg_cookie)
45393ccda647Slclee {
45403ccda647Slclee 	struct cmlb_geom	pgeom;
45413ccda647Slclee 	struct cmlb_geom	*pgeomp = &pgeom;
45423ccda647Slclee 	int			ret;
45433ccda647Slclee 	int			geom_base_cap = 1;
45443ccda647Slclee 
45453ccda647Slclee 
4546e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
45473ccda647Slclee 
45483ccda647Slclee 	/* zero out the soft state geometry and partition table. */
4549e8fb11a1Sshidokht 	bzero(&cl->cl_g, sizeof (struct dk_geom));
4550e8fb11a1Sshidokht 	bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
4551e8fb11a1Sshidokht 	bzero(cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
45523ccda647Slclee 
45533ccda647Slclee 	/*
45543ccda647Slclee 	 * For the rpm, we use the minimum for the disk.
45553ccda647Slclee 	 * For the head, cyl and number of sector per track,
45563ccda647Slclee 	 * if the capacity <= 1GB, head = 64, sect = 32.
45573ccda647Slclee 	 * else head = 255, sect 63
45583ccda647Slclee 	 * Note: the capacity should be equal to C*H*S values.
45593ccda647Slclee 	 * This will cause some truncation of size due to
45603ccda647Slclee 	 * round off errors. For CD-ROMs, this truncation can
45613ccda647Slclee 	 * have adverse side effects, so returning ncyl and
45623ccda647Slclee 	 * nhead as 1. The nsect will overflow for most of
45633ccda647Slclee 	 * CD-ROMs as nsect is of type ushort.
45643ccda647Slclee 	 */
4565e8fb11a1Sshidokht 	if (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) {
45663ccda647Slclee 		/*
45673ccda647Slclee 		 * newfs currently can not handle 255 ntracks for SPARC
45683ccda647Slclee 		 * so get the geometry from target driver instead of coming up
45693ccda647Slclee 		 * with one based on capacity.
45703ccda647Slclee 		 */
4571e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
4572e8fb11a1Sshidokht 		ret = DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie);
4573e8fb11a1Sshidokht 		mutex_enter(CMLB_MUTEX(cl));
45743ccda647Slclee 
45753ccda647Slclee 		if (ret  == 0) {
45763ccda647Slclee 			geom_base_cap = 0;
45773ccda647Slclee 		} else {
4578e8fb11a1Sshidokht 			cmlb_dbg(CMLB_ERROR,  cl,
45793ccda647Slclee 			    "cmlb_setup_default_geometry: "
45803ccda647Slclee 			    "tg_getphygeom failed %d\n", ret);
45813ccda647Slclee 
45823ccda647Slclee 			/* do default setting, geometry based on capacity */
45833ccda647Slclee 		}
45843ccda647Slclee 	}
45853ccda647Slclee 
45863ccda647Slclee 	if (geom_base_cap) {
4587e8fb11a1Sshidokht 		if (ISCD(cl)) {
4588e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl = 1;
4589e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 1;
4590e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = cl->cl_blockcount;
4591e8fb11a1Sshidokht 		} else if (cl->cl_blockcount <= 0x1000) {
45923ccda647Slclee 			/* Needed for unlabeled SCSI floppies. */
4593e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 2;
4594e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl = 80;
4595e8fb11a1Sshidokht 			cl->cl_g.dkg_pcyl = 80;
4596e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = cl->cl_blockcount / (2 * 80);
4597e8fb11a1Sshidokht 		} else if (cl->cl_blockcount <= 0x200000) {
4598e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 64;
4599e8fb11a1Sshidokht 			cl->cl_g.dkg_nsect = 32;
4600e8fb11a1Sshidokht 			cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32);
46013ccda647Slclee 		} else {
4602e8fb11a1Sshidokht 			cl->cl_g.dkg_nhead = 255;
460398a65dd4Sshidokht 
460498a65dd4Sshidokht 			cl->cl_g.dkg_nsect = ((cl->cl_blockcount +
460598a65dd4Sshidokht 			    (UINT16_MAX * 255 * 63) - 1) /
460698a65dd4Sshidokht 			    (UINT16_MAX * 255 * 63)) * 63;
460798a65dd4Sshidokht 
460898a65dd4Sshidokht 			if (cl->cl_g.dkg_nsect == 0)
460998a65dd4Sshidokht 				cl->cl_g.dkg_nsect = (UINT16_MAX / 63) * 63;
461098a65dd4Sshidokht 
461198a65dd4Sshidokht 			cl->cl_g.dkg_ncyl = cl->cl_blockcount /
461298a65dd4Sshidokht 			    (255 * cl->cl_g.dkg_nsect);
46133ccda647Slclee 		}
46143ccda647Slclee 
4615e8fb11a1Sshidokht 		cl->cl_g.dkg_acyl = 0;
4616e8fb11a1Sshidokht 		cl->cl_g.dkg_bcyl = 0;
4617e8fb11a1Sshidokht 		cl->cl_g.dkg_intrlv = 1;
4618e8fb11a1Sshidokht 		cl->cl_g.dkg_rpm = 200;
4619e8fb11a1Sshidokht 		if (cl->cl_g.dkg_pcyl == 0)
4620e8fb11a1Sshidokht 			cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl +
4621e8fb11a1Sshidokht 			    cl->cl_g.dkg_acyl;
46223ccda647Slclee 	} else {
4623e8fb11a1Sshidokht 		cl->cl_g.dkg_ncyl = (short)pgeomp->g_ncyl;
4624e8fb11a1Sshidokht 		cl->cl_g.dkg_acyl = pgeomp->g_acyl;
4625e8fb11a1Sshidokht 		cl->cl_g.dkg_nhead = pgeomp->g_nhead;
4626e8fb11a1Sshidokht 		cl->cl_g.dkg_nsect = pgeomp->g_nsect;
4627e8fb11a1Sshidokht 		cl->cl_g.dkg_intrlv = pgeomp->g_intrlv;
4628e8fb11a1Sshidokht 		cl->cl_g.dkg_rpm = pgeomp->g_rpm;
4629e8fb11a1Sshidokht 		cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl;
4630e8fb11a1Sshidokht 	}
4631e8fb11a1Sshidokht 
4632e8fb11a1Sshidokht 	cl->cl_g.dkg_read_reinstruct = 0;
4633e8fb11a1Sshidokht 	cl->cl_g.dkg_write_reinstruct = 0;
4634e8fb11a1Sshidokht 	cl->cl_solaris_size = cl->cl_g.dkg_ncyl *
4635e8fb11a1Sshidokht 	    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
4636e8fb11a1Sshidokht 
4637e8fb11a1Sshidokht 	cl->cl_map['a'-'a'].dkl_cylno = 0;
4638e8fb11a1Sshidokht 	cl->cl_map['a'-'a'].dkl_nblk = cl->cl_solaris_size;
4639e8fb11a1Sshidokht 
4640e8fb11a1Sshidokht 	cl->cl_map['c'-'a'].dkl_cylno = 0;
4641e8fb11a1Sshidokht 	cl->cl_map['c'-'a'].dkl_nblk = cl->cl_solaris_size;
4642e8fb11a1Sshidokht 
4643e8fb11a1Sshidokht 	cl->cl_vtoc.v_part[2].p_tag   = V_BACKUP;
4644e8fb11a1Sshidokht 	cl->cl_vtoc.v_part[2].p_flag  = V_UNMNT;
4645e8fb11a1Sshidokht 	cl->cl_vtoc.v_nparts = V_NUMPAR;
4646e8fb11a1Sshidokht 	cl->cl_vtoc.v_version = V_VERSION;
4647e8fb11a1Sshidokht 	(void) sprintf((char *)cl->cl_asciilabel, "DEFAULT cyl %d alt %d"
4648e8fb11a1Sshidokht 	    " hd %d sec %d", cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
4649e8fb11a1Sshidokht 	    cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
4650e8fb11a1Sshidokht 
4651e8fb11a1Sshidokht 	cl->cl_f_geometry_is_valid = FALSE;
46523ccda647Slclee }
46533ccda647Slclee 
46543ccda647Slclee 
46553ccda647Slclee #if defined(__i386) || defined(__amd64)
46563ccda647Slclee /*
46573ccda647Slclee  *    Function: cmlb_update_fdisk_and_vtoc
46583ccda647Slclee  *
46593ccda647Slclee  * Description: This local utility routine updates the device fdisk and vtoc
46603ccda647Slclee  *		as part of setting the device mboot.
46613ccda647Slclee  *
4662e8fb11a1Sshidokht  *   Arguments:
4663e8fb11a1Sshidokht  *	cl		driver soft state (unit) structure
4664e8fb11a1Sshidokht  *
4665e8fb11a1Sshidokht  *	tg_cookie	cookie from target driver to be passed back to target
4666e8fb11a1Sshidokht  *			driver when we call back to it through tg_ops.
4667e8fb11a1Sshidokht  *
46683ccda647Slclee  *
46693ccda647Slclee  * Return Code: 0 for success or errno-type return code.
46703ccda647Slclee  *
46713ccda647Slclee  *    Note:x86: This looks like a duplicate of cmlb_validate_geometry(), but
46723ccda647Slclee  *		these did exist separately in x86 sd.c.
46733ccda647Slclee  */
46743ccda647Slclee static int
4675e8fb11a1Sshidokht cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie)
46763ccda647Slclee {
46773ccda647Slclee 	int		count;
46783ccda647Slclee 	int		label_rc = 0;
46793ccda647Slclee 	int		fdisk_rval;
46803ccda647Slclee 	diskaddr_t	capacity;
46813ccda647Slclee 
4682e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
46833ccda647Slclee 
4684e8fb11a1Sshidokht 	if (cmlb_check_update_blockcount(cl, tg_cookie) != 0)
46853ccda647Slclee 		return (EINVAL);
46863ccda647Slclee 
46873ccda647Slclee #if defined(_SUNOS_VTOC_16)
46883ccda647Slclee 	/*
46893ccda647Slclee 	 * Set up the "whole disk" fdisk partition; this should always
46903ccda647Slclee 	 * exist, regardless of whether the disk contains an fdisk table
46913ccda647Slclee 	 * or vtoc.
46923ccda647Slclee 	 */
4693e8fb11a1Sshidokht 	cl->cl_map[P0_RAW_DISK].dkl_cylno = 0;
4694e8fb11a1Sshidokht 	cl->cl_map[P0_RAW_DISK].dkl_nblk = cl->cl_blockcount;
46953ccda647Slclee #endif	/* defined(_SUNOS_VTOC_16) */
46963ccda647Slclee 
46973ccda647Slclee 	/*
46983ccda647Slclee 	 * copy the lbasize and capacity so that if they're
4699e8fb11a1Sshidokht 	 * reset while we're not holding the CMLB_MUTEX(cl), we will
4700e8fb11a1Sshidokht 	 * continue to use valid values after the CMLB_MUTEX(cl) is
47013ccda647Slclee 	 * reacquired.
47023ccda647Slclee 	 */
4703e8fb11a1Sshidokht 	capacity = cl->cl_blockcount;
47043ccda647Slclee 
47053ccda647Slclee 	/*
47063ccda647Slclee 	 * refresh the logical and physical geometry caches.
47073ccda647Slclee 	 * (data from mode sense format/rigid disk geometry pages,
47083ccda647Slclee 	 * and scsi_ifgetcap("geometry").
47093ccda647Slclee 	 */
4710e8fb11a1Sshidokht 	cmlb_resync_geom_caches(cl, capacity, tg_cookie);
47113ccda647Slclee 
47123ccda647Slclee 	/*
4713e8fb11a1Sshidokht 	 * Only DIRECT ACCESS devices will have Scl labels.
4714e8fb11a1Sshidokht 	 * CD's supposedly have a Scl label, too
47153ccda647Slclee 	 */
4716e8fb11a1Sshidokht 	if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) {
4717e8fb11a1Sshidokht 		fdisk_rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
47183ccda647Slclee 		if (fdisk_rval != 0) {
4719e8fb11a1Sshidokht 			ASSERT(mutex_owned(CMLB_MUTEX(cl)));
47203ccda647Slclee 			return (fdisk_rval);
47213ccda647Slclee 		}
47223ccda647Slclee 
4723e8fb11a1Sshidokht 		if (cl->cl_solaris_size <= DK_LABEL_LOC) {
47243ccda647Slclee 			/*
47253ccda647Slclee 			 * Found fdisk table but no Solaris partition entry,
47263ccda647Slclee 			 * so don't call cmlb_uselabel() and don't create
47273ccda647Slclee 			 * a default label.
47283ccda647Slclee 			 */
47293ccda647Slclee 			label_rc = 0;
4730e8fb11a1Sshidokht 			cl->cl_f_geometry_is_valid = TRUE;
47313ccda647Slclee 			goto no_solaris_partition;
47323ccda647Slclee 		}
47333ccda647Slclee 	} else if (capacity < 0) {
4734e8fb11a1Sshidokht 		ASSERT(mutex_owned(CMLB_MUTEX(cl)));
47353ccda647Slclee 		return (EINVAL);
47363ccda647Slclee 	}
47373ccda647Slclee 
47383ccda647Slclee 	/*
47393ccda647Slclee 	 * For Removable media We reach here if we have found a
47403ccda647Slclee 	 * SOLARIS PARTITION.
4741e8fb11a1Sshidokht 	 * If cl_f_geometry_is_valid is FALSE it indicates that the SOLARIS
47423ccda647Slclee 	 * PARTITION has changed from the previous one, hence we will setup a
47433ccda647Slclee 	 * default VTOC in this case.
47443ccda647Slclee 	 */
4745e8fb11a1Sshidokht 	if (cl->cl_f_geometry_is_valid == FALSE) {
47463ccda647Slclee 		/* if we get here it is writable */
47473ccda647Slclee 		/* we are called from SMBOOT, and after a write of fdisk */
4748e8fb11a1Sshidokht 		cmlb_build_default_label(cl, tg_cookie);
47493ccda647Slclee 		label_rc = 0;
47503ccda647Slclee 	}
47513ccda647Slclee 
47523ccda647Slclee no_solaris_partition:
47533ccda647Slclee 
47543ccda647Slclee #if defined(_SUNOS_VTOC_16)
47553ccda647Slclee 	/*
47563ccda647Slclee 	 * If we have valid geometry, set up the remaining fdisk partitions.
47573ccda647Slclee 	 * Note that dkl_cylno is not used for the fdisk map entries, so
47583ccda647Slclee 	 * we set it to an entirely bogus value.
47593ccda647Slclee 	 */
4760f85c7842SSuhasini Peddada 	for (count = 0; count < FD_NUMPART; count++) {
4761342440ecSPrasad Singamsetty 		cl->cl_map[FDISK_P1 + count].dkl_cylno = UINT32_MAX;
4762e8fb11a1Sshidokht 		cl->cl_map[FDISK_P1 + count].dkl_nblk =
4763e8fb11a1Sshidokht 		    cl->cl_fmap[count].fmap_nblk;
4764e8fb11a1Sshidokht 		cl->cl_offset[FDISK_P1 + count] =
4765e8fb11a1Sshidokht 		    cl->cl_fmap[count].fmap_start;
47663ccda647Slclee 	}
47673ccda647Slclee #endif
47683ccda647Slclee 
47693ccda647Slclee 	for (count = 0; count < NDKMAP; count++) {
47703ccda647Slclee #if defined(_SUNOS_VTOC_8)
4771e8fb11a1Sshidokht 		struct dk_map *lp  = &cl->cl_map[count];
4772e8fb11a1Sshidokht 		cl->cl_offset[count] =
4773e8fb11a1Sshidokht 		    cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
47743ccda647Slclee #elif defined(_SUNOS_VTOC_16)
4775e8fb11a1Sshidokht 		struct dkl_partition *vp = &cl->cl_vtoc.v_part[count];
4776e8fb11a1Sshidokht 		cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset;
47773ccda647Slclee #else
47783ccda647Slclee #error "No VTOC format defined."
47793ccda647Slclee #endif
47803ccda647Slclee 	}
47813ccda647Slclee 
4782e8fb11a1Sshidokht 	ASSERT(mutex_owned(CMLB_MUTEX(cl)));
47833ccda647Slclee 	return (label_rc);
47843ccda647Slclee }
47853ccda647Slclee #endif
47863ccda647Slclee 
47873ccda647Slclee #if defined(__i386) || defined(__amd64)
47883ccda647Slclee static int
4789e8fb11a1Sshidokht cmlb_dkio_get_virtgeom(struct cmlb_lun *cl, caddr_t arg, int flag)
47903ccda647Slclee {
47913ccda647Slclee 	int err = 0;
47923ccda647Slclee 
47933ccda647Slclee 	/* Return the driver's notion of the media's logical geometry */
47943ccda647Slclee 	struct dk_geom	disk_geom;
47953ccda647Slclee 	struct dk_geom	*dkgp = &disk_geom;
47963ccda647Slclee 
4797e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
47983ccda647Slclee 	/*
47993ccda647Slclee 	 * If there is no HBA geometry available, or
48003ccda647Slclee 	 * if the HBA returned us something that doesn't
48013ccda647Slclee 	 * really fit into an Int 13/function 8 geometry
48023ccda647Slclee 	 * result, just fail the ioctl.  See PSARC 1998/313.
48033ccda647Slclee 	 */
4804e8fb11a1Sshidokht 	if (cl->cl_lgeom.g_nhead == 0 ||
4805e8fb11a1Sshidokht 	    cl->cl_lgeom.g_nsect == 0 ||
4806e8fb11a1Sshidokht 	    cl->cl_lgeom.g_ncyl > 1024) {
4807e8fb11a1Sshidokht 		mutex_exit(CMLB_MUTEX(cl));
48083ccda647Slclee 		err = EINVAL;
48093ccda647Slclee 	} else {
4810e8fb11a1Sshidokht 		dkgp->dkg_ncyl	= cl->cl_lgeom.g_ncyl;
4811e8fb11a1Sshidokht 		dkgp->dkg_acyl	= cl->cl_lgeom.g_acyl;
48123ccda647Slclee 		dkgp->dkg_pcyl	= dkgp->dkg_ncyl + dkgp->dkg_acyl;
4813e8fb11a1Sshidokht 		dkgp->dkg_nhead	= cl->cl_lgeom.g_nhead;
4814e8fb11a1Sshidokht 		dkgp->dkg_nsect	= cl->cl_lgeom.g_nsect;
48153ccda647Slclee 
48161c97599bSshidokht 		mutex_exit(CMLB_MUTEX(cl));
48173ccda647Slclee 		if (ddi_copyout(dkgp, (void *)arg,
48183ccda647Slclee 		    sizeof (struct dk_geom), flag)) {
48193ccda647Slclee 			err = EFAULT;
48203ccda647Slclee 		} else {
48213ccda647Slclee 			err = 0;
48223ccda647Slclee 		}
48233ccda647Slclee 	}
48243ccda647Slclee 	return (err);
48253ccda647Slclee }
48263ccda647Slclee #endif
48273ccda647Slclee 
48283ccda647Slclee #if defined(__i386) || defined(__amd64)
48293ccda647Slclee static int
4830e8fb11a1Sshidokht cmlb_dkio_get_phygeom(struct cmlb_lun *cl, caddr_t  arg, int flag)
48313ccda647Slclee {
48323ccda647Slclee 	int err = 0;
4833e8fb11a1Sshidokht 	diskaddr_t capacity;
48343ccda647Slclee 
48353ccda647Slclee 
48363ccda647Slclee 	/* Return the driver's notion of the media physical geometry */
48373ccda647Slclee 	struct dk_geom	disk_geom;
48383ccda647Slclee 	struct dk_geom	*dkgp = &disk_geom;
48393ccda647Slclee 
4840e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
48413ccda647Slclee 
4842e8fb11a1Sshidokht 	if (cl->cl_g.dkg_nhead != 0 &&
4843e8fb11a1Sshidokht 	    cl->cl_g.dkg_nsect != 0) {
48443ccda647Slclee 		/*
48453ccda647Slclee 		 * We succeeded in getting a geometry, but
48463ccda647Slclee 		 * right now it is being reported as just the
48473ccda647Slclee 		 * Solaris fdisk partition, just like for
48483ccda647Slclee 		 * DKIOCGGEOM. We need to change that to be
48493ccda647Slclee 		 * correct for the entire disk now.
48503ccda647Slclee 		 */
4851e8fb11a1Sshidokht 		bcopy(&cl->cl_g, dkgp, sizeof (*dkgp));
48523ccda647Slclee 		dkgp->dkg_acyl = 0;
4853e8fb11a1Sshidokht 		dkgp->dkg_ncyl = cl->cl_blockcount /
48543ccda647Slclee 		    (dkgp->dkg_nhead * dkgp->dkg_nsect);
48553ccda647Slclee 	} else {
48563ccda647Slclee 		bzero(dkgp, sizeof (struct dk_geom));
48573ccda647Slclee 		/*
48583ccda647Slclee 		 * This disk does not have a Solaris VTOC
48593ccda647Slclee 		 * so we must present a physical geometry
48603ccda647Slclee 		 * that will remain consistent regardless
48613ccda647Slclee 		 * of how the disk is used. This will ensure
48623ccda647Slclee 		 * that the geometry does not change regardless
48633ccda647Slclee 		 * of the fdisk partition type (ie. EFI, FAT32,
48643ccda647Slclee 		 * Solaris, etc).
48653ccda647Slclee 		 */
4866e8fb11a1Sshidokht 		if (ISCD(cl)) {
4867e8fb11a1Sshidokht 			dkgp->dkg_nhead = cl->cl_pgeom.g_nhead;
4868e8fb11a1Sshidokht 			dkgp->dkg_nsect = cl->cl_pgeom.g_nsect;
4869e8fb11a1Sshidokht 			dkgp->dkg_ncyl = cl->cl_pgeom.g_ncyl;
4870e8fb11a1Sshidokht 			dkgp->dkg_acyl = cl->cl_pgeom.g_acyl;
48713ccda647Slclee 		} else {
4872e8fb11a1Sshidokht 			/*
4873e8fb11a1Sshidokht 			 * Invalid cl_blockcount can generate invalid
4874e8fb11a1Sshidokht 			 * dk_geom and may result in division by zero
4875e8fb11a1Sshidokht 			 * system failure. Should make sure blockcount
4876e8fb11a1Sshidokht 			 * is valid before using it here.
4877e8fb11a1Sshidokht 			 */
4878e8fb11a1Sshidokht 			if (cl->cl_blockcount == 0) {
4879e8fb11a1Sshidokht 				mutex_exit(CMLB_MUTEX(cl));
4880e8fb11a1Sshidokht 				err = EIO;
4881e8fb11a1Sshidokht 				return (err);
4882e8fb11a1Sshidokht 			}
4883e8fb11a1Sshidokht 			/*
4884e8fb11a1Sshidokht 			 * Refer to comments related to off-by-1 at the
4885e8fb11a1Sshidokht 			 * header of this file
4886e8fb11a1Sshidokht 			 */
4887e8fb11a1Sshidokht 			if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE)
4888e8fb11a1Sshidokht 				capacity = cl->cl_blockcount - 1;
4889e8fb11a1Sshidokht 			else
4890e8fb11a1Sshidokht 				capacity = cl->cl_blockcount;
4891e8fb11a1Sshidokht 
4892e8fb11a1Sshidokht 			cmlb_convert_geometry(capacity, dkgp);
48933ccda647Slclee 			dkgp->dkg_acyl = 0;
4894e8fb11a1Sshidokht 			dkgp->dkg_ncyl = capacity /
48953ccda647Slclee 			    (dkgp->dkg_nhead * dkgp->dkg_nsect);
48963ccda647Slclee 		}
48973ccda647Slclee 	}
48983ccda647Slclee 	dkgp->dkg_pcyl = dkgp->dkg_ncyl + dkgp->dkg_acyl;
48993ccda647Slclee 
49001c97599bSshidokht 	mutex_exit(CMLB_MUTEX(cl));
49011c97599bSshidokht 	if (ddi_copyout(dkgp, (void *)arg, sizeof (struct dk_geom), flag))
49023ccda647Slclee 		err = EFAULT;
49031c97599bSshidokht 
49043ccda647Slclee 	return (err);
49053ccda647Slclee }
49063ccda647Slclee #endif
49073ccda647Slclee 
49083ccda647Slclee #if defined(__i386) || defined(__amd64)
49093ccda647Slclee static int
4910e8fb11a1Sshidokht cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t  arg, int flag)
49113ccda647Slclee {
49123ccda647Slclee 	int err = 0;
49133ccda647Slclee 
49143ccda647Slclee 	/*
49153ccda647Slclee 	 * Return parameters describing the selected disk slice.
49163ccda647Slclee 	 * Note: this ioctl is for the intel platform only
49173ccda647Slclee 	 */
49183ccda647Slclee 	int part;
49193ccda647Slclee 
49203ccda647Slclee 	part = CMLBPART(dev);
49213ccda647Slclee 
4922e8fb11a1Sshidokht 	mutex_enter(CMLB_MUTEX(cl));
4923e8fb11a1Sshidokht 	/* don't check cl_solaris_size for pN */
4924e8fb11a1Sshidokht 	if (part < P0_RAW_DISK && cl->cl_solaris_size == 0) {
49253ccda647Slclee 		err = EIO;
49261c97599bSshidokht 		mutex_exit(CMLB_MUTEX(cl));
49273ccda647Slclee 	} else {
49283ccda647Slclee 		struct part_info p;
49293ccda647Slclee 
4930e8fb11a1Sshidokht 		p.p_start = (daddr_t)cl->cl_offset[part];
4931e8fb11a1Sshidokht 		p.p_length = (int)cl->cl_map[part].dkl_nblk;
49321c97599bSshidokht 		mutex_exit(CMLB_MUTEX(cl));
49333ccda647Slclee #ifdef _MULTI_DATAMODEL
49343ccda647Slclee 		switch (ddi_model_convert_from(flag & FMODELS)) {
49353ccda647Slclee 		case DDI_MODEL_ILP32:
49363ccda647Slclee 		{
49373ccda647Slclee 			struct part_info32 p32;
49383ccda647Slclee 
49393ccda647Slclee 			p32.p_start = (daddr32_t)p.p_start;
49403ccda647Slclee 			p32.p_length = p.p_length;
49413ccda647Slclee 			if (ddi_copyout(&p32, (void *)arg,
49423ccda647Slclee 			    sizeof (p32), flag))
49433ccda647Slclee 				err = EFAULT;
49443ccda647Slclee 			break;
49453ccda647Slclee 		}
49463ccda647Slclee 
49473ccda647Slclee 		case DDI_MODEL_NONE:
49483ccda647Slclee 		{
49493ccda647Slclee 			if (ddi_copyout(&p, (void *)arg, sizeof (p),
49503ccda647Slclee 			    flag))
49513ccda647Slclee 				err = EFAULT;
49523ccda647Slclee 			break;
49533ccda647Slclee 		}
49543ccda647Slclee 		}
49553ccda647Slclee #else /* ! _MULTI_DATAMODEL */
49563ccda647Slclee 		if (ddi_copyout(&p, (void *)arg, sizeof (p), flag))
49573ccda647Slclee 			err = EFAULT;
49583ccda647Slclee #endif /* _MULTI_DATAMODEL */
49593ccda647Slclee 	}
49603ccda647Slclee 	return (err);
49613ccda647Slclee }
4962342440ecSPrasad Singamsetty static int
4963342440ecSPrasad Singamsetty cmlb_dkio_extpartinfo(struct cmlb_lun *cl, dev_t dev, caddr_t  arg, int flag)
4964342440ecSPrasad Singamsetty {
4965342440ecSPrasad Singamsetty 	int err = 0;
4966342440ecSPrasad Singamsetty 
4967342440ecSPrasad Singamsetty 	/*
4968342440ecSPrasad Singamsetty 	 * Return parameters describing the selected disk slice.
4969342440ecSPrasad Singamsetty 	 * Note: this ioctl is for the intel platform only
4970342440ecSPrasad Singamsetty 	 */
4971342440ecSPrasad Singamsetty 	int part;
4972342440ecSPrasad Singamsetty 
4973342440ecSPrasad Singamsetty 	part = CMLBPART(dev);
4974342440ecSPrasad Singamsetty 
4975342440ecSPrasad Singamsetty 	mutex_enter(CMLB_MUTEX(cl));
4976342440ecSPrasad Singamsetty 	/* don't check cl_solaris_size for pN */
4977342440ecSPrasad Singamsetty 	if (part < P0_RAW_DISK && cl->cl_solaris_size == 0) {
4978342440ecSPrasad Singamsetty 		err = EIO;
4979342440ecSPrasad Singamsetty 		mutex_exit(CMLB_MUTEX(cl));
4980342440ecSPrasad Singamsetty 	} else {
4981342440ecSPrasad Singamsetty 		struct extpart_info p;
4982342440ecSPrasad Singamsetty 
4983342440ecSPrasad Singamsetty 		p.p_start = (diskaddr_t)cl->cl_offset[part];
4984342440ecSPrasad Singamsetty 		p.p_length = (diskaddr_t)cl->cl_map[part].dkl_nblk;
4985342440ecSPrasad Singamsetty 		mutex_exit(CMLB_MUTEX(cl));
4986342440ecSPrasad Singamsetty 		if (ddi_copyout(&p, (void *)arg, sizeof (p), flag))
4987342440ecSPrasad Singamsetty 			err = EFAULT;
4988342440ecSPrasad Singamsetty 	}
4989342440ecSPrasad Singamsetty 	return (err);
4990342440ecSPrasad Singamsetty }
49913ccda647Slclee #endif
4992b9ccdc5aScth 
4993b9ccdc5aScth int
4994b9ccdc5aScth cmlb_prop_op(cmlb_handle_t cmlbhandle,
4995b9ccdc5aScth     dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
4996b9ccdc5aScth     char *name, caddr_t valuep, int *lengthp, int part, void *tg_cookie)
4997b9ccdc5aScth {
4998b9ccdc5aScth 	struct cmlb_lun	*cl;
4999b9ccdc5aScth 	diskaddr_t	capacity;
5000b9ccdc5aScth 	uint32_t	lbasize;
5001b9ccdc5aScth 	enum		dp { DP_NBLOCKS, DP_BLKSIZE } dp;
5002b9ccdc5aScth 	int		callers_length;
5003b9ccdc5aScth 	caddr_t		buffer;
5004b9ccdc5aScth 	uint64_t	nblocks64;
5005b9ccdc5aScth 	uint_t		dblk;
5006b9ccdc5aScth 
5007b9ccdc5aScth 	/* Always fallback to ddi_prop_op... */
5008b9ccdc5aScth 	cl = (struct cmlb_lun *)cmlbhandle;
5009b9ccdc5aScth 	if (cl == NULL) {
5010b9ccdc5aScth fallback:	return (ddi_prop_op(dev, dip, prop_op, mod_flags,
5011b9ccdc5aScth 		    name, valuep, lengthp));
5012b9ccdc5aScth 	}
5013b9ccdc5aScth 
5014b9ccdc5aScth 	/* Pick up capacity and blocksize information. */
5015b9ccdc5aScth 	capacity = cl->cl_blockcount;
5016b9ccdc5aScth 	if (capacity == 0)
5017b9ccdc5aScth 		goto fallback;
5018b9ccdc5aScth 	lbasize = cl->cl_tgt_blocksize;
5019b9ccdc5aScth 	if (lbasize == 0)
5020b9ccdc5aScth 		lbasize = DEV_BSIZE;	/* 0 -> DEV_BSIZE units */
5021b9ccdc5aScth 
5022b9ccdc5aScth 	/* Check for dynamic property of whole device. */
5023b9ccdc5aScth 	if (dev == DDI_DEV_T_ANY) {
5024b9ccdc5aScth 		/* Fallback to ddi_prop_op if we don't understand.  */
5025b9ccdc5aScth 		if (strcmp(name, "device-nblocks") == 0)
5026b9ccdc5aScth 			dp = DP_NBLOCKS;
5027b9ccdc5aScth 		else if (strcmp(name, "device-blksize") == 0)
5028b9ccdc5aScth 			dp = DP_BLKSIZE;
5029b9ccdc5aScth 		else
5030b9ccdc5aScth 			goto fallback;
5031b9ccdc5aScth 
5032b9ccdc5aScth 		/* get callers length, establish length of our dynamic prop */
5033b9ccdc5aScth 		callers_length = *lengthp;
5034b9ccdc5aScth 		if (dp == DP_NBLOCKS)
5035b9ccdc5aScth 			*lengthp = sizeof (uint64_t);
5036b9ccdc5aScth 		else if (dp == DP_BLKSIZE)
5037b9ccdc5aScth 			*lengthp = sizeof (uint32_t);
5038b9ccdc5aScth 
5039b9ccdc5aScth 		/* service request for the length of the property */
5040b9ccdc5aScth 		if (prop_op == PROP_LEN)
5041b9ccdc5aScth 			return (DDI_PROP_SUCCESS);
5042b9ccdc5aScth 
5043b9ccdc5aScth 		switch (prop_op) {
5044b9ccdc5aScth 		case PROP_LEN_AND_VAL_ALLOC:
5045b9ccdc5aScth 			if ((buffer = kmem_alloc(*lengthp,
5046b9ccdc5aScth 			    (mod_flags & DDI_PROP_CANSLEEP) ?
5047b9ccdc5aScth 			    KM_SLEEP : KM_NOSLEEP)) == NULL)
5048b9ccdc5aScth 				return (DDI_PROP_NO_MEMORY);
5049b9ccdc5aScth 			*(caddr_t *)valuep = buffer;	/* set callers buf */
5050b9ccdc5aScth 			break;
5051b9ccdc5aScth 
5052b9ccdc5aScth 		case PROP_LEN_AND_VAL_BUF:
5053b9ccdc5aScth 			/* the length of the prop and the request must match */
5054b9ccdc5aScth 			if (callers_length != *lengthp)
5055b9ccdc5aScth 				return (DDI_PROP_INVAL_ARG);
5056b9ccdc5aScth 			buffer = valuep;		/* get callers buf */
5057b9ccdc5aScth 			break;
5058b9ccdc5aScth 
5059b9ccdc5aScth 		default:
5060b9ccdc5aScth 			return (DDI_PROP_INVAL_ARG);
5061b9ccdc5aScth 		}
5062b9ccdc5aScth 
5063b9ccdc5aScth 		/* transfer the value into the buffer */
5064b9ccdc5aScth 		if (dp == DP_NBLOCKS)
5065b9ccdc5aScth 			*((uint64_t *)buffer) = capacity;
5066b9ccdc5aScth 		else if (dp == DP_BLKSIZE)
5067b9ccdc5aScth 			*((uint32_t *)buffer) = lbasize;
5068b9ccdc5aScth 
5069b9ccdc5aScth 		return (DDI_PROP_SUCCESS);
5070b9ccdc5aScth 	}
5071b9ccdc5aScth 
5072b9ccdc5aScth 	/*
5073b9ccdc5aScth 	 * Support dynamic size oriented properties of partition. Requests
5074b9ccdc5aScth 	 * issued under conditions where size is valid are passed to
5075b9ccdc5aScth 	 * ddi_prop_op_nblocks with the size information, otherwise the
5076b9ccdc5aScth 	 * request is passed to ddi_prop_op. Size depends on valid geometry.
5077b9ccdc5aScth 	 */
5078b9ccdc5aScth 	if (!cmlb_is_valid(cmlbhandle))
5079b9ccdc5aScth 		goto fallback;
5080b9ccdc5aScth 
5081b9ccdc5aScth 	/* Get partition nblocks value. */
5082b9ccdc5aScth 	(void) cmlb_partinfo(cmlbhandle, part,
5083b9ccdc5aScth 	    (diskaddr_t *)&nblocks64, NULL, NULL, NULL, tg_cookie);
5084b9ccdc5aScth 
5085b9ccdc5aScth 	/*
5086b9ccdc5aScth 	 * Assume partition information is in DEV_BSIZE units, compute
5087b9ccdc5aScth 	 * divisor for size(9P) property representation.
5088b9ccdc5aScth 	 */
5089b9ccdc5aScth 	dblk = lbasize / DEV_BSIZE;
5090b9ccdc5aScth 
5091b9ccdc5aScth 	/* Now let ddi_prop_op_nblocks_blksize() handle the request. */
5092b9ccdc5aScth 	return (ddi_prop_op_nblocks_blksize(dev, dip, prop_op, mod_flags,
5093b9ccdc5aScth 	    name, valuep, lengthp, nblocks64 / dblk, lbasize));
5094b9ccdc5aScth }
5095