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 /*
2359d8f100SGarrett D'Amore * Copyright 2012 DEY Storage Systems, Inc. All rights reserved.
247e74b1cbSSharath M Srinivasan * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
253ccda647Slclee * Use is subject to license terms.
26406fc510SToomas Soome * Copyright 2016 Toomas Soome <tsoome@me.com>
27fd797736SJohn Levon * Copyright (c) 2019, Joyent, Inc.
283ccda647Slclee */
293ccda647Slclee
303ccda647Slclee /*
313ccda647Slclee * This module provides support for labeling operations for target
323ccda647Slclee * drivers.
333ccda647Slclee */
343ccda647Slclee
353ccda647Slclee #include <sys/scsi/scsi.h>
363ccda647Slclee #include <sys/sunddi.h>
373ccda647Slclee #include <sys/dklabel.h>
383ccda647Slclee #include <sys/dkio.h>
393ccda647Slclee #include <sys/vtoc.h>
403ccda647Slclee #include <sys/dktp/fdisk.h>
413ccda647Slclee #include <sys/vtrace.h>
423ccda647Slclee #include <sys/efi_partition.h>
433ccda647Slclee #include <sys/cmlb.h>
443ccda647Slclee #include <sys/cmlb_impl.h>
4586ef0a63SRichard Lowe #if defined(__x86)
46aa1b14e7SSheshadri Vasudevan #include <sys/fs/dv_node.h>
47aa1b14e7SSheshadri Vasudevan #endif
48b9ccdc5aScth #include <sys/ddi_impldefs.h>
493ccda647Slclee
503ccda647Slclee /*
513ccda647Slclee * Driver minor node structure and data table
523ccda647Slclee */
533ccda647Slclee struct driver_minor_data {
543ccda647Slclee char *name;
553ccda647Slclee minor_t minor;
563ccda647Slclee int type;
573ccda647Slclee };
583ccda647Slclee
593ccda647Slclee static struct driver_minor_data dk_minor_data[] = {
603ccda647Slclee {"a", 0, S_IFBLK},
613ccda647Slclee {"b", 1, S_IFBLK},
623ccda647Slclee {"c", 2, S_IFBLK},
633ccda647Slclee {"d", 3, S_IFBLK},
643ccda647Slclee {"e", 4, S_IFBLK},
653ccda647Slclee {"f", 5, S_IFBLK},
663ccda647Slclee {"g", 6, S_IFBLK},
673ccda647Slclee {"h", 7, S_IFBLK},
683ccda647Slclee #if defined(_SUNOS_VTOC_16)
693ccda647Slclee {"i", 8, S_IFBLK},
703ccda647Slclee {"j", 9, S_IFBLK},
713ccda647Slclee {"k", 10, S_IFBLK},
723ccda647Slclee {"l", 11, S_IFBLK},
733ccda647Slclee {"m", 12, S_IFBLK},
743ccda647Slclee {"n", 13, S_IFBLK},
753ccda647Slclee {"o", 14, S_IFBLK},
763ccda647Slclee {"p", 15, S_IFBLK},
773ccda647Slclee #endif /* defined(_SUNOS_VTOC_16) */
783ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
793ccda647Slclee {"q", 16, S_IFBLK},
803ccda647Slclee {"r", 17, S_IFBLK},
813ccda647Slclee {"s", 18, S_IFBLK},
823ccda647Slclee {"t", 19, S_IFBLK},
833ccda647Slclee {"u", 20, S_IFBLK},
843ccda647Slclee #endif /* defined(_FIRMWARE_NEEDS_FDISK) */
853ccda647Slclee {"a,raw", 0, S_IFCHR},
863ccda647Slclee {"b,raw", 1, S_IFCHR},
873ccda647Slclee {"c,raw", 2, S_IFCHR},
883ccda647Slclee {"d,raw", 3, S_IFCHR},
893ccda647Slclee {"e,raw", 4, S_IFCHR},
903ccda647Slclee {"f,raw", 5, S_IFCHR},
913ccda647Slclee {"g,raw", 6, S_IFCHR},
923ccda647Slclee {"h,raw", 7, S_IFCHR},
933ccda647Slclee #if defined(_SUNOS_VTOC_16)
943ccda647Slclee {"i,raw", 8, S_IFCHR},
953ccda647Slclee {"j,raw", 9, S_IFCHR},
963ccda647Slclee {"k,raw", 10, S_IFCHR},
973ccda647Slclee {"l,raw", 11, S_IFCHR},
983ccda647Slclee {"m,raw", 12, S_IFCHR},
993ccda647Slclee {"n,raw", 13, S_IFCHR},
1003ccda647Slclee {"o,raw", 14, S_IFCHR},
1013ccda647Slclee {"p,raw", 15, S_IFCHR},
1023ccda647Slclee #endif /* defined(_SUNOS_VTOC_16) */
1033ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
1043ccda647Slclee {"q,raw", 16, S_IFCHR},
1053ccda647Slclee {"r,raw", 17, S_IFCHR},
1063ccda647Slclee {"s,raw", 18, S_IFCHR},
1073ccda647Slclee {"t,raw", 19, S_IFCHR},
1083ccda647Slclee {"u,raw", 20, S_IFCHR},
1093ccda647Slclee #endif /* defined(_FIRMWARE_NEEDS_FDISK) */
1103ccda647Slclee {0}
1113ccda647Slclee };
1123ccda647Slclee
11386ef0a63SRichard Lowe #if defined(__x86)
114aa1b14e7SSheshadri Vasudevan #if defined(_FIRMWARE_NEEDS_FDISK)
115aa1b14e7SSheshadri Vasudevan static struct driver_minor_data dk_ext_minor_data[] = {
116aa1b14e7SSheshadri Vasudevan {"p5", 21, S_IFBLK},
117aa1b14e7SSheshadri Vasudevan {"p6", 22, S_IFBLK},
118aa1b14e7SSheshadri Vasudevan {"p7", 23, S_IFBLK},
119aa1b14e7SSheshadri Vasudevan {"p8", 24, S_IFBLK},
120aa1b14e7SSheshadri Vasudevan {"p9", 25, S_IFBLK},
121aa1b14e7SSheshadri Vasudevan {"p10", 26, S_IFBLK},
122aa1b14e7SSheshadri Vasudevan {"p11", 27, S_IFBLK},
123aa1b14e7SSheshadri Vasudevan {"p12", 28, S_IFBLK},
124aa1b14e7SSheshadri Vasudevan {"p13", 29, S_IFBLK},
125aa1b14e7SSheshadri Vasudevan {"p14", 30, S_IFBLK},
126aa1b14e7SSheshadri Vasudevan {"p15", 31, S_IFBLK},
127aa1b14e7SSheshadri Vasudevan {"p16", 32, S_IFBLK},
128aa1b14e7SSheshadri Vasudevan {"p17", 33, S_IFBLK},
129aa1b14e7SSheshadri Vasudevan {"p18", 34, S_IFBLK},
130aa1b14e7SSheshadri Vasudevan {"p19", 35, S_IFBLK},
131aa1b14e7SSheshadri Vasudevan {"p20", 36, S_IFBLK},
132aa1b14e7SSheshadri Vasudevan {"p21", 37, S_IFBLK},
133aa1b14e7SSheshadri Vasudevan {"p22", 38, S_IFBLK},
134aa1b14e7SSheshadri Vasudevan {"p23", 39, S_IFBLK},
135aa1b14e7SSheshadri Vasudevan {"p24", 40, S_IFBLK},
136aa1b14e7SSheshadri Vasudevan {"p25", 41, S_IFBLK},
137aa1b14e7SSheshadri Vasudevan {"p26", 42, S_IFBLK},
138aa1b14e7SSheshadri Vasudevan {"p27", 43, S_IFBLK},
139aa1b14e7SSheshadri Vasudevan {"p28", 44, S_IFBLK},
140aa1b14e7SSheshadri Vasudevan {"p29", 45, S_IFBLK},
141aa1b14e7SSheshadri Vasudevan {"p30", 46, S_IFBLK},
142aa1b14e7SSheshadri Vasudevan {"p31", 47, S_IFBLK},
143aa1b14e7SSheshadri Vasudevan {"p32", 48, S_IFBLK},
144aa1b14e7SSheshadri Vasudevan {"p33", 49, S_IFBLK},
145aa1b14e7SSheshadri Vasudevan {"p34", 50, S_IFBLK},
146aa1b14e7SSheshadri Vasudevan {"p35", 51, S_IFBLK},
147aa1b14e7SSheshadri Vasudevan {"p36", 52, S_IFBLK},
148aa1b14e7SSheshadri Vasudevan {"p5,raw", 21, S_IFCHR},
149aa1b14e7SSheshadri Vasudevan {"p6,raw", 22, S_IFCHR},
150aa1b14e7SSheshadri Vasudevan {"p7,raw", 23, S_IFCHR},
151aa1b14e7SSheshadri Vasudevan {"p8,raw", 24, S_IFCHR},
152aa1b14e7SSheshadri Vasudevan {"p9,raw", 25, S_IFCHR},
153aa1b14e7SSheshadri Vasudevan {"p10,raw", 26, S_IFCHR},
154aa1b14e7SSheshadri Vasudevan {"p11,raw", 27, S_IFCHR},
155aa1b14e7SSheshadri Vasudevan {"p12,raw", 28, S_IFCHR},
156aa1b14e7SSheshadri Vasudevan {"p13,raw", 29, S_IFCHR},
157aa1b14e7SSheshadri Vasudevan {"p14,raw", 30, S_IFCHR},
158aa1b14e7SSheshadri Vasudevan {"p15,raw", 31, S_IFCHR},
159aa1b14e7SSheshadri Vasudevan {"p16,raw", 32, S_IFCHR},
160aa1b14e7SSheshadri Vasudevan {"p17,raw", 33, S_IFCHR},
161aa1b14e7SSheshadri Vasudevan {"p18,raw", 34, S_IFCHR},
162aa1b14e7SSheshadri Vasudevan {"p19,raw", 35, S_IFCHR},
163aa1b14e7SSheshadri Vasudevan {"p20,raw", 36, S_IFCHR},
164aa1b14e7SSheshadri Vasudevan {"p21,raw", 37, S_IFCHR},
165aa1b14e7SSheshadri Vasudevan {"p22,raw", 38, S_IFCHR},
166aa1b14e7SSheshadri Vasudevan {"p23,raw", 39, S_IFCHR},
167aa1b14e7SSheshadri Vasudevan {"p24,raw", 40, S_IFCHR},
168aa1b14e7SSheshadri Vasudevan {"p25,raw", 41, S_IFCHR},
169aa1b14e7SSheshadri Vasudevan {"p26,raw", 42, S_IFCHR},
170aa1b14e7SSheshadri Vasudevan {"p27,raw", 43, S_IFCHR},
171aa1b14e7SSheshadri Vasudevan {"p28,raw", 44, S_IFCHR},
172aa1b14e7SSheshadri Vasudevan {"p29,raw", 45, S_IFCHR},
173aa1b14e7SSheshadri Vasudevan {"p30,raw", 46, S_IFCHR},
174aa1b14e7SSheshadri Vasudevan {"p31,raw", 47, S_IFCHR},
175aa1b14e7SSheshadri Vasudevan {"p32,raw", 48, S_IFCHR},
176aa1b14e7SSheshadri Vasudevan {"p33,raw", 49, S_IFCHR},
177aa1b14e7SSheshadri Vasudevan {"p34,raw", 50, S_IFCHR},
178aa1b14e7SSheshadri Vasudevan {"p35,raw", 51, S_IFCHR},
179aa1b14e7SSheshadri Vasudevan {"p36,raw", 52, S_IFCHR},
180aa1b14e7SSheshadri Vasudevan {0}
181aa1b14e7SSheshadri Vasudevan };
182aa1b14e7SSheshadri Vasudevan #endif /* defined(_FIRMWARE_NEEDS_FDISK) */
18386ef0a63SRichard Lowe #endif /* if defined(__x86) */
184aa1b14e7SSheshadri Vasudevan
1853ccda647Slclee static struct driver_minor_data dk_minor_data_efi[] = {
1863ccda647Slclee {"a", 0, S_IFBLK},
1873ccda647Slclee {"b", 1, S_IFBLK},
1883ccda647Slclee {"c", 2, S_IFBLK},
1893ccda647Slclee {"d", 3, S_IFBLK},
1903ccda647Slclee {"e", 4, S_IFBLK},
1913ccda647Slclee {"f", 5, S_IFBLK},
1923ccda647Slclee {"g", 6, S_IFBLK},
1933ccda647Slclee {"wd", 7, S_IFBLK},
1947e70b434SShidokht Yadegari #if defined(_SUNOS_VTOC_16)
1957e70b434SShidokht Yadegari {"i", 8, S_IFBLK},
1967e70b434SShidokht Yadegari {"j", 9, S_IFBLK},
1977e70b434SShidokht Yadegari {"k", 10, S_IFBLK},
1987e70b434SShidokht Yadegari {"l", 11, S_IFBLK},
1997e70b434SShidokht Yadegari {"m", 12, S_IFBLK},
2007e70b434SShidokht Yadegari {"n", 13, S_IFBLK},
2017e70b434SShidokht Yadegari {"o", 14, S_IFBLK},
2027e70b434SShidokht Yadegari {"p", 15, S_IFBLK},
2037e70b434SShidokht Yadegari #endif /* defined(_SUNOS_VTOC_16) */
2043ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
2053ccda647Slclee {"q", 16, S_IFBLK},
2063ccda647Slclee {"r", 17, S_IFBLK},
2073ccda647Slclee {"s", 18, S_IFBLK},
2083ccda647Slclee {"t", 19, S_IFBLK},
2093ccda647Slclee {"u", 20, S_IFBLK},
2103ccda647Slclee #endif /* defined(_FIRMWARE_NEEDS_FDISK) */
2113ccda647Slclee {"a,raw", 0, S_IFCHR},
2123ccda647Slclee {"b,raw", 1, S_IFCHR},
2133ccda647Slclee {"c,raw", 2, S_IFCHR},
2143ccda647Slclee {"d,raw", 3, S_IFCHR},
2153ccda647Slclee {"e,raw", 4, S_IFCHR},
2163ccda647Slclee {"f,raw", 5, S_IFCHR},
2173ccda647Slclee {"g,raw", 6, S_IFCHR},
2183ccda647Slclee {"wd,raw", 7, S_IFCHR},
2197e70b434SShidokht Yadegari #if defined(_SUNOS_VTOC_16)
2207e70b434SShidokht Yadegari {"i,raw", 8, S_IFCHR},
2217e70b434SShidokht Yadegari {"j,raw", 9, S_IFCHR},
2227e70b434SShidokht Yadegari {"k,raw", 10, S_IFCHR},
2237e70b434SShidokht Yadegari {"l,raw", 11, S_IFCHR},
2247e70b434SShidokht Yadegari {"m,raw", 12, S_IFCHR},
2257e70b434SShidokht Yadegari {"n,raw", 13, S_IFCHR},
2267e70b434SShidokht Yadegari {"o,raw", 14, S_IFCHR},
2277e70b434SShidokht Yadegari {"p,raw", 15, S_IFCHR},
2287e70b434SShidokht Yadegari #endif /* defined(_SUNOS_VTOC_16) */
2293ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
2303ccda647Slclee {"q,raw", 16, S_IFCHR},
2313ccda647Slclee {"r,raw", 17, S_IFCHR},
2323ccda647Slclee {"s,raw", 18, S_IFCHR},
2333ccda647Slclee {"t,raw", 19, S_IFCHR},
2343ccda647Slclee {"u,raw", 20, S_IFCHR},
2353ccda647Slclee #endif /* defined(_FIRMWARE_NEEDS_FDISK) */
2363ccda647Slclee {0}
2373ccda647Slclee };
2383ccda647Slclee
239b9ccdc5aScth /*
240b9ccdc5aScth * Declare the dynamic properties implemented in prop_op(9E) implementation
241b9ccdc5aScth * that we want to have show up in a di_init(3DEVINFO) device tree snapshot
242b9ccdc5aScth * of drivers that call cmlb_attach().
243b9ccdc5aScth */
244b9ccdc5aScth static i_ddi_prop_dyn_t cmlb_prop_dyn[] = {
245b9ccdc5aScth {"Nblocks", DDI_PROP_TYPE_INT64, S_IFBLK},
246b9ccdc5aScth {"Size", DDI_PROP_TYPE_INT64, S_IFCHR},
247b9ccdc5aScth {"device-nblocks", DDI_PROP_TYPE_INT64},
248b9ccdc5aScth {"device-blksize", DDI_PROP_TYPE_INT},
24959d8f100SGarrett D'Amore {"device-solid-state", DDI_PROP_TYPE_INT},
250acb450ddSYuri Pankov {"device-rotational", DDI_PROP_TYPE_INT},
251b9ccdc5aScth {NULL}
252b9ccdc5aScth };
2533ccda647Slclee
254c31fac72SShidokht Yadegari /*
255c31fac72SShidokht Yadegari * This implies an upper limit of 8192 GPT partitions
256c31fac72SShidokht Yadegari * in one transfer for GUID Partition Entry Array.
257c31fac72SShidokht Yadegari */
258c31fac72SShidokht Yadegari len_t cmlb_tg_max_efi_xfer = 1024 * 1024;
259c31fac72SShidokht Yadegari
26006bbe1e0Sedp /*
26106bbe1e0Sedp * External kernel interfaces
26206bbe1e0Sedp */
2633ccda647Slclee extern struct mod_ops mod_miscops;
2643ccda647Slclee
26506bbe1e0Sedp extern int ddi_create_internal_pathname(dev_info_t *dip, char *name,
26606bbe1e0Sedp int spec_type, minor_t minor_num);
26706bbe1e0Sedp
2683ccda647Slclee /*
2693ccda647Slclee * Global buffer and mutex for debug logging
2703ccda647Slclee */
2713ccda647Slclee static char cmlb_log_buffer[1024];
2723ccda647Slclee static kmutex_t cmlb_log_mutex;
2733ccda647Slclee
2743ccda647Slclee
275e8fb11a1Sshidokht struct cmlb_lun *cmlb_debug_cl = NULL;
2763ccda647Slclee uint_t cmlb_level_mask = 0x0;
2773ccda647Slclee
2783ccda647Slclee int cmlb_rot_delay = 4; /* default rotational delay */
2793ccda647Slclee
2803ccda647Slclee static struct modlmisc modlmisc = {
2813ccda647Slclee &mod_miscops, /* Type of module */
282342440ecSPrasad Singamsetty "Common Labeling module"
2833ccda647Slclee };
2843ccda647Slclee
2853ccda647Slclee static struct modlinkage modlinkage = {
2863ccda647Slclee MODREV_1, (void *)&modlmisc, NULL
2873ccda647Slclee };
2883ccda647Slclee
2893ccda647Slclee /* Local function prototypes */
290e8fb11a1Sshidokht static dev_t cmlb_make_device(struct cmlb_lun *cl);
2917f0b8309SEdward Pilatowicz static int cmlb_validate_geometry(struct cmlb_lun *cl, boolean_t forcerevalid,
292e8fb11a1Sshidokht int flags, void *tg_cookie);
293e8fb11a1Sshidokht static void cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity,
294e8fb11a1Sshidokht void *tg_cookie);
295e8fb11a1Sshidokht static int cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity,
296e8fb11a1Sshidokht void *tg_cookie);
2973ccda647Slclee static void cmlb_swap_efi_gpt(efi_gpt_t *e);
2983ccda647Slclee static void cmlb_swap_efi_gpe(int nparts, efi_gpe_t *p);
2993ccda647Slclee static int cmlb_validate_efi(efi_gpt_t *labp);
300e8fb11a1Sshidokht static int cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags,
301e8fb11a1Sshidokht void *tg_cookie);
302e8fb11a1Sshidokht static void cmlb_build_default_label(struct cmlb_lun *cl, void *tg_cookie);
303e8fb11a1Sshidokht static int cmlb_uselabel(struct cmlb_lun *cl, struct dk_label *l, int flags);
304e8fb11a1Sshidokht #if defined(_SUNOS_VTOC_8)
305e8fb11a1Sshidokht static void cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc);
306e8fb11a1Sshidokht #endif
307e8fb11a1Sshidokht static int cmlb_build_label_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc);
308e8fb11a1Sshidokht static int cmlb_write_label(struct cmlb_lun *cl, void *tg_cookie);
309e8fb11a1Sshidokht static int cmlb_set_vtoc(struct cmlb_lun *cl, struct dk_label *dkl,
310e8fb11a1Sshidokht void *tg_cookie);
311e8fb11a1Sshidokht static void cmlb_clear_efi(struct cmlb_lun *cl, void *tg_cookie);
312e8fb11a1Sshidokht static void cmlb_clear_vtoc(struct cmlb_lun *cl, void *tg_cookie);
313e8fb11a1Sshidokht static void cmlb_setup_default_geometry(struct cmlb_lun *cl, void *tg_cookie);
314e8fb11a1Sshidokht static int cmlb_create_minor_nodes(struct cmlb_lun *cl);
315e8fb11a1Sshidokht static int cmlb_check_update_blockcount(struct cmlb_lun *cl, void *tg_cookie);
3167f0b8309SEdward Pilatowicz static boolean_t cmlb_check_efi_mbr(uchar_t *buf, boolean_t *is_mbr);
3173ccda647Slclee
31886ef0a63SRichard Lowe #if defined(__x86)
319e8fb11a1Sshidokht static int cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie);
3203ccda647Slclee #endif
3213ccda647Slclee
3223ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
3237f0b8309SEdward Pilatowicz static boolean_t cmlb_has_max_chs_vals(struct ipart *fdp);
3243ccda647Slclee #endif
3253ccda647Slclee
3263ccda647Slclee #if defined(_SUNOS_VTOC_16)
327b081f1c4Syu, larry liu - Sun Microsystems - Beijing China static void cmlb_convert_geometry(struct cmlb_lun *cl, diskaddr_t capacity,
328b081f1c4Syu, larry liu - Sun Microsystems - Beijing China struct dk_geom *cl_g, void *tg_cookie);
3293ccda647Slclee #endif
3303ccda647Slclee
331e8fb11a1Sshidokht static int cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag,
332e8fb11a1Sshidokht void *tg_cookie);
333e8fb11a1Sshidokht static int cmlb_dkio_set_geometry(struct cmlb_lun *cl, caddr_t arg, int flag);
334e8fb11a1Sshidokht static int cmlb_dkio_get_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
335e8fb11a1Sshidokht void *tg_cookie);
336e8fb11a1Sshidokht static int cmlb_dkio_set_partition(struct cmlb_lun *cl, caddr_t arg, int flag);
337e8fb11a1Sshidokht static int cmlb_dkio_get_efi(struct cmlb_lun *cl, caddr_t arg, int flag,
338e8fb11a1Sshidokht void *tg_cookie);
339e8fb11a1Sshidokht static int cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
340e8fb11a1Sshidokht int flag, void *tg_cookie);
341e8fb11a1Sshidokht static int cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
342e8fb11a1Sshidokht void *tg_cookie);
343342440ecSPrasad Singamsetty static int cmlb_dkio_get_extvtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
344342440ecSPrasad Singamsetty void *tg_cookie);
345e8fb11a1Sshidokht static int cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
346e8fb11a1Sshidokht int flag, void *tg_cookie);
347342440ecSPrasad Singamsetty static int cmlb_dkio_set_extvtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
348342440ecSPrasad Singamsetty int flag, void *tg_cookie);
349e8fb11a1Sshidokht static int cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag,
350e8fb11a1Sshidokht void *tg_cookie);
351e8fb11a1Sshidokht static int cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag,
352e8fb11a1Sshidokht void *tg_cookie);
353e8fb11a1Sshidokht static int cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
354e8fb11a1Sshidokht void *tg_cookie);
3553ccda647Slclee
35686ef0a63SRichard Lowe #if defined(__x86)
357aa1b14e7SSheshadri Vasudevan static int cmlb_dkio_set_ext_part(struct cmlb_lun *cl, caddr_t arg, int flag,
358aa1b14e7SSheshadri Vasudevan void *tg_cookie);
359aa1b14e7SSheshadri Vasudevan static int cmlb_validate_ext_part(struct cmlb_lun *cl, int part, int epart,
360aa1b14e7SSheshadri Vasudevan uint32_t start, uint32_t size);
361aa1b14e7SSheshadri Vasudevan static int cmlb_is_linux_swap(struct cmlb_lun *cl, uint32_t part_start,
362aa1b14e7SSheshadri Vasudevan void *tg_cookie);
363e8fb11a1Sshidokht static int cmlb_dkio_get_virtgeom(struct cmlb_lun *cl, caddr_t arg, int flag);
364b081f1c4Syu, larry liu - Sun Microsystems - Beijing China static int cmlb_dkio_get_phygeom(struct cmlb_lun *cl, caddr_t arg, int flag,
365b081f1c4Syu, larry liu - Sun Microsystems - Beijing China void *tg_cookie);
366e8fb11a1Sshidokht static int cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
3673ccda647Slclee int flag);
368342440ecSPrasad Singamsetty static int cmlb_dkio_extpartinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
369342440ecSPrasad Singamsetty int flag);
3703ccda647Slclee #endif
3713ccda647Slclee
372e8fb11a1Sshidokht static void cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...);
373c31fac72SShidokht Yadegari static void cmlb_v_log(dev_info_t *dev, const char *label, uint_t level,
3743ccda647Slclee const char *fmt, va_list ap);
375c31fac72SShidokht Yadegari static void cmlb_log(dev_info_t *dev, const char *label, uint_t level,
3763ccda647Slclee const char *fmt, ...);
3773ccda647Slclee
3783ccda647Slclee int
_init(void)3793ccda647Slclee _init(void)
3803ccda647Slclee {
3813ccda647Slclee mutex_init(&cmlb_log_mutex, NULL, MUTEX_DRIVER, NULL);
3823ccda647Slclee return (mod_install(&modlinkage));
3833ccda647Slclee }
3843ccda647Slclee
3853ccda647Slclee int
_info(struct modinfo * modinfop)3863ccda647Slclee _info(struct modinfo *modinfop)
3873ccda647Slclee {
3883ccda647Slclee return (mod_info(&modlinkage, modinfop));
3893ccda647Slclee }
3903ccda647Slclee
3913ccda647Slclee int
_fini(void)3923ccda647Slclee _fini(void)
3933ccda647Slclee {
3943ccda647Slclee int err;
3953ccda647Slclee
3963ccda647Slclee if ((err = mod_remove(&modlinkage)) != 0) {
3973ccda647Slclee return (err);
3983ccda647Slclee }
3993ccda647Slclee
4003ccda647Slclee mutex_destroy(&cmlb_log_mutex);
4013ccda647Slclee return (err);
4023ccda647Slclee }
4033ccda647Slclee
4043ccda647Slclee /*
4053ccda647Slclee * cmlb_dbg is used for debugging to log additional info
4063ccda647Slclee * Level of output is controlled via cmlb_level_mask setting.
4073ccda647Slclee */
4083ccda647Slclee static void
cmlb_dbg(uint_t comp,struct cmlb_lun * cl,const char * fmt,...)409e8fb11a1Sshidokht cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...)
4103ccda647Slclee {
4113ccda647Slclee va_list ap;
4123ccda647Slclee dev_info_t *dev;
4133ccda647Slclee uint_t level_mask = 0;
4143ccda647Slclee
415e8fb11a1Sshidokht ASSERT(cl != NULL);
416e8fb11a1Sshidokht dev = CMLB_DEVINFO(cl);
4173ccda647Slclee ASSERT(dev != NULL);
4183ccda647Slclee /*
4193ccda647Slclee * Filter messages based on the global component and level masks,
420e8fb11a1Sshidokht * also print if cl matches the value of cmlb_debug_cl, or if
421e8fb11a1Sshidokht * cmlb_debug_cl is set to NULL.
4223ccda647Slclee */
4233ccda647Slclee if (comp & CMLB_TRACE)
4243ccda647Slclee level_mask |= CMLB_LOGMASK_TRACE;
4253ccda647Slclee
4263ccda647Slclee if (comp & CMLB_INFO)
4273ccda647Slclee level_mask |= CMLB_LOGMASK_INFO;
4283ccda647Slclee
4293ccda647Slclee if (comp & CMLB_ERROR)
4303ccda647Slclee level_mask |= CMLB_LOGMASK_ERROR;
4313ccda647Slclee
4323ccda647Slclee if ((cmlb_level_mask & level_mask) &&
433e8fb11a1Sshidokht ((cmlb_debug_cl == NULL) || (cmlb_debug_cl == cl))) {
4343ccda647Slclee va_start(ap, fmt);
435e8fb11a1Sshidokht cmlb_v_log(dev, CMLB_LABEL(cl), CE_CONT, fmt, ap);
4363ccda647Slclee va_end(ap);
4373ccda647Slclee }
4383ccda647Slclee }
4393ccda647Slclee
4403ccda647Slclee /*
4413ccda647Slclee * cmlb_log is basically a duplicate of scsi_log. It is redefined here
4423ccda647Slclee * so that this module does not depend on scsi module.
4433ccda647Slclee */
4443ccda647Slclee static void
cmlb_log(dev_info_t * dev,const char * label,uint_t level,const char * fmt,...)445c31fac72SShidokht Yadegari cmlb_log(dev_info_t *dev, const char *label, uint_t level, const char *fmt, ...)
4463ccda647Slclee {
4473ccda647Slclee va_list ap;
4483ccda647Slclee
4493ccda647Slclee va_start(ap, fmt);
4503ccda647Slclee cmlb_v_log(dev, label, level, fmt, ap);
4513ccda647Slclee va_end(ap);
4523ccda647Slclee }
4533ccda647Slclee
4543ccda647Slclee static void
cmlb_v_log(dev_info_t * dev,const char * label,uint_t level,const char * fmt,va_list ap)455c31fac72SShidokht Yadegari cmlb_v_log(dev_info_t *dev, const char *label, uint_t level, const char *fmt,
4563ccda647Slclee va_list ap)
4573ccda647Slclee {
458531d0b66SToomas Soome static char name[256];
459531d0b66SToomas Soome int log_only = 0;
460531d0b66SToomas Soome int boot_only = 0;
461531d0b66SToomas Soome int console_only = 0;
4623ccda647Slclee
4633ccda647Slclee mutex_enter(&cmlb_log_mutex);
4643ccda647Slclee
4653ccda647Slclee if (dev) {
4663ccda647Slclee if (level == CE_PANIC || level == CE_WARN ||
4673ccda647Slclee level == CE_NOTE) {
4683ccda647Slclee (void) sprintf(name, "%s (%s%d):\n",
4693ccda647Slclee ddi_pathname(dev, cmlb_log_buffer),
4703ccda647Slclee label, ddi_get_instance(dev));
4713ccda647Slclee } else {
4723ccda647Slclee name[0] = '\0';
4733ccda647Slclee }
4743ccda647Slclee } else {
4753ccda647Slclee (void) sprintf(name, "%s:", label);
4763ccda647Slclee }
4773ccda647Slclee
4783ccda647Slclee (void) vsprintf(cmlb_log_buffer, fmt, ap);
4793ccda647Slclee
4803ccda647Slclee switch (cmlb_log_buffer[0]) {
4813ccda647Slclee case '!':
4823ccda647Slclee log_only = 1;
4833ccda647Slclee break;
4843ccda647Slclee case '?':
4853ccda647Slclee boot_only = 1;
4863ccda647Slclee break;
4873ccda647Slclee case '^':
4883ccda647Slclee console_only = 1;
4893ccda647Slclee break;
4903ccda647Slclee }
4913ccda647Slclee
4923ccda647Slclee switch (level) {
4933ccda647Slclee case CE_NOTE:
4943ccda647Slclee level = CE_CONT;
4953ccda647Slclee /* FALLTHROUGH */
4963ccda647Slclee case CE_CONT:
4973ccda647Slclee case CE_WARN:
4983ccda647Slclee case CE_PANIC:
4993ccda647Slclee if (boot_only) {
5003ccda647Slclee cmn_err(level, "?%s\t%s", name, &cmlb_log_buffer[1]);
5013ccda647Slclee } else if (console_only) {
5023ccda647Slclee cmn_err(level, "^%s\t%s", name, &cmlb_log_buffer[1]);
5033ccda647Slclee } else if (log_only) {
5043ccda647Slclee cmn_err(level, "!%s\t%s", name, &cmlb_log_buffer[1]);
5053ccda647Slclee } else {
5063ccda647Slclee cmn_err(level, "%s\t%s", name, cmlb_log_buffer);
5073ccda647Slclee }
5083ccda647Slclee break;
5093ccda647Slclee case CE_IGNORE:
5103ccda647Slclee break;
5113ccda647Slclee default:
5123ccda647Slclee cmn_err(CE_CONT, "^DEBUG: %s\t%s", name, cmlb_log_buffer);
5133ccda647Slclee break;
5143ccda647Slclee }
5153ccda647Slclee mutex_exit(&cmlb_log_mutex);
5163ccda647Slclee }
5173ccda647Slclee
5183ccda647Slclee
5193ccda647Slclee /*
5203ccda647Slclee * cmlb_alloc_handle:
5213ccda647Slclee *
5223ccda647Slclee * Allocates a handle.
5233ccda647Slclee *
5243ccda647Slclee * Arguments:
5253ccda647Slclee * cmlbhandlep pointer to handle
5263ccda647Slclee *
5273ccda647Slclee * Notes:
5283ccda647Slclee * Allocates a handle and stores the allocated handle in the area
5293ccda647Slclee * pointed to by cmlbhandlep
5303ccda647Slclee *
5313ccda647Slclee * Context:
5323ccda647Slclee * Kernel thread only (can sleep).
5333ccda647Slclee */
5343ccda647Slclee void
cmlb_alloc_handle(cmlb_handle_t * cmlbhandlep)5353ccda647Slclee cmlb_alloc_handle(cmlb_handle_t *cmlbhandlep)
5363ccda647Slclee {
537531d0b66SToomas Soome struct cmlb_lun *cl;
5383ccda647Slclee
539e8fb11a1Sshidokht cl = kmem_zalloc(sizeof (struct cmlb_lun), KM_SLEEP);
5403ccda647Slclee ASSERT(cmlbhandlep != NULL);
5413ccda647Slclee
542e8fb11a1Sshidokht cl->cl_state = CMLB_INITED;
543e8fb11a1Sshidokht cl->cl_def_labeltype = CMLB_LABEL_UNDEF;
544e8fb11a1Sshidokht mutex_init(CMLB_MUTEX(cl), NULL, MUTEX_DRIVER, NULL);
5453ccda647Slclee
546e8fb11a1Sshidokht *cmlbhandlep = (cmlb_handle_t)(cl);
5473ccda647Slclee }
5483ccda647Slclee
5493ccda647Slclee /*
5503ccda647Slclee * cmlb_free_handle
5513ccda647Slclee *
5523ccda647Slclee * Frees handle.
5533ccda647Slclee *
5543ccda647Slclee * Arguments:
5553ccda647Slclee * cmlbhandlep pointer to handle
5563ccda647Slclee */
5573ccda647Slclee void
cmlb_free_handle(cmlb_handle_t * cmlbhandlep)5583ccda647Slclee cmlb_free_handle(cmlb_handle_t *cmlbhandlep)
5593ccda647Slclee {
560531d0b66SToomas Soome struct cmlb_lun *cl;
5613ccda647Slclee
562e8fb11a1Sshidokht cl = (struct cmlb_lun *)*cmlbhandlep;
563e8fb11a1Sshidokht if (cl != NULL) {
564e8fb11a1Sshidokht mutex_destroy(CMLB_MUTEX(cl));
565e8fb11a1Sshidokht kmem_free(cl, sizeof (struct cmlb_lun));
5663ccda647Slclee }
5673ccda647Slclee
5683ccda647Slclee }
5693ccda647Slclee
5703ccda647Slclee /*
5713ccda647Slclee * cmlb_attach:
5723ccda647Slclee *
5733ccda647Slclee * Attach handle to device, create minor nodes for device.
5743ccda647Slclee *
5753ccda647Slclee * Arguments:
576531d0b66SToomas Soome * devi pointer to device's dev_info structure.
577531d0b66SToomas Soome * tgopsp pointer to array of functions cmlb can use to callback
5783ccda647Slclee * to target driver.
5793ccda647Slclee *
5803ccda647Slclee * device_type Peripheral device type as defined in
5813ccda647Slclee * scsi/generic/inquiry.h
5823ccda647Slclee *
5833ccda647Slclee * is_removable whether or not device is removable.
5843ccda647Slclee *
585e8fb11a1Sshidokht * is_hotpluggable whether or not device is hotpluggable.
586e8fb11a1Sshidokht *
5873ccda647Slclee * node_type minor node type (as used by ddi_create_minor_node)
5883ccda647Slclee *
5893ccda647Slclee * alter_behavior
5903ccda647Slclee * bit flags:
5913ccda647Slclee *
5923ccda647Slclee * CMLB_CREATE_ALTSLICE_VTOC_16_DTYPE_DIRECT: create
5933ccda647Slclee * an alternate slice for the default label, if
5943ccda647Slclee * device type is DTYPE_DIRECT an architectures default
5953ccda647Slclee * label type is VTOC16.
5963ccda647Slclee * Otherwise alternate slice will no be created.
5973ccda647Slclee *
5983ccda647Slclee *
5993ccda647Slclee * CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8: report a default
6003ccda647Slclee * geometry and label for DKIOCGGEOM and DKIOCGVTOC
6013ccda647Slclee * on architecture with VTOC8 label types.
6023ccda647Slclee *
603531d0b66SToomas Soome * CMLB_OFF_BY_ONE: do the workaround for legacy off-by-
604e8fb11a1Sshidokht * one bug in obtaining capacity (in sd):
605e8fb11a1Sshidokht * SCSI READ_CAPACITY command returns the LBA number of the
606e8fb11a1Sshidokht * last logical block, but sd once treated this number as
607e8fb11a1Sshidokht * disks' capacity on x86 platform. And LBAs are addressed
608e8fb11a1Sshidokht * based 0. So the last block was lost on x86 platform.
609e8fb11a1Sshidokht *
610e8fb11a1Sshidokht * Now, we remove this workaround. In order for present sd
611e8fb11a1Sshidokht * driver to work with disks which are labeled/partitioned
612e8fb11a1Sshidokht * via previous sd, we add workaround as follows:
613e8fb11a1Sshidokht *
614e8fb11a1Sshidokht * 1) Locate backup EFI label: cmlb searches the next to
615e8fb11a1Sshidokht * last
616e8fb11a1Sshidokht * block for backup EFI label. If fails, it will
617e8fb11a1Sshidokht * turn to the last block for backup EFI label;
618e8fb11a1Sshidokht *
619e8fb11a1Sshidokht * 2) Clear backup EFI label: cmlb first search the last
620e8fb11a1Sshidokht * block for backup EFI label, and will search the
621e8fb11a1Sshidokht * next to last block only if failed for the last
622e8fb11a1Sshidokht * block.
623e8fb11a1Sshidokht *
624e8fb11a1Sshidokht * 3) Calculate geometry:refer to cmlb_convert_geometry()
625e8fb11a1Sshidokht * If capacity increasing by 1 causes disks' capacity
626342440ecSPrasad Singamsetty * to cross over the limits in geometry calculation,
627e8fb11a1Sshidokht * geometry info will change. This will raise an issue:
628e8fb11a1Sshidokht * In case that primary VTOC label is destroyed, format
629e8fb11a1Sshidokht * commandline can restore it via backup VTOC labels.
630e8fb11a1Sshidokht * And format locates backup VTOC labels by use of
631e8fb11a1Sshidokht * geometry. So changing geometry will
632e8fb11a1Sshidokht * prevent format from finding backup VTOC labels. To
633e8fb11a1Sshidokht * eliminate this side effect for compatibility,
634e8fb11a1Sshidokht * sd uses (capacity -1) to calculate geometry;
635e8fb11a1Sshidokht *
636e8fb11a1Sshidokht * 4) 1TB disks: some important data structures use
637e8fb11a1Sshidokht * 32-bit signed long/int (for example, daddr_t),
638e8fb11a1Sshidokht * so that sd doesn't support a disk with capacity
639e8fb11a1Sshidokht * larger than 1TB on 32-bit platform. However,
640e8fb11a1Sshidokht * for exactly 1TB disk, it was treated as (1T - 512)B
641e8fb11a1Sshidokht * in the past, and could have valid Solaris
642e8fb11a1Sshidokht * partitions. To workaround this, if an exactly 1TB
643e8fb11a1Sshidokht * disk has Solaris fdisk partition, it will be allowed
644e8fb11a1Sshidokht * to work with sd.
645e8fb11a1Sshidokht *
646e8fb11a1Sshidokht *
6473ccda647Slclee *
648843e1988Sjohnlev * CMLB_FAKE_LABEL_ONE_PARTITION: create s0 and s2 covering
649843e1988Sjohnlev * the entire disk, if there is no valid partition info.
650843e1988Sjohnlev * If there is a valid Solaris partition, s0 and s2 will
651843e1988Sjohnlev * only cover the entire Solaris partition.
652843e1988Sjohnlev *
653406fc510SToomas Soome * CMLB_CREATE_P0_MINOR_NODE: create p0 node covering
654406fc510SToomas Soome * the entire disk. Used by lofi to ensure presence of
655406fc510SToomas Soome * whole disk device node in case of LOFI_MAP_FILE ioctl.
656843e1988Sjohnlev *
6573ccda647Slclee * cmlbhandle cmlb handle associated with device
6583ccda647Slclee *
659e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
660e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
661e8fb11a1Sshidokht *
6623ccda647Slclee * Notes:
6633ccda647Slclee * Assumes a default label based on capacity for non-removable devices.
6643ccda647Slclee * If capacity > 1TB, EFI is assumed otherwise VTOC (default VTOC
6653ccda647Slclee * for the architecture).
6663ccda647Slclee *
6673ccda647Slclee * For removable devices, default label type is assumed to be VTOC
6683ccda647Slclee * type. Create minor nodes based on a default label type.
6693ccda647Slclee * Label on the media is not validated.
6703ccda647Slclee * minor number consists of:
6713ccda647Slclee * if _SUNOS_VTOC_8 is defined
6723ccda647Slclee * lowest 3 bits is taken as partition number
6733ccda647Slclee * the rest is instance number
6743ccda647Slclee * if _SUNOS_VTOC_16 is defined
6753ccda647Slclee * lowest 6 bits is taken as partition number
6763ccda647Slclee * the rest is instance number
6773ccda647Slclee *
6783ccda647Slclee *
6793ccda647Slclee * Return values:
680531d0b66SToomas Soome * 0 Success
681531d0b66SToomas Soome * ENXIO creating minor nodes failed.
682e8fb11a1Sshidokht * EINVAL invalid arg, unsupported tg_ops version
6833ccda647Slclee */
6843ccda647Slclee int
cmlb_attach(dev_info_t * devi,cmlb_tg_ops_t * tgopsp,int device_type,boolean_t is_removable,boolean_t is_hotpluggable,char * node_type,int alter_behavior,cmlb_handle_t cmlbhandle,void * tg_cookie)6853ccda647Slclee cmlb_attach(dev_info_t *devi, cmlb_tg_ops_t *tgopsp, int device_type,
6867f0b8309SEdward Pilatowicz boolean_t is_removable, boolean_t is_hotpluggable, char *node_type,
687e8fb11a1Sshidokht int alter_behavior, cmlb_handle_t cmlbhandle, void *tg_cookie)
6883ccda647Slclee {
6893ccda647Slclee
690e8fb11a1Sshidokht struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
6913ccda647Slclee diskaddr_t cap;
6923ccda647Slclee int status;
6933ccda647Slclee
6947f0b8309SEdward Pilatowicz ASSERT(VALID_BOOLEAN(is_removable));
6957f0b8309SEdward Pilatowicz ASSERT(VALID_BOOLEAN(is_hotpluggable));
6967f0b8309SEdward Pilatowicz
697e8fb11a1Sshidokht if (tgopsp->tg_version < TG_DK_OPS_VERSION_1)
698e8fb11a1Sshidokht return (EINVAL);
6993ccda647Slclee
700e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
701e8fb11a1Sshidokht
702e8fb11a1Sshidokht CMLB_DEVINFO(cl) = devi;
703e8fb11a1Sshidokht cl->cmlb_tg_ops = tgopsp;
704e8fb11a1Sshidokht cl->cl_device_type = device_type;
705e8fb11a1Sshidokht cl->cl_is_removable = is_removable;
706e8fb11a1Sshidokht cl->cl_is_hotpluggable = is_hotpluggable;
707e8fb11a1Sshidokht cl->cl_node_type = node_type;
708e8fb11a1Sshidokht cl->cl_sys_blocksize = DEV_BSIZE;
7097f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_FALSE;
710e8fb11a1Sshidokht cl->cl_def_labeltype = CMLB_LABEL_VTOC;
711e8fb11a1Sshidokht cl->cl_alter_behavior = alter_behavior;
712e8fb11a1Sshidokht cl->cl_reserved = -1;
713342440ecSPrasad Singamsetty cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
71486ef0a63SRichard Lowe #if defined(__x86)
715aa1b14e7SSheshadri Vasudevan cl->cl_logical_drive_count = 0;
716aa1b14e7SSheshadri Vasudevan #endif
7173ccda647Slclee
7187f0b8309SEdward Pilatowicz if (!is_removable) {
719e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
720e8fb11a1Sshidokht status = DK_TG_GETCAP(cl, &cap, tg_cookie);
721e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
722342440ecSPrasad Singamsetty if (status == 0 && cap > CMLB_EXTVTOC_LIMIT) {
723342440ecSPrasad Singamsetty /* set default EFI if > 2TB */
724e8fb11a1Sshidokht cl->cl_def_labeltype = CMLB_LABEL_EFI;
7253ccda647Slclee }
7263ccda647Slclee }
7273ccda647Slclee
7283ccda647Slclee /* create minor nodes based on default label type */
729e8fb11a1Sshidokht cl->cl_last_labeltype = CMLB_LABEL_UNDEF;
730e8fb11a1Sshidokht cl->cl_cur_labeltype = CMLB_LABEL_UNDEF;
7313ccda647Slclee
732e8fb11a1Sshidokht if (cmlb_create_minor_nodes(cl) != 0) {
733e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
7343ccda647Slclee return (ENXIO);
7353ccda647Slclee }
7363ccda647Slclee
737b9ccdc5aScth /* Define the dynamic properties for devinfo spapshots. */
738b9ccdc5aScth i_ddi_prop_dyn_driver_set(CMLB_DEVINFO(cl), cmlb_prop_dyn);
739b9ccdc5aScth
740e8fb11a1Sshidokht cl->cl_state = CMLB_ATTACHED;
7413ccda647Slclee
742e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
7433ccda647Slclee return (0);
7443ccda647Slclee }
7453ccda647Slclee
7463ccda647Slclee /*
7473ccda647Slclee * cmlb_detach:
7483ccda647Slclee *
7493ccda647Slclee * Invalidate in-core labeling data and remove all minor nodes for
7503ccda647Slclee * the device associate with handle.
7513ccda647Slclee *
7523ccda647Slclee * Arguments:
7533ccda647Slclee * cmlbhandle cmlb handle associated with device.
7543ccda647Slclee *
755e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
756e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
757e8fb11a1Sshidokht *
7583ccda647Slclee */
759e8fb11a1Sshidokht /*ARGSUSED1*/
7603ccda647Slclee void
cmlb_detach(cmlb_handle_t cmlbhandle,void * tg_cookie)761e8fb11a1Sshidokht cmlb_detach(cmlb_handle_t cmlbhandle, void *tg_cookie)
7623ccda647Slclee {
763e8fb11a1Sshidokht struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
764e8fb11a1Sshidokht
765e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
766e8fb11a1Sshidokht cl->cl_def_labeltype = CMLB_LABEL_UNDEF;
7677f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_FALSE;
768e8fb11a1Sshidokht ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
769b9ccdc5aScth i_ddi_prop_dyn_driver_set(CMLB_DEVINFO(cl), NULL);
770e8fb11a1Sshidokht cl->cl_state = CMLB_INITED;
771e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
7723ccda647Slclee }
7733ccda647Slclee
7743ccda647Slclee /*
7753ccda647Slclee * cmlb_validate:
7763ccda647Slclee *
7773ccda647Slclee * Validates label.
7783ccda647Slclee *
7793ccda647Slclee * Arguments
7803ccda647Slclee * cmlbhandle cmlb handle associated with device.
7813ccda647Slclee *
782e8fb11a1Sshidokht * flags operation flags. used for verbosity control
783e8fb11a1Sshidokht *
784e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
785e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
786e8fb11a1Sshidokht *
787e8fb11a1Sshidokht *
7883ccda647Slclee * Notes:
7893ccda647Slclee * If new label type is different from the current, adjust minor nodes
7903ccda647Slclee * accordingly.
7913ccda647Slclee *
7923ccda647Slclee * Return values:
7933ccda647Slclee * 0 success
7943ccda647Slclee * Note: having fdisk but no solaris partition is assumed
7953ccda647Slclee * success.
7963ccda647Slclee *
7973ccda647Slclee * ENOMEM memory allocation failed
7983ccda647Slclee * EIO i/o errors during read or get capacity
799531d0b66SToomas Soome * EACCESS reservation conflicts
800531d0b66SToomas Soome * EINVAL label was corrupt, or no default label was assumed
8013ccda647Slclee * ENXIO invalid handle
8023ccda647Slclee */
8033ccda647Slclee int
cmlb_validate(cmlb_handle_t cmlbhandle,int flags,void * tg_cookie)804e8fb11a1Sshidokht cmlb_validate(cmlb_handle_t cmlbhandle, int flags, void *tg_cookie)
8053ccda647Slclee {
806e8fb11a1Sshidokht struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
807531d0b66SToomas Soome int rval;
808531d0b66SToomas Soome int ret = 0;
8093ccda647Slclee
8103ccda647Slclee /*
811e8fb11a1Sshidokht * Temp work-around checking cl for NULL since there is a bug
8123ccda647Slclee * in sd_detach calling this routine from taskq_dispatch
8133ccda647Slclee * inited function.
8143ccda647Slclee */
815e8fb11a1Sshidokht if (cl == NULL)
8163ccda647Slclee return (ENXIO);
8173ccda647Slclee
818e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
819e8fb11a1Sshidokht if (cl->cl_state < CMLB_ATTACHED) {
820e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
8213ccda647Slclee return (ENXIO);
8223ccda647Slclee }
8233ccda647Slclee
8247f0b8309SEdward Pilatowicz rval = cmlb_validate_geometry((struct cmlb_lun *)cmlbhandle, B_TRUE,
825e8fb11a1Sshidokht flags, tg_cookie);
8263ccda647Slclee
8273ccda647Slclee if (rval == ENOTSUP) {
8287f0b8309SEdward Pilatowicz if (cl->cl_f_geometry_is_valid) {
829e8fb11a1Sshidokht cl->cl_cur_labeltype = CMLB_LABEL_EFI;
8303ccda647Slclee ret = 0;
8313ccda647Slclee } else {
8323ccda647Slclee ret = EINVAL;
8333ccda647Slclee }
8343ccda647Slclee } else {
8353ccda647Slclee ret = rval;
8363ccda647Slclee if (ret == 0)
837e8fb11a1Sshidokht cl->cl_cur_labeltype = CMLB_LABEL_VTOC;
8383ccda647Slclee }
8393ccda647Slclee
8403ccda647Slclee if (ret == 0)
841e8fb11a1Sshidokht (void) cmlb_create_minor_nodes(cl);
8423ccda647Slclee
843e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
8443ccda647Slclee return (ret);
8453ccda647Slclee }
8463ccda647Slclee
8473ccda647Slclee /*
8483ccda647Slclee * cmlb_invalidate:
8493ccda647Slclee * Invalidate in core label data
8503ccda647Slclee *
8513ccda647Slclee * Arguments:
8523ccda647Slclee * cmlbhandle cmlb handle associated with device.
853e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
854e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
8553ccda647Slclee */
856e8fb11a1Sshidokht /*ARGSUSED1*/
8573ccda647Slclee void
cmlb_invalidate(cmlb_handle_t cmlbhandle,void * tg_cookie)858e8fb11a1Sshidokht cmlb_invalidate(cmlb_handle_t cmlbhandle, void *tg_cookie)
8593ccda647Slclee {
860e8fb11a1Sshidokht struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
8613ccda647Slclee
862e8fb11a1Sshidokht if (cl == NULL)
8633ccda647Slclee return;
8643ccda647Slclee
865e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
8667f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_FALSE;
867e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
868e8fb11a1Sshidokht }
869e8fb11a1Sshidokht
870e8fb11a1Sshidokht /*
871e8fb11a1Sshidokht * cmlb_is_valid
872531d0b66SToomas Soome * Get status on whether the incore label/geom data is valid
873e8fb11a1Sshidokht *
874e8fb11a1Sshidokht * Arguments:
875e8fb11a1Sshidokht * cmlbhandle cmlb handle associated with device.
876e8fb11a1Sshidokht *
877e8fb11a1Sshidokht * Return values:
8787f0b8309SEdward Pilatowicz * B_TRUE if incore label/geom data is valid.
8797f0b8309SEdward Pilatowicz * B_FALSE otherwise.
880e8fb11a1Sshidokht *
881e8fb11a1Sshidokht */
882e8fb11a1Sshidokht
883e8fb11a1Sshidokht
8847f0b8309SEdward Pilatowicz boolean_t
cmlb_is_valid(cmlb_handle_t cmlbhandle)885e8fb11a1Sshidokht cmlb_is_valid(cmlb_handle_t cmlbhandle)
886e8fb11a1Sshidokht {
887e8fb11a1Sshidokht struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
888e8fb11a1Sshidokht
889e8fb11a1Sshidokht if (cmlbhandle == NULL)
8907f0b8309SEdward Pilatowicz return (B_FALSE);
891e8fb11a1Sshidokht
892e8fb11a1Sshidokht return (cl->cl_f_geometry_is_valid);
893e8fb11a1Sshidokht
8943ccda647Slclee }
8953ccda647Slclee
896e8fb11a1Sshidokht
897e8fb11a1Sshidokht
8983ccda647Slclee /*
8993ccda647Slclee * cmlb_close:
9003ccda647Slclee *
9013ccda647Slclee * Close the device, revert to a default label minor node for the device,
9023ccda647Slclee * if it is removable.
9033ccda647Slclee *
9043ccda647Slclee * Arguments:
9053ccda647Slclee * cmlbhandle cmlb handle associated with device.
9063ccda647Slclee *
907e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
908e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
9093ccda647Slclee * Return values:
9103ccda647Slclee * 0 Success
911531d0b66SToomas Soome * ENXIO Re-creating minor node failed.
9123ccda647Slclee */
913e8fb11a1Sshidokht /*ARGSUSED1*/
9143ccda647Slclee int
cmlb_close(cmlb_handle_t cmlbhandle,void * tg_cookie)915e8fb11a1Sshidokht cmlb_close(cmlb_handle_t cmlbhandle, void *tg_cookie)
9163ccda647Slclee {
917e8fb11a1Sshidokht struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
9183ccda647Slclee
919e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
9207f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_FALSE;
9213ccda647Slclee
9223ccda647Slclee /* revert to default minor node for this device */
923e8fb11a1Sshidokht if (ISREMOVABLE(cl)) {
924e8fb11a1Sshidokht cl->cl_cur_labeltype = CMLB_LABEL_UNDEF;
925e8fb11a1Sshidokht (void) cmlb_create_minor_nodes(cl);
9263ccda647Slclee }
9273ccda647Slclee
928e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
9293ccda647Slclee return (0);
9303ccda647Slclee }
9313ccda647Slclee
9323ccda647Slclee /*
9333ccda647Slclee * cmlb_get_devid_block:
9343ccda647Slclee * get the block number where device id is stored.
9353ccda647Slclee *
9363ccda647Slclee * Arguments:
9373ccda647Slclee * cmlbhandle cmlb handle associated with device.
9383ccda647Slclee * devidblockp pointer to block number.
939e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
940e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
9413ccda647Slclee *
9423ccda647Slclee * Notes:
9433ccda647Slclee * It stores the block number of device id in the area pointed to
9443ccda647Slclee * by devidblockp.
945531d0b66SToomas Soome * with the block number of device id.
9463ccda647Slclee *
9473ccda647Slclee * Return values:
9483ccda647Slclee * 0 success
949531d0b66SToomas Soome * EINVAL device id does not apply to current label type.
9503ccda647Slclee */
951e8fb11a1Sshidokht /*ARGSUSED2*/
9523ccda647Slclee int
cmlb_get_devid_block(cmlb_handle_t cmlbhandle,diskaddr_t * devidblockp,void * tg_cookie)953e8fb11a1Sshidokht cmlb_get_devid_block(cmlb_handle_t cmlbhandle, diskaddr_t *devidblockp,
954e8fb11a1Sshidokht void *tg_cookie)
9553ccda647Slclee {
9563ccda647Slclee daddr_t spc, blk, head, cyl;
957e8fb11a1Sshidokht struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
9583ccda647Slclee
959e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
960e8fb11a1Sshidokht if (cl->cl_state < CMLB_ATTACHED) {
961e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
9623ccda647Slclee return (EINVAL);
9633ccda647Slclee }
9643ccda647Slclee
9657f0b8309SEdward Pilatowicz if ((!cl->cl_f_geometry_is_valid) ||
966e8fb11a1Sshidokht (cl->cl_solaris_size < DK_LABEL_LOC)) {
967e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
968e8fb11a1Sshidokht return (EINVAL);
969e8fb11a1Sshidokht }
970e8fb11a1Sshidokht
971e8fb11a1Sshidokht if (cl->cl_cur_labeltype == CMLB_LABEL_EFI) {
972e8fb11a1Sshidokht if (cl->cl_reserved != -1) {
973e8fb11a1Sshidokht blk = cl->cl_map[cl->cl_reserved].dkl_cylno;
974e8fb11a1Sshidokht } else {
975e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
976e8fb11a1Sshidokht return (EINVAL);
977e8fb11a1Sshidokht }
978e8fb11a1Sshidokht } else {
9795d22422eSml /* if the disk is unlabeled, don't write a devid to it */
980342440ecSPrasad Singamsetty if (cl->cl_label_from_media != CMLB_LABEL_VTOC) {
9815d22422eSml mutex_exit(CMLB_MUTEX(cl));
9825d22422eSml return (EINVAL);
9835d22422eSml }
9845d22422eSml
9853ccda647Slclee /* this geometry doesn't allow us to write a devid */
986e8fb11a1Sshidokht if (cl->cl_g.dkg_acyl < 2) {
987e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
9883ccda647Slclee return (EINVAL);
9893ccda647Slclee }
9903ccda647Slclee
9913ccda647Slclee /*
9923ccda647Slclee * Subtract 2 guarantees that the next to last cylinder
9933ccda647Slclee * is used
9943ccda647Slclee */
995e8fb11a1Sshidokht cyl = cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl - 2;
996e8fb11a1Sshidokht spc = cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
997e8fb11a1Sshidokht head = cl->cl_g.dkg_nhead - 1;
9985d22422eSml blk = cl->cl_solaris_offset +
9995d22422eSml (cyl * (spc - cl->cl_g.dkg_apc)) +
1000e8fb11a1Sshidokht (head * cl->cl_g.dkg_nsect) + 1;
10013ccda647Slclee }
1002e8fb11a1Sshidokht
10033ccda647Slclee *devidblockp = blk;
1004e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
10053ccda647Slclee return (0);
10063ccda647Slclee }
10073ccda647Slclee
10083ccda647Slclee /*
10093ccda647Slclee * cmlb_partinfo:
10103ccda647Slclee * Get partition info for specified partition number.
10113ccda647Slclee *
10123ccda647Slclee * Arguments:
10133ccda647Slclee * cmlbhandle cmlb handle associated with device.
10143ccda647Slclee * part partition number
10153ccda647Slclee * nblocksp pointer to number of blocks
10163ccda647Slclee * startblockp pointer to starting block
10173ccda647Slclee * partnamep pointer to name of partition
10183ccda647Slclee * tagp pointer to tag info
1019e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
1020e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
10213ccda647Slclee *
10223ccda647Slclee *
10233ccda647Slclee * Notes:
10243ccda647Slclee * If in-core label is not valid, this functions tries to revalidate
10253ccda647Slclee * the label. If label is valid, it stores the total number of blocks
10263ccda647Slclee * in this partition in the area pointed to by nblocksp, starting
10273ccda647Slclee * block number in area pointed to by startblockp, pointer to partition
10283ccda647Slclee * name in area pointed to by partnamep, and tag value in area
10293ccda647Slclee * pointed by tagp.
10303ccda647Slclee * For EFI labels, tag value will be set to 0.
10313ccda647Slclee *
10323ccda647Slclee * For all nblocksp, startblockp and partnamep, tagp, a value of NULL
10333ccda647Slclee * indicates the corresponding info is not requested.
10343ccda647Slclee *
10353ccda647Slclee *
10363ccda647Slclee * Return values:
10373ccda647Slclee * 0 success
10383ccda647Slclee * EINVAL no valid label or requested partition number is invalid.
10393ccda647Slclee *
10403ccda647Slclee */
10413ccda647Slclee int
cmlb_partinfo(cmlb_handle_t cmlbhandle,int part,diskaddr_t * nblocksp,diskaddr_t * startblockp,char ** partnamep,uint16_t * tagp,void * tg_cookie)10423ccda647Slclee cmlb_partinfo(cmlb_handle_t cmlbhandle, int part, diskaddr_t *nblocksp,
1043e8fb11a1Sshidokht diskaddr_t *startblockp, char **partnamep, uint16_t *tagp, void *tg_cookie)
10443ccda647Slclee {
10453ccda647Slclee
1046e8fb11a1Sshidokht struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
10473ccda647Slclee int rval;
104886ef0a63SRichard Lowe #if defined(__x86)
1049aa1b14e7SSheshadri Vasudevan int ext_part;
1050aa1b14e7SSheshadri Vasudevan #endif
10513ccda647Slclee
1052e8fb11a1Sshidokht ASSERT(cl != NULL);
1053e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
1054e8fb11a1Sshidokht if (cl->cl_state < CMLB_ATTACHED) {
1055e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
10563ccda647Slclee return (EINVAL);
10573ccda647Slclee }
10583ccda647Slclee
10593ccda647Slclee if (part < 0 || part >= MAXPART) {
10603ccda647Slclee rval = EINVAL;
10613ccda647Slclee } else {
10627f0b8309SEdward Pilatowicz if (!cl->cl_f_geometry_is_valid)
10637f0b8309SEdward Pilatowicz (void) cmlb_validate_geometry((struct cmlb_lun *)cl,
10647f0b8309SEdward Pilatowicz B_FALSE, 0, tg_cookie);
1065e8fb11a1Sshidokht
10667f0b8309SEdward Pilatowicz if (((!cl->cl_f_geometry_is_valid) ||
1067342440ecSPrasad Singamsetty (part < NDKMAP && cl->cl_solaris_size == 0)) &&
1068342440ecSPrasad Singamsetty (part != P0_RAW_DISK)) {
10693ccda647Slclee rval = EINVAL;
10703ccda647Slclee } else {
10713ccda647Slclee if (startblockp != NULL)
1072e8fb11a1Sshidokht *startblockp = (diskaddr_t)cl->cl_offset[part];
10733ccda647Slclee
10743ccda647Slclee if (nblocksp != NULL)
10753ccda647Slclee *nblocksp = (diskaddr_t)
1076e8fb11a1Sshidokht cl->cl_map[part].dkl_nblk;
10773ccda647Slclee
10783ccda647Slclee if (tagp != NULL)
1079c31fac72SShidokht Yadegari *tagp =
1080c31fac72SShidokht Yadegari ((cl->cl_cur_labeltype == CMLB_LABEL_EFI) ||
1081c31fac72SShidokht Yadegari (part >= NDKMAP)) ? V_UNASSIGNED :
1082c31fac72SShidokht Yadegari cl->cl_vtoc.v_part[part].p_tag;
10833ccda647Slclee rval = 0;
10843ccda647Slclee }
10853ccda647Slclee
10863ccda647Slclee /* consistent with behavior of sd for getting minor name */
1087aa1b14e7SSheshadri Vasudevan if (partnamep != NULL) {
108886ef0a63SRichard Lowe #if defined(__x86)
1089aa1b14e7SSheshadri Vasudevan #if defined(_FIRMWARE_NEEDS_FDISK)
1090aa1b14e7SSheshadri Vasudevan if (part > FDISK_P4) {
1091aa1b14e7SSheshadri Vasudevan ext_part = part-FDISK_P4-1;
1092aa1b14e7SSheshadri Vasudevan *partnamep = dk_ext_minor_data[ext_part].name;
1093aa1b14e7SSheshadri Vasudevan } else
1094aa1b14e7SSheshadri Vasudevan #endif
1095aa1b14e7SSheshadri Vasudevan #endif
10963ccda647Slclee *partnamep = dk_minor_data[part].name;
1097aa1b14e7SSheshadri Vasudevan }
10983ccda647Slclee
10993ccda647Slclee }
11003ccda647Slclee
1101e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
11023ccda647Slclee return (rval);
11033ccda647Slclee }
11043ccda647Slclee
1105af007057Syl /*
1106af007057Syl * cmlb_efi_label_capacity:
1107af007057Syl * Get capacity stored in EFI disk label.
1108af007057Syl *
1109af007057Syl * Arguments:
1110af007057Syl * cmlbhandle cmlb handle associated with device.
1111af007057Syl * capacity pointer to capacity stored in EFI disk label.
1112af007057Syl * tg_cookie cookie from target driver to be passed back to target
1113af007057Syl * driver when we call back to it through tg_ops.
1114af007057Syl *
1115af007057Syl *
1116af007057Syl * Notes:
1117af007057Syl * If in-core label is not valid, this functions tries to revalidate
1118af007057Syl * the label. If label is valid and is an EFI label, it stores the capacity
1119af007057Syl * in disk label in the area pointed to by capacity.
1120af007057Syl *
1121af007057Syl *
1122af007057Syl * Return values:
1123af007057Syl * 0 success
1124af007057Syl * EINVAL no valid EFI label or capacity is NULL.
1125af007057Syl *
1126af007057Syl */
1127af007057Syl int
cmlb_efi_label_capacity(cmlb_handle_t cmlbhandle,diskaddr_t * capacity,void * tg_cookie)1128af007057Syl cmlb_efi_label_capacity(cmlb_handle_t cmlbhandle, diskaddr_t *capacity,
1129af007057Syl void *tg_cookie)
1130af007057Syl {
1131af007057Syl struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
1132af007057Syl int rval;
1133af007057Syl
1134af007057Syl ASSERT(cl != NULL);
1135af007057Syl mutex_enter(CMLB_MUTEX(cl));
1136af007057Syl if (cl->cl_state < CMLB_ATTACHED) {
1137af007057Syl mutex_exit(CMLB_MUTEX(cl));
1138af007057Syl return (EINVAL);
1139af007057Syl }
1140af007057Syl
11417f0b8309SEdward Pilatowicz if (!cl->cl_f_geometry_is_valid)
11427f0b8309SEdward Pilatowicz (void) cmlb_validate_geometry((struct cmlb_lun *)cl, B_FALSE,
1143af007057Syl 0, tg_cookie);
1144af007057Syl
11457f0b8309SEdward Pilatowicz if ((!cl->cl_f_geometry_is_valid) || (capacity == NULL) ||
1146af007057Syl (cl->cl_cur_labeltype != CMLB_LABEL_EFI)) {
1147af007057Syl rval = EINVAL;
1148af007057Syl } else {
1149af007057Syl *capacity = (diskaddr_t)cl->cl_map[WD_NODE].dkl_nblk;
1150af007057Syl rval = 0;
1151af007057Syl }
1152af007057Syl
1153af007057Syl mutex_exit(CMLB_MUTEX(cl));
1154af007057Syl return (rval);
1155af007057Syl }
1156af007057Syl
1157e8fb11a1Sshidokht /* Caller should make sure Test Unit Ready succeeds before calling this. */
1158e8fb11a1Sshidokht /*ARGSUSED*/
11593ccda647Slclee int
cmlb_ioctl(cmlb_handle_t cmlbhandle,dev_t dev,int cmd,intptr_t arg,int flag,cred_t * cred_p,int * rval_p,void * tg_cookie)11603ccda647Slclee cmlb_ioctl(cmlb_handle_t cmlbhandle, dev_t dev, int cmd, intptr_t arg,
1161e8fb11a1Sshidokht int flag, cred_t *cred_p, int *rval_p, void *tg_cookie)
11623ccda647Slclee {
11633ccda647Slclee
11643ccda647Slclee int err;
1165e8fb11a1Sshidokht struct cmlb_lun *cl;
11663ccda647Slclee
1167e8fb11a1Sshidokht cl = (struct cmlb_lun *)cmlbhandle;
11683ccda647Slclee
1169e8fb11a1Sshidokht ASSERT(cl != NULL);
11703ccda647Slclee
1171e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
1172e8fb11a1Sshidokht if (cl->cl_state < CMLB_ATTACHED) {
1173e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
11743ccda647Slclee return (EIO);
11753ccda647Slclee }
11763ccda647Slclee
11773ccda647Slclee switch (cmd) {
1178342440ecSPrasad Singamsetty case DKIOCSEXTVTOC:
1179e8fb11a1Sshidokht case DKIOCSGEOM:
11803ccda647Slclee case DKIOCSETEFI:
11813ccda647Slclee case DKIOCSMBOOT:
118286ef0a63SRichard Lowe #if defined(__x86)
1183aa1b14e7SSheshadri Vasudevan case DKIOCSETEXTPART:
1184aa1b14e7SSheshadri Vasudevan #endif
11853ccda647Slclee break;
1186342440ecSPrasad Singamsetty case DKIOCSVTOC:
118786ef0a63SRichard Lowe #if defined(__x86)
1188342440ecSPrasad Singamsetty case DKIOCPARTINFO:
1189342440ecSPrasad Singamsetty #endif
1190342440ecSPrasad Singamsetty if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
1191342440ecSPrasad Singamsetty mutex_exit(CMLB_MUTEX(cl));
1192342440ecSPrasad Singamsetty return (EOVERFLOW);
1193342440ecSPrasad Singamsetty }
1194342440ecSPrasad Singamsetty break;
11953ccda647Slclee default:
1196342440ecSPrasad Singamsetty (void) cmlb_validate_geometry(cl, 1, CMLB_SILENT,
1197adc076afSshidokht tg_cookie);
1198e8fb11a1Sshidokht
1199342440ecSPrasad Singamsetty switch (cmd) {
1200342440ecSPrasad Singamsetty case DKIOCGVTOC:
1201342440ecSPrasad Singamsetty case DKIOCGAPART:
1202342440ecSPrasad Singamsetty case DKIOCSAPART:
1203e8fb11a1Sshidokht
1204342440ecSPrasad Singamsetty if (cl->cl_label_from_media == CMLB_LABEL_EFI) {
1205342440ecSPrasad Singamsetty /* GPT label on disk */
1206e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
12073ccda647Slclee return (ENOTSUP);
1208342440ecSPrasad Singamsetty } else if
1209342440ecSPrasad Singamsetty (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
1210342440ecSPrasad Singamsetty mutex_exit(CMLB_MUTEX(cl));
1211342440ecSPrasad Singamsetty return (EOVERFLOW);
12123ccda647Slclee }
1213342440ecSPrasad Singamsetty break;
1214342440ecSPrasad Singamsetty
1215342440ecSPrasad Singamsetty case DKIOCGGEOM:
1216342440ecSPrasad Singamsetty if (cl->cl_label_from_media == CMLB_LABEL_EFI) {
1217342440ecSPrasad Singamsetty /* GPT label on disk */
1218342440ecSPrasad Singamsetty mutex_exit(CMLB_MUTEX(cl));
1219342440ecSPrasad Singamsetty return (ENOTSUP);
1220e8fb11a1Sshidokht }
1221342440ecSPrasad Singamsetty break;
1222342440ecSPrasad Singamsetty default:
1223342440ecSPrasad Singamsetty break;
12243ccda647Slclee }
12253ccda647Slclee }
12263ccda647Slclee
1227e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
12283ccda647Slclee
12293ccda647Slclee switch (cmd) {
12303ccda647Slclee case DKIOCGGEOM:
1231e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl, "DKIOCGGEOM\n");
1232e8fb11a1Sshidokht err = cmlb_dkio_get_geometry(cl, (caddr_t)arg, flag, tg_cookie);
12333ccda647Slclee break;
12343ccda647Slclee
12353ccda647Slclee case DKIOCSGEOM:
1236e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl, "DKIOCSGEOM\n");
1237e8fb11a1Sshidokht err = cmlb_dkio_set_geometry(cl, (caddr_t)arg, flag);
12383ccda647Slclee break;
12393ccda647Slclee
12403ccda647Slclee case DKIOCGAPART:
1241e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl, "DKIOCGAPART\n");
1242e8fb11a1Sshidokht err = cmlb_dkio_get_partition(cl, (caddr_t)arg,
1243e8fb11a1Sshidokht flag, tg_cookie);
12443ccda647Slclee break;
12453ccda647Slclee
12463ccda647Slclee case DKIOCSAPART:
1247e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl, "DKIOCSAPART\n");
1248e8fb11a1Sshidokht err = cmlb_dkio_set_partition(cl, (caddr_t)arg, flag);
12493ccda647Slclee break;
12503ccda647Slclee
12513ccda647Slclee case DKIOCGVTOC:
1252e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl, "DKIOCGVTOC\n");
1253e8fb11a1Sshidokht err = cmlb_dkio_get_vtoc(cl, (caddr_t)arg, flag, tg_cookie);
12543ccda647Slclee break;
12553ccda647Slclee
1256342440ecSPrasad Singamsetty case DKIOCGEXTVTOC:
1257342440ecSPrasad Singamsetty cmlb_dbg(CMLB_TRACE, cl, "DKIOCGVTOC\n");
1258342440ecSPrasad Singamsetty err = cmlb_dkio_get_extvtoc(cl, (caddr_t)arg, flag, tg_cookie);
1259342440ecSPrasad Singamsetty break;
1260342440ecSPrasad Singamsetty
12613ccda647Slclee case DKIOCGETEFI:
1262e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl, "DKIOCGETEFI\n");
1263e8fb11a1Sshidokht err = cmlb_dkio_get_efi(cl, (caddr_t)arg, flag, tg_cookie);
12643ccda647Slclee break;
12653ccda647Slclee
12663ccda647Slclee case DKIOCPARTITION:
1267e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTITION\n");
1268e8fb11a1Sshidokht err = cmlb_dkio_partition(cl, (caddr_t)arg, flag, tg_cookie);
12693ccda647Slclee break;
12703ccda647Slclee
12713ccda647Slclee case DKIOCSVTOC:
1272e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl, "DKIOCSVTOC\n");
1273e8fb11a1Sshidokht err = cmlb_dkio_set_vtoc(cl, dev, (caddr_t)arg, flag,
1274e8fb11a1Sshidokht tg_cookie);
12753ccda647Slclee break;
12763ccda647Slclee
1277342440ecSPrasad Singamsetty case DKIOCSEXTVTOC:
1278342440ecSPrasad Singamsetty cmlb_dbg(CMLB_TRACE, cl, "DKIOCSVTOC\n");
1279342440ecSPrasad Singamsetty err = cmlb_dkio_set_extvtoc(cl, dev, (caddr_t)arg, flag,
1280342440ecSPrasad Singamsetty tg_cookie);
1281342440ecSPrasad Singamsetty break;
1282342440ecSPrasad Singamsetty
12833ccda647Slclee case DKIOCSETEFI:
1284e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl, "DKIOCSETEFI\n");
1285e8fb11a1Sshidokht err = cmlb_dkio_set_efi(cl, dev, (caddr_t)arg, flag, tg_cookie);
12863ccda647Slclee break;
12873ccda647Slclee
12883ccda647Slclee case DKIOCGMBOOT:
1289e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl, "DKIOCGMBOOT\n");
1290e8fb11a1Sshidokht err = cmlb_dkio_get_mboot(cl, (caddr_t)arg, flag, tg_cookie);
12913ccda647Slclee break;
12923ccda647Slclee
12933ccda647Slclee case DKIOCSMBOOT:
1294e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl, "DKIOCSMBOOT\n");
1295e8fb11a1Sshidokht err = cmlb_dkio_set_mboot(cl, (caddr_t)arg, flag, tg_cookie);
12963ccda647Slclee break;
12973ccda647Slclee case DKIOCG_PHYGEOM:
1298e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_PHYGEOM\n");
129986ef0a63SRichard Lowe #if defined(__x86)
1300b081f1c4Syu, larry liu - Sun Microsystems - Beijing China err = cmlb_dkio_get_phygeom(cl, (caddr_t)arg, flag, tg_cookie);
13013ccda647Slclee #else
13023ccda647Slclee err = ENOTTY;
13033ccda647Slclee #endif
13043ccda647Slclee break;
13053ccda647Slclee case DKIOCG_VIRTGEOM:
1306e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_VIRTGEOM\n");
130786ef0a63SRichard Lowe #if defined(__x86)
1308e8fb11a1Sshidokht err = cmlb_dkio_get_virtgeom(cl, (caddr_t)arg, flag);
13093ccda647Slclee #else
13103ccda647Slclee err = ENOTTY;
13113ccda647Slclee #endif
13123ccda647Slclee break;
13133ccda647Slclee case DKIOCPARTINFO:
1314e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTINFO");
131586ef0a63SRichard Lowe #if defined(__x86)
1316e8fb11a1Sshidokht err = cmlb_dkio_partinfo(cl, dev, (caddr_t)arg, flag);
13173ccda647Slclee #else
13183ccda647Slclee err = ENOTTY;
1319342440ecSPrasad Singamsetty #endif
1320342440ecSPrasad Singamsetty break;
1321342440ecSPrasad Singamsetty case DKIOCEXTPARTINFO:
1322342440ecSPrasad Singamsetty cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTINFO");
132386ef0a63SRichard Lowe #if defined(__x86)
1324342440ecSPrasad Singamsetty err = cmlb_dkio_extpartinfo(cl, dev, (caddr_t)arg, flag);
1325342440ecSPrasad Singamsetty #else
1326342440ecSPrasad Singamsetty err = ENOTTY;
13273ccda647Slclee #endif
13283ccda647Slclee break;
132986ef0a63SRichard Lowe #if defined(__x86)
1330aa1b14e7SSheshadri Vasudevan case DKIOCSETEXTPART:
1331aa1b14e7SSheshadri Vasudevan cmlb_dbg(CMLB_TRACE, cl, "DKIOCSETEXTPART");
1332aa1b14e7SSheshadri Vasudevan err = cmlb_dkio_set_ext_part(cl, (caddr_t)arg, flag, tg_cookie);
1333aa1b14e7SSheshadri Vasudevan break;
1334aa1b14e7SSheshadri Vasudevan #endif
13353ccda647Slclee default:
13363ccda647Slclee err = ENOTTY;
13373ccda647Slclee
13383ccda647Slclee }
1339b9ccdc5aScth
1340b9ccdc5aScth /*
1341b9ccdc5aScth * An ioctl that succeeds and changed ('set') size(9P) information
1342b9ccdc5aScth * needs to invalidate the cached devinfo snapshot to avoid having
1343b9ccdc5aScth * old information being returned in a snapshots.
1344b9ccdc5aScth *
1345b9ccdc5aScth * NB: When available, call ddi_change_minor_node() to clear
1346b9ccdc5aScth * SSIZEVALID in specfs vnodes via spec_size_invalidate().
1347b9ccdc5aScth */
1348b9ccdc5aScth if (err == 0) {
1349b9ccdc5aScth switch (cmd) {
1350b9ccdc5aScth case DKIOCSGEOM:
1351b9ccdc5aScth case DKIOCSAPART:
1352b9ccdc5aScth case DKIOCSVTOC:
1353342440ecSPrasad Singamsetty case DKIOCSEXTVTOC:
1354b9ccdc5aScth case DKIOCSETEFI:
1355b9ccdc5aScth i_ddi_prop_dyn_cache_invalidate(CMLB_DEVINFO(cl),
1356b9ccdc5aScth i_ddi_prop_dyn_driver_get(CMLB_DEVINFO(cl)));
1357b9ccdc5aScth }
1358b9ccdc5aScth }
13593ccda647Slclee return (err);
13603ccda647Slclee }
13613ccda647Slclee
13623ccda647Slclee dev_t
cmlb_make_device(struct cmlb_lun * cl)1363e8fb11a1Sshidokht cmlb_make_device(struct cmlb_lun *cl)
13643ccda647Slclee {
1365406fc510SToomas Soome if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) {
1366406fc510SToomas Soome return (makedevice(ddi_driver_major(CMLB_DEVINFO(cl)),
1367406fc510SToomas Soome ddi_get_instance(
1368406fc510SToomas Soome CMLB_DEVINFO(cl)) << CMLBUNIT_FORCE_P0_SHIFT));
1369406fc510SToomas Soome } else {
1370406fc510SToomas Soome return (makedevice(ddi_driver_major(CMLB_DEVINFO(cl)),
1371406fc510SToomas Soome ddi_get_instance(CMLB_DEVINFO(cl)) << CMLBUNIT_SHIFT));
1372406fc510SToomas Soome }
13733ccda647Slclee }
13743ccda647Slclee
13753ccda647Slclee /*
13763ccda647Slclee * Function: cmlb_check_update_blockcount
13773ccda647Slclee *
13783ccda647Slclee * Description: If current capacity value is invalid, obtains the
13793ccda647Slclee * current capacity from target driver.
13803ccda647Slclee *
13813ccda647Slclee * Return Code: 0 success
13823ccda647Slclee * EIO failure
13833ccda647Slclee */
13843ccda647Slclee static int
cmlb_check_update_blockcount(struct cmlb_lun * cl,void * tg_cookie)1385e8fb11a1Sshidokht cmlb_check_update_blockcount(struct cmlb_lun *cl, void *tg_cookie)
13863ccda647Slclee {
13873ccda647Slclee int status;
13883ccda647Slclee diskaddr_t capacity;
1389e8fb11a1Sshidokht uint32_t lbasize;
13903ccda647Slclee
1391e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
13923ccda647Slclee
13937f0b8309SEdward Pilatowicz if (cl->cl_f_geometry_is_valid)
13947f0b8309SEdward Pilatowicz return (0);
1395e8fb11a1Sshidokht
13967f0b8309SEdward Pilatowicz mutex_exit(CMLB_MUTEX(cl));
13977f0b8309SEdward Pilatowicz status = DK_TG_GETCAP(cl, &capacity, tg_cookie);
13987f0b8309SEdward Pilatowicz if (status != 0) {
1399e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
14007f0b8309SEdward Pilatowicz return (EIO);
14017f0b8309SEdward Pilatowicz }
1402e8fb11a1Sshidokht
14037f0b8309SEdward Pilatowicz status = DK_TG_GETBLOCKSIZE(cl, &lbasize, tg_cookie);
14047f0b8309SEdward Pilatowicz mutex_enter(CMLB_MUTEX(cl));
14057f0b8309SEdward Pilatowicz if (status != 0)
14067f0b8309SEdward Pilatowicz return (EIO);
14077f0b8309SEdward Pilatowicz
14087f0b8309SEdward Pilatowicz if ((capacity != 0) && (lbasize != 0)) {
14097f0b8309SEdward Pilatowicz cl->cl_blockcount = capacity;
14107f0b8309SEdward Pilatowicz cl->cl_tgt_blocksize = lbasize;
141165908c77Syu, larry liu - Sun Microsystems - Beijing China if (!cl->cl_is_removable) {
141265908c77Syu, larry liu - Sun Microsystems - Beijing China cl->cl_sys_blocksize = lbasize;
141365908c77Syu, larry liu - Sun Microsystems - Beijing China }
14143ccda647Slclee return (0);
14157f0b8309SEdward Pilatowicz } else {
14167f0b8309SEdward Pilatowicz return (EIO);
14177f0b8309SEdward Pilatowicz }
14183ccda647Slclee }
14193ccda647Slclee
142006bbe1e0Sedp static int
cmlb_create_minor(dev_info_t * dip,char * name,int spec_type,minor_t minor_num,char * node_type,int flag,boolean_t internal)142106bbe1e0Sedp cmlb_create_minor(dev_info_t *dip, char *name, int spec_type,
142206bbe1e0Sedp minor_t minor_num, char *node_type, int flag, boolean_t internal)
142306bbe1e0Sedp {
14247f0b8309SEdward Pilatowicz ASSERT(VALID_BOOLEAN(internal));
14257f0b8309SEdward Pilatowicz
142606bbe1e0Sedp if (internal)
142706bbe1e0Sedp return (ddi_create_internal_pathname(dip,
142806bbe1e0Sedp name, spec_type, minor_num));
142906bbe1e0Sedp else
143006bbe1e0Sedp return (ddi_create_minor_node(dip,
143106bbe1e0Sedp name, spec_type, minor_num, node_type, flag));
143206bbe1e0Sedp }
143306bbe1e0Sedp
14343ccda647Slclee /*
14353ccda647Slclee * Function: cmlb_create_minor_nodes
14363ccda647Slclee *
14373ccda647Slclee * Description: Create or adjust the minor device nodes for the instance.
1438531d0b66SToomas Soome * Minor nodes are created based on default label type,
14393ccda647Slclee * current label type and last label type we created
14403ccda647Slclee * minor nodes based on.
14413ccda647Slclee *
14423ccda647Slclee *
1443e8fb11a1Sshidokht * Arguments: cl - driver soft state (unit) structure
14443ccda647Slclee *
14453ccda647Slclee * Return Code: 0 success
14463ccda647Slclee * ENXIO failure.
14473ccda647Slclee *
14483ccda647Slclee * Context: Kernel thread context
14493ccda647Slclee */
14503ccda647Slclee static int
cmlb_create_minor_nodes(struct cmlb_lun * cl)1451e8fb11a1Sshidokht cmlb_create_minor_nodes(struct cmlb_lun *cl)
14523ccda647Slclee {
14533ccda647Slclee struct driver_minor_data *dmdp;
1454406fc510SToomas Soome int instance, shift;
14553ccda647Slclee char name[48];
14563ccda647Slclee cmlb_label_t newlabeltype;
145706bbe1e0Sedp boolean_t internal;
14583ccda647Slclee
1459e8fb11a1Sshidokht ASSERT(cl != NULL);
1460e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
14613ccda647Slclee
14627f0b8309SEdward Pilatowicz internal = VOID2BOOLEAN(
14637f0b8309SEdward Pilatowicz (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
14643ccda647Slclee
1465406fc510SToomas Soome if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
1466406fc510SToomas Soome shift = CMLBUNIT_FORCE_P0_SHIFT;
1467406fc510SToomas Soome else
1468406fc510SToomas Soome shift = CMLBUNIT_SHIFT;
1469406fc510SToomas Soome
14703ccda647Slclee /* check the most common case */
1471e8fb11a1Sshidokht if (cl->cl_cur_labeltype != CMLB_LABEL_UNDEF &&
1472e8fb11a1Sshidokht cl->cl_last_labeltype == cl->cl_cur_labeltype) {
14733ccda647Slclee /* do nothing */
14743ccda647Slclee return (0);
14753ccda647Slclee }
14763ccda647Slclee
1477e8fb11a1Sshidokht if (cl->cl_def_labeltype == CMLB_LABEL_UNDEF) {
14783ccda647Slclee /* we should never get here */
14793ccda647Slclee return (ENXIO);
14803ccda647Slclee }
14813ccda647Slclee
1482e8fb11a1Sshidokht if (cl->cl_last_labeltype == CMLB_LABEL_UNDEF) {
14833ccda647Slclee /* first time during attach */
1484e8fb11a1Sshidokht newlabeltype = cl->cl_def_labeltype;
14853ccda647Slclee
1486e8fb11a1Sshidokht instance = ddi_get_instance(CMLB_DEVINFO(cl));
14873ccda647Slclee
14883ccda647Slclee /* Create all the minor nodes for this target. */
14893ccda647Slclee dmdp = (newlabeltype == CMLB_LABEL_EFI) ? dk_minor_data_efi :
14903ccda647Slclee dk_minor_data;
14913ccda647Slclee while (dmdp->name != NULL) {
14923ccda647Slclee
14933ccda647Slclee (void) sprintf(name, "%s", dmdp->name);
14943ccda647Slclee
149506bbe1e0Sedp if (cmlb_create_minor(CMLB_DEVINFO(cl), name,
14963ccda647Slclee dmdp->type,
1497406fc510SToomas Soome (instance << shift) | dmdp->minor,
1498531d0b66SToomas Soome cl->cl_node_type, 0, internal) == DDI_FAILURE) {
14993ccda647Slclee /*
15003ccda647Slclee * Clean up any nodes that may have been
15013ccda647Slclee * created, in case this fails in the middle
15023ccda647Slclee * of the loop.
15033ccda647Slclee */
1504e8fb11a1Sshidokht ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
15053ccda647Slclee return (ENXIO);
15063ccda647Slclee }
15073ccda647Slclee dmdp++;
15083ccda647Slclee }
1509e8fb11a1Sshidokht cl->cl_last_labeltype = newlabeltype;
1510406fc510SToomas Soome #if defined(_SUNOS_VTOC_8)
1511406fc510SToomas Soome /*
1512406fc510SToomas Soome * "emulate" p0 device for sparc, used by lofi
1513406fc510SToomas Soome */
1514406fc510SToomas Soome if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) {
1515406fc510SToomas Soome if (cmlb_create_minor(CMLB_DEVINFO(cl), "q", S_IFBLK,
1516406fc510SToomas Soome (instance << CMLBUNIT_FORCE_P0_SHIFT) | P0_RAW_DISK,
151785ba5240SToomas Soome cl->cl_node_type, 0, internal) == DDI_FAILURE) {
1518406fc510SToomas Soome ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
1519406fc510SToomas Soome return (ENXIO);
1520406fc510SToomas Soome }
1521406fc510SToomas Soome
1522406fc510SToomas Soome if (cmlb_create_minor(CMLB_DEVINFO(cl), "q,raw",
1523406fc510SToomas Soome S_IFCHR,
1524406fc510SToomas Soome (instance << CMLBUNIT_FORCE_P0_SHIFT) | P0_RAW_DISK,
152585ba5240SToomas Soome cl->cl_node_type, 0, internal) == DDI_FAILURE) {
1526406fc510SToomas Soome ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
1527406fc510SToomas Soome return (ENXIO);
1528406fc510SToomas Soome }
1529406fc510SToomas Soome }
1530406fc510SToomas Soome #endif /* defined(_SUNOS_VTOC_8) */
15313ccda647Slclee return (0);
15323ccda647Slclee }
15333ccda647Slclee
15343ccda647Slclee /* Not first time */
1535e8fb11a1Sshidokht if (cl->cl_cur_labeltype == CMLB_LABEL_UNDEF) {
1536e8fb11a1Sshidokht if (cl->cl_last_labeltype != cl->cl_def_labeltype) {
15373ccda647Slclee /* close time, revert to default. */
1538e8fb11a1Sshidokht newlabeltype = cl->cl_def_labeltype;
15393ccda647Slclee } else {
15403ccda647Slclee /*
15413ccda647Slclee * do nothing since the type for which we last created
15423ccda647Slclee * nodes matches the default
15433ccda647Slclee */
15443ccda647Slclee return (0);
15453ccda647Slclee }
15463ccda647Slclee } else {
1547e8fb11a1Sshidokht if (cl->cl_cur_labeltype != cl->cl_last_labeltype) {
15483ccda647Slclee /* We are not closing, use current label type */
1549e8fb11a1Sshidokht newlabeltype = cl->cl_cur_labeltype;
15503ccda647Slclee } else {
15513ccda647Slclee /*
15523ccda647Slclee * do nothing since the type for which we last created
15533ccda647Slclee * nodes matches the current label type
15543ccda647Slclee */
15553ccda647Slclee return (0);
15563ccda647Slclee }
15573ccda647Slclee }
15583ccda647Slclee
1559e8fb11a1Sshidokht instance = ddi_get_instance(CMLB_DEVINFO(cl));
15603ccda647Slclee
15613ccda647Slclee /*
15623ccda647Slclee * Currently we only fix up the s7 node when we are switching
15633ccda647Slclee * label types from or to EFI. This is consistent with
15643ccda647Slclee * current behavior of sd.
15653ccda647Slclee */
15663ccda647Slclee if (newlabeltype == CMLB_LABEL_EFI &&
1567e8fb11a1Sshidokht cl->cl_last_labeltype != CMLB_LABEL_EFI) {
15683ccda647Slclee /* from vtoc to EFI */
1569e8fb11a1Sshidokht ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
1570e8fb11a1Sshidokht ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
157106bbe1e0Sedp (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd",
1572406fc510SToomas Soome S_IFBLK, (instance << shift) | WD_NODE,
1573531d0b66SToomas Soome cl->cl_node_type, 0, internal);
157406bbe1e0Sedp (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd,raw",
1575406fc510SToomas Soome S_IFCHR, (instance << shift) | WD_NODE,
1576531d0b66SToomas Soome cl->cl_node_type, 0, internal);
15773ccda647Slclee } else {
15783ccda647Slclee /* from efi to vtoc */
1579e8fb11a1Sshidokht ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
1580e8fb11a1Sshidokht ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
158106bbe1e0Sedp (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
1582406fc510SToomas Soome S_IFBLK, (instance << shift) | WD_NODE,
1583531d0b66SToomas Soome cl->cl_node_type, 0, internal);
158406bbe1e0Sedp (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
1585406fc510SToomas Soome S_IFCHR, (instance << shift) | WD_NODE,
1586531d0b66SToomas Soome cl->cl_node_type, 0, internal);
15873ccda647Slclee }
15883ccda647Slclee
1589e8fb11a1Sshidokht cl->cl_last_labeltype = newlabeltype;
15903ccda647Slclee return (0);
15913ccda647Slclee }
15923ccda647Slclee
15933ccda647Slclee /*
15943ccda647Slclee * Function: cmlb_validate_geometry
15953ccda647Slclee *
15963ccda647Slclee * Description: Read the label from the disk (if present). Update the unit's
15973ccda647Slclee * geometry and vtoc information from the data in the label.
15983ccda647Slclee * Verify that the label is valid.
15993ccda647Slclee *
1600e8fb11a1Sshidokht * Arguments:
1601e8fb11a1Sshidokht * cl driver soft state (unit) structure
1602e8fb11a1Sshidokht *
1603e8fb11a1Sshidokht * forcerevalid force revalidation even if we are already valid.
1604e8fb11a1Sshidokht * flags operation flags from target driver. Used for verbosity
1605e8fb11a1Sshidokht * control at this time.
1606e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
1607e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
16083ccda647Slclee *
16093ccda647Slclee * Return Code: 0 - Successful completion
1610e8fb11a1Sshidokht * EINVAL - Invalid value in cl->cl_tgt_blocksize or
1611e8fb11a1Sshidokht * cl->cl_blockcount; or label on disk is corrupted
16123ccda647Slclee * or unreadable.
16133ccda647Slclee * EACCES - Reservation conflict at the device.
16143ccda647Slclee * ENOMEM - Resource allocation error
16153ccda647Slclee * ENOTSUP - geometry not applicable
16163ccda647Slclee *
16173ccda647Slclee * Context: Kernel thread only (can sleep).
16183ccda647Slclee */
16193ccda647Slclee static int
cmlb_validate_geometry(struct cmlb_lun * cl,boolean_t forcerevalid,int flags,void * tg_cookie)16207f0b8309SEdward Pilatowicz cmlb_validate_geometry(struct cmlb_lun *cl, boolean_t forcerevalid, int flags,
1621e8fb11a1Sshidokht void *tg_cookie)
16223ccda647Slclee {
16233ccda647Slclee int label_error = 0;
16243ccda647Slclee diskaddr_t capacity;
16253ccda647Slclee int count;
16263ccda647Slclee
1627e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
16287f0b8309SEdward Pilatowicz ASSERT(VALID_BOOLEAN(forcerevalid));
16293ccda647Slclee
16307f0b8309SEdward Pilatowicz if ((cl->cl_f_geometry_is_valid) && (!forcerevalid)) {
1631e8fb11a1Sshidokht if (cl->cl_cur_labeltype == CMLB_LABEL_EFI)
16323ccda647Slclee return (ENOTSUP);
16333ccda647Slclee return (0);
16343ccda647Slclee }
16353ccda647Slclee
1636e8fb11a1Sshidokht if (cmlb_check_update_blockcount(cl, tg_cookie) != 0)
16373ccda647Slclee return (EIO);
16383ccda647Slclee
1639e8fb11a1Sshidokht capacity = cl->cl_blockcount;
16403ccda647Slclee
16413ccda647Slclee /*
16423ccda647Slclee * Set up the "whole disk" fdisk partition; this should always
16433ccda647Slclee * exist, regardless of whether the disk contains an fdisk table
16443ccda647Slclee * or vtoc.
16453ccda647Slclee */
1646e8fb11a1Sshidokht cl->cl_map[P0_RAW_DISK].dkl_cylno = 0;
1647342440ecSPrasad Singamsetty cl->cl_offset[P0_RAW_DISK] = 0;
16483ccda647Slclee /*
1649342440ecSPrasad Singamsetty * note if capacity > int32_max(1TB) we are in 64bit environment
1650342440ecSPrasad Singamsetty * so no truncation happens
16513ccda647Slclee */
1652e8fb11a1Sshidokht cl->cl_map[P0_RAW_DISK].dkl_nblk = capacity;
1653406fc510SToomas Soome
16543ccda647Slclee /*
16553ccda647Slclee * Refresh the logical and physical geometry caches.
16563ccda647Slclee * (data from MODE SENSE format/rigid disk geometry pages,
16573ccda647Slclee * and scsi_ifgetcap("geometry").
16583ccda647Slclee */
1659e8fb11a1Sshidokht cmlb_resync_geom_caches(cl, capacity, tg_cookie);
16603ccda647Slclee
1661342440ecSPrasad Singamsetty cl->cl_label_from_media = CMLB_LABEL_UNDEF;
1662e8fb11a1Sshidokht label_error = cmlb_use_efi(cl, capacity, flags, tg_cookie);
16633ccda647Slclee if (label_error == 0) {
16643ccda647Slclee
16653ccda647Slclee /* found a valid EFI label */
1666e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl,
16673ccda647Slclee "cmlb_validate_geometry: found EFI label\n");
16683ccda647Slclee /*
16693ccda647Slclee * solaris_size and geometry_is_valid are set in
16703ccda647Slclee * cmlb_use_efi
16713ccda647Slclee */
16723ccda647Slclee return (ENOTSUP);
16733ccda647Slclee }
16743ccda647Slclee
16753ccda647Slclee /* NO EFI label found */
16763ccda647Slclee
1677342440ecSPrasad Singamsetty if (capacity > CMLB_EXTVTOC_LIMIT) {
16783ccda647Slclee if (label_error == ESRCH) {
16793ccda647Slclee /*
1680342440ecSPrasad Singamsetty * they've configured a LUN over 2TB, but used
16813ccda647Slclee * format.dat to restrict format's view of the
1682342440ecSPrasad Singamsetty * capacity to be under 2TB in some earlier Solaris
1683342440ecSPrasad Singamsetty * release.
16843ccda647Slclee */
1685342440ecSPrasad Singamsetty /* i.e > 2TB with a VTOC < 2TB */
1686342440ecSPrasad Singamsetty if (!(flags & CMLB_SILENT) &&
1687342440ecSPrasad Singamsetty (cl->cl_msglog_flag & CMLB_ALLOW_2TB_WARN)) {
1688e8fb11a1Sshidokht
1689e8fb11a1Sshidokht cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
1690342440ecSPrasad Singamsetty CE_NOTE, "!Disk (%s%d) is limited to 2 TB "
1691342440ecSPrasad Singamsetty "due to VTOC label. To use the full "
1692*bbf21555SRichard Lowe "capacity of the disk, use format(8) to "
1693342440ecSPrasad Singamsetty "relabel the disk with EFI/GPT label.\n",
1694342440ecSPrasad Singamsetty CMLB_LABEL(cl),
1695342440ecSPrasad Singamsetty ddi_get_instance(CMLB_DEVINFO(cl)));
1696342440ecSPrasad Singamsetty
1697342440ecSPrasad Singamsetty cl->cl_msglog_flag &= ~CMLB_ALLOW_2TB_WARN;
1698e8fb11a1Sshidokht }
16993ccda647Slclee } else {
1700e8fb11a1Sshidokht return (ENOTSUP);
17013ccda647Slclee }
17023ccda647Slclee }
17033ccda647Slclee
17043ccda647Slclee label_error = 0;
17053ccda647Slclee
17063ccda647Slclee /*
17073ccda647Slclee * at this point it is either labeled with a VTOC or it is
1708e8fb11a1Sshidokht * under 1TB (<= 1TB actually for off-by-1)
17093ccda647Slclee */
17103ccda647Slclee
17113ccda647Slclee /*
1712e8fb11a1Sshidokht * Only DIRECT ACCESS devices will have Scl labels.
1713e8fb11a1Sshidokht * CD's supposedly have a Scl label, too
17143ccda647Slclee */
1715e8fb11a1Sshidokht if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) {
17163ccda647Slclee struct dk_label *dkl;
17173ccda647Slclee offset_t label_addr;
17183ccda647Slclee int rval;
17193ccda647Slclee size_t buffer_size;
17203ccda647Slclee
17213ccda647Slclee /*
1722e8fb11a1Sshidokht * Note: This will set up cl->cl_solaris_size and
1723e8fb11a1Sshidokht * cl->cl_solaris_offset.
17243ccda647Slclee */
1725e8fb11a1Sshidokht rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
1726e8fb11a1Sshidokht if ((rval != 0) && !ISCD(cl)) {
1727e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
17283ccda647Slclee return (rval);
17293ccda647Slclee }
17303ccda647Slclee
1731e8fb11a1Sshidokht if (cl->cl_solaris_size <= DK_LABEL_LOC) {
17323ccda647Slclee /*
17333ccda647Slclee * Found fdisk table but no Solaris partition entry,
17343ccda647Slclee * so don't call cmlb_uselabel() and don't create
17353ccda647Slclee * a default label.
17363ccda647Slclee */
17373ccda647Slclee label_error = 0;
17387f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_TRUE;
17393ccda647Slclee goto no_solaris_partition;
17403ccda647Slclee }
17413ccda647Slclee
1742e8fb11a1Sshidokht label_addr = (daddr_t)(cl->cl_solaris_offset + DK_LABEL_LOC);
1743e8fb11a1Sshidokht
174465908c77Syu, larry liu - Sun Microsystems - Beijing China buffer_size = cl->cl_sys_blocksize;
17453ccda647Slclee
1746e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl, "cmlb_validate_geometry: "
17473ccda647Slclee "label_addr: 0x%x allocation size: 0x%x\n",
17483ccda647Slclee label_addr, buffer_size);
17493ccda647Slclee
17503ccda647Slclee if ((dkl = kmem_zalloc(buffer_size, KM_NOSLEEP)) == NULL)
17513ccda647Slclee return (ENOMEM);
17523ccda647Slclee
1753e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
1754e8fb11a1Sshidokht rval = DK_TG_READ(cl, dkl, label_addr, buffer_size, tg_cookie);
1755e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
17563ccda647Slclee
17573ccda647Slclee switch (rval) {
17583ccda647Slclee case 0:
17593ccda647Slclee /*
17603ccda647Slclee * cmlb_uselabel will establish that the geometry
17613ccda647Slclee * is valid.
17623ccda647Slclee */
1763e8fb11a1Sshidokht if (cmlb_uselabel(cl,
1764e8fb11a1Sshidokht (struct dk_label *)(uintptr_t)dkl, flags) !=
17653ccda647Slclee CMLB_LABEL_IS_VALID) {
17663ccda647Slclee label_error = EINVAL;
17673ccda647Slclee } else
1768342440ecSPrasad Singamsetty cl->cl_label_from_media = CMLB_LABEL_VTOC;
17693ccda647Slclee break;
17703ccda647Slclee case EACCES:
17713ccda647Slclee label_error = EACCES;
17723ccda647Slclee break;
17733ccda647Slclee default:
17743ccda647Slclee label_error = EINVAL;
17753ccda647Slclee break;
17763ccda647Slclee }
17773ccda647Slclee
17783ccda647Slclee kmem_free(dkl, buffer_size);
17793ccda647Slclee }
17803ccda647Slclee
17813ccda647Slclee /*
17823ccda647Slclee * If a valid label was not found, AND if no reservation conflict
17833ccda647Slclee * was detected, then go ahead and create a default label (4069506).
17843ccda647Slclee *
17853ccda647Slclee * Note: currently, for VTOC_8 devices, the default label is created
1786e8fb11a1Sshidokht * for removables and hotpluggables only. For VTOC_16 devices, the
1787e8fb11a1Sshidokht * default label will be created for all devices.
17883ccda647Slclee * (see cmlb_build_default_label)
17893ccda647Slclee */
17903ccda647Slclee #if defined(_SUNOS_VTOC_8)
1791e8fb11a1Sshidokht if ((ISREMOVABLE(cl) || ISHOTPLUGGABLE(cl)) &&
1792e8fb11a1Sshidokht (label_error != EACCES)) {
17933ccda647Slclee #elif defined(_SUNOS_VTOC_16)
17943ccda647Slclee if (label_error != EACCES) {
17953ccda647Slclee #endif
17967f0b8309SEdward Pilatowicz if (!cl->cl_f_geometry_is_valid) {
1797e8fb11a1Sshidokht cmlb_build_default_label(cl, tg_cookie);
17983ccda647Slclee }
17993ccda647Slclee label_error = 0;
18003ccda647Slclee }
18013ccda647Slclee
18023ccda647Slclee no_solaris_partition:
18033ccda647Slclee
18043ccda647Slclee #if defined(_SUNOS_VTOC_16)
18053ccda647Slclee /*
18063ccda647Slclee * If we have valid geometry, set up the remaining fdisk partitions.
18073ccda647Slclee * Note that dkl_cylno is not used for the fdisk map entries, so
18083ccda647Slclee * we set it to an entirely bogus value.
18093ccda647Slclee */
1810aa1b14e7SSheshadri Vasudevan for (count = 0; count < FDISK_PARTS; count++) {
1811342440ecSPrasad Singamsetty cl->cl_map[FDISK_P1 + count].dkl_cylno = UINT16_MAX;
1812e8fb11a1Sshidokht cl->cl_map[FDISK_P1 + count].dkl_nblk =
1813e8fb11a1Sshidokht cl->cl_fmap[count].fmap_nblk;
18143ccda647Slclee
1815e8fb11a1Sshidokht cl->cl_offset[FDISK_P1 + count] =
1816e8fb11a1Sshidokht cl->cl_fmap[count].fmap_start;
18173ccda647Slclee }
18183ccda647Slclee #endif
18193ccda647Slclee
18203ccda647Slclee for (count = 0; count < NDKMAP; count++) {
18213ccda647Slclee #if defined(_SUNOS_VTOC_8)
1822e8fb11a1Sshidokht struct dk_map *lp = &cl->cl_map[count];
1823e8fb11a1Sshidokht cl->cl_offset[count] =
1824e8fb11a1Sshidokht cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
18253ccda647Slclee #elif defined(_SUNOS_VTOC_16)
1826e8fb11a1Sshidokht struct dkl_partition *vp = &cl->cl_vtoc.v_part[count];
18273ccda647Slclee
1828e8fb11a1Sshidokht cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset;
18293ccda647Slclee #else
18303ccda647Slclee #error "No VTOC format defined."
18313ccda647Slclee #endif
18323ccda647Slclee }
18333ccda647Slclee
18343ccda647Slclee return (label_error);
18353ccda647Slclee }
18363ccda647Slclee
18373ccda647Slclee #if defined(_SUNOS_VTOC_16)
18383ccda647Slclee /*
18393ccda647Slclee * Function: cmlb_convert_geometry
18403ccda647Slclee *
18413ccda647Slclee * Description: Convert physical geometry into a dk_geom structure. In
18423ccda647Slclee * other words, make sure we don't wrap 16-bit values.
18433ccda647Slclee * e.g. converting from geom_cache to dk_geom
18443ccda647Slclee *
18453ccda647Slclee * Context: Kernel thread only
18463ccda647Slclee */
18473ccda647Slclee static void
1848b081f1c4Syu, larry liu - Sun Microsystems - Beijing China cmlb_convert_geometry(struct cmlb_lun *cl, diskaddr_t capacity,
1849b081f1c4Syu, larry liu - Sun Microsystems - Beijing China struct dk_geom *cl_g, void *tg_cookie)
18503ccda647Slclee {
18513ccda647Slclee
1852b081f1c4Syu, larry liu - Sun Microsystems - Beijing China ASSERT(cl != NULL);
1853b081f1c4Syu, larry liu - Sun Microsystems - Beijing China ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1854b081f1c4Syu, larry liu - Sun Microsystems - Beijing China
18553ccda647Slclee /* Unlabeled SCSI floppy device */
1856c31fac72SShidokht Yadegari if (capacity < 160) {
1857c31fac72SShidokht Yadegari /* Less than 80K */
1858c31fac72SShidokht Yadegari cl_g->dkg_nhead = 1;
1859c31fac72SShidokht Yadegari cl_g->dkg_ncyl = capacity;
1860c31fac72SShidokht Yadegari cl_g->dkg_nsect = 1;
1861c31fac72SShidokht Yadegari return;
1862c31fac72SShidokht Yadegari } else if (capacity <= 0x1000) {
1863e8fb11a1Sshidokht cl_g->dkg_nhead = 2;
1864e8fb11a1Sshidokht cl_g->dkg_ncyl = 80;
1865e8fb11a1Sshidokht cl_g->dkg_nsect = capacity / (cl_g->dkg_nhead * cl_g->dkg_ncyl);
18663ccda647Slclee return;
18673ccda647Slclee }
18683ccda647Slclee
18693ccda647Slclee /*
1870342440ecSPrasad Singamsetty * For all devices we calculate cylinders using the heads and sectors
1871342440ecSPrasad Singamsetty * we assign based on capacity of the device. The algorithm is
1872342440ecSPrasad Singamsetty * designed to be compatible with the way other operating systems
1873342440ecSPrasad Singamsetty * lay out fdisk tables for X86 and to insure that the cylinders never
1874342440ecSPrasad Singamsetty * exceed 65535 to prevent problems with X86 ioctls that report
1875342440ecSPrasad Singamsetty * geometry.
1876342440ecSPrasad Singamsetty * For some smaller disk sizes we report geometry that matches those
1877342440ecSPrasad Singamsetty * used by X86 BIOS usage. For larger disks, we use SPT that are
1878342440ecSPrasad Singamsetty * multiples of 63, since other OSes that are not limited to 16-bits
1879342440ecSPrasad Singamsetty * for cylinders stop at 63 SPT we make do by using multiples of 63 SPT.
1880342440ecSPrasad Singamsetty *
1881342440ecSPrasad Singamsetty * The following table (in order) illustrates some end result
1882342440ecSPrasad Singamsetty * calculations:
18833ccda647Slclee *
1884531d0b66SToomas Soome * Maximum number of blocks nhead nsect
1885342440ecSPrasad Singamsetty *
1886342440ecSPrasad Singamsetty * 2097152 (1GB) 64 32
1887342440ecSPrasad Singamsetty * 16777216 (8GB) 128 32
1888531d0b66SToomas Soome * 1052819775 (502.02GB) 255 63
1889342440ecSPrasad Singamsetty * 2105639550 (0.98TB) 255 126
1890531d0b66SToomas Soome * 3158459325 (1.47TB) 255 189
1891531d0b66SToomas Soome * 4211279100 (1.96TB) 255 252
1892531d0b66SToomas Soome * 5264098875 (2.45TB) 255 315
1893342440ecSPrasad Singamsetty * ...
1894b081f1c4Syu, larry liu - Sun Microsystems - Beijing China *
1895b081f1c4Syu, larry liu - Sun Microsystems - Beijing China * For Solid State Drive(SSD), it uses 4K page size inside and may be
1896b081f1c4Syu, larry liu - Sun Microsystems - Beijing China * double with every new generation. If the I/O is not aligned with
1897b081f1c4Syu, larry liu - Sun Microsystems - Beijing China * page size on SSDs, SSDs perform a lot slower.
1898b081f1c4Syu, larry liu - Sun Microsystems - Beijing China * By default, Solaris partition starts from cylinder 1. It will be
1899b081f1c4Syu, larry liu - Sun Microsystems - Beijing China * misaligned even with 4K if using heads(255) and SPT(63). To
1900b081f1c4Syu, larry liu - Sun Microsystems - Beijing China * workaround the problem, if the device is SSD, we use heads(224) and
1901b081f1c4Syu, larry liu - Sun Microsystems - Beijing China * SPT multiple of 56. Thus the default Solaris partition starts from
1902b081f1c4Syu, larry liu - Sun Microsystems - Beijing China * a position that aligns with 128K on a 512 bytes sector size SSD.
19033ccda647Slclee */
19043ccda647Slclee
1905342440ecSPrasad Singamsetty if (capacity <= 0x200000) {
1906342440ecSPrasad Singamsetty cl_g->dkg_nhead = 64;
1907342440ecSPrasad Singamsetty cl_g->dkg_nsect = 32;
1908342440ecSPrasad Singamsetty } else if (capacity <= 0x01000000) {
1909342440ecSPrasad Singamsetty cl_g->dkg_nhead = 128;
1910342440ecSPrasad Singamsetty cl_g->dkg_nsect = 32;
1911342440ecSPrasad Singamsetty } else {
1912b081f1c4Syu, larry liu - Sun Microsystems - Beijing China tg_attribute_t tgattribute;
1913b081f1c4Syu, larry liu - Sun Microsystems - Beijing China int is_solid_state;
1914b081f1c4Syu, larry liu - Sun Microsystems - Beijing China unsigned short nhead;
1915b081f1c4Syu, larry liu - Sun Microsystems - Beijing China unsigned short nsect;
1916b081f1c4Syu, larry liu - Sun Microsystems - Beijing China
1917b081f1c4Syu, larry liu - Sun Microsystems - Beijing China bzero(&tgattribute, sizeof (tg_attribute_t));
1918342440ecSPrasad Singamsetty
1919b081f1c4Syu, larry liu - Sun Microsystems - Beijing China mutex_exit(CMLB_MUTEX(cl));
1920b081f1c4Syu, larry liu - Sun Microsystems - Beijing China is_solid_state =
1921b081f1c4Syu, larry liu - Sun Microsystems - Beijing China (DK_TG_GETATTRIBUTE(cl, &tgattribute, tg_cookie) == 0) ?
1922b081f1c4Syu, larry liu - Sun Microsystems - Beijing China tgattribute.media_is_solid_state : FALSE;
1923b081f1c4Syu, larry liu - Sun Microsystems - Beijing China mutex_enter(CMLB_MUTEX(cl));
1924b081f1c4Syu, larry liu - Sun Microsystems - Beijing China
1925b081f1c4Syu, larry liu - Sun Microsystems - Beijing China if (is_solid_state) {
1926b081f1c4Syu, larry liu - Sun Microsystems - Beijing China nhead = 224;
1927b081f1c4Syu, larry liu - Sun Microsystems - Beijing China nsect = 56;
1928b081f1c4Syu, larry liu - Sun Microsystems - Beijing China } else {
1929b081f1c4Syu, larry liu - Sun Microsystems - Beijing China nhead = 255;
1930b081f1c4Syu, larry liu - Sun Microsystems - Beijing China nsect = 63;
1931b081f1c4Syu, larry liu - Sun Microsystems - Beijing China }
1932b081f1c4Syu, larry liu - Sun Microsystems - Beijing China
1933b081f1c4Syu, larry liu - Sun Microsystems - Beijing China cl_g->dkg_nhead = nhead;
1934b081f1c4Syu, larry liu - Sun Microsystems - Beijing China
1935b132e0a0Slu cai - Sun Microsystems - Beijing China /* make dkg_nsect be smallest multiple of nsect */
1936342440ecSPrasad Singamsetty cl_g->dkg_nsect = ((capacity +
1937b081f1c4Syu, larry liu - Sun Microsystems - Beijing China (UINT16_MAX * nhead * nsect) - 1) /
1938b081f1c4Syu, larry liu - Sun Microsystems - Beijing China (UINT16_MAX * nhead * nsect)) * nsect;
1939342440ecSPrasad Singamsetty
1940342440ecSPrasad Singamsetty if (cl_g->dkg_nsect == 0)
1941b081f1c4Syu, larry liu - Sun Microsystems - Beijing China cl_g->dkg_nsect = (UINT16_MAX / nsect) * nsect;
1942342440ecSPrasad Singamsetty }
1943342440ecSPrasad Singamsetty
19443ccda647Slclee }
19453ccda647Slclee #endif
19463ccda647Slclee
19473ccda647Slclee /*
19483ccda647Slclee * Function: cmlb_resync_geom_caches
19493ccda647Slclee *
19503ccda647Slclee * Description: (Re)initialize both geometry caches: the virtual geometry
19513ccda647Slclee * information is extracted from the HBA (the "geometry"
19523ccda647Slclee * capability), and the physical geometry cache data is
19533ccda647Slclee * generated by issuing MODE SENSE commands.
19543ccda647Slclee *
1955e8fb11a1Sshidokht * Arguments:
1956531d0b66SToomas Soome * cl driver soft state (unit) structure
1957e8fb11a1Sshidokht * capacity disk capacity in #blocks
1958e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
1959e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
19603ccda647Slclee *
19613ccda647Slclee * Context: Kernel thread only (can sleep).
19623ccda647Slclee */
19633ccda647Slclee static void
1964e8fb11a1Sshidokht cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity,
1965e8fb11a1Sshidokht void *tg_cookie)
19663ccda647Slclee {
1967531d0b66SToomas Soome struct cmlb_geom pgeom;
19683ccda647Slclee struct cmlb_geom lgeom;
1969531d0b66SToomas Soome struct cmlb_geom *pgeomp = &pgeom;
1970531d0b66SToomas Soome unsigned short nhead;
1971531d0b66SToomas Soome unsigned short nsect;
1972531d0b66SToomas Soome int spc;
19733ccda647Slclee int ret;
19743ccda647Slclee
1975e8fb11a1Sshidokht ASSERT(cl != NULL);
1976e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
19773ccda647Slclee
19783ccda647Slclee /*
19793ccda647Slclee * Ask the controller for its logical geometry.
19803ccda647Slclee * Note: if the HBA does not support scsi_ifgetcap("geometry"),
19813ccda647Slclee * then the lgeom cache will be invalid.
19823ccda647Slclee */
1983e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
19843ccda647Slclee bzero(&lgeom, sizeof (struct cmlb_geom));
1985e8fb11a1Sshidokht ret = DK_TG_GETVIRTGEOM(cl, &lgeom, tg_cookie);
1986e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
19873ccda647Slclee
1988e8fb11a1Sshidokht bcopy(&lgeom, &cl->cl_lgeom, sizeof (cl->cl_lgeom));
19893ccda647Slclee
19903ccda647Slclee /*
19913ccda647Slclee * Initialize the pgeom cache from lgeom, so that if MODE SENSE
19923ccda647Slclee * doesn't work, DKIOCG_PHYSGEOM can return reasonable values.
19933ccda647Slclee */
1994e8fb11a1Sshidokht if (ret != 0 || cl->cl_lgeom.g_nsect == 0 ||
1995e8fb11a1Sshidokht cl->cl_lgeom.g_nhead == 0) {
19963ccda647Slclee /*
19973ccda647Slclee * Note: Perhaps this needs to be more adaptive? The rationale
19983ccda647Slclee * is that, if there's no HBA geometry from the HBA driver, any
19993ccda647Slclee * guess is good, since this is the physical geometry. If MODE
20003ccda647Slclee * SENSE fails this gives a max cylinder size for non-LBA access
20013ccda647Slclee */
20023ccda647Slclee nhead = 255;
20033ccda647Slclee nsect = 63;
20043ccda647Slclee } else {
2005e8fb11a1Sshidokht nhead = cl->cl_lgeom.g_nhead;
2006e8fb11a1Sshidokht nsect = cl->cl_lgeom.g_nsect;
20073ccda647Slclee }
20083ccda647Slclee
2009e8fb11a1Sshidokht if (ISCD(cl)) {
20103ccda647Slclee pgeomp->g_nhead = 1;
20113ccda647Slclee pgeomp->g_nsect = nsect * nhead;
20123ccda647Slclee } else {
20133ccda647Slclee pgeomp->g_nhead = nhead;
20143ccda647Slclee pgeomp->g_nsect = nsect;
20153ccda647Slclee }
20163ccda647Slclee
20173ccda647Slclee spc = pgeomp->g_nhead * pgeomp->g_nsect;
20183ccda647Slclee pgeomp->g_capacity = capacity;
20197501b6d5SSheshadri Vasudevan if (spc == 0)
20207501b6d5SSheshadri Vasudevan pgeomp->g_ncyl = 0;
20217501b6d5SSheshadri Vasudevan else
20227501b6d5SSheshadri Vasudevan pgeomp->g_ncyl = pgeomp->g_capacity / spc;
20233ccda647Slclee pgeomp->g_acyl = 0;
20243ccda647Slclee
20253ccda647Slclee /*
20263ccda647Slclee * Retrieve fresh geometry data from the hardware, stash it
20273ccda647Slclee * here temporarily before we rebuild the incore label.
20283ccda647Slclee *
20293ccda647Slclee * We want to use the MODE SENSE commands to derive the
20303ccda647Slclee * physical geometry of the device, but if either command
20313ccda647Slclee * fails, the logical geometry is used as the fallback for
20323ccda647Slclee * disk label geometry.
20333ccda647Slclee */
20343ccda647Slclee
2035e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
2036e8fb11a1Sshidokht (void) DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie);
2037e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
20383ccda647Slclee
20393ccda647Slclee /*
20403ccda647Slclee * Now update the real copy while holding the mutex. This
20413ccda647Slclee * way the global copy is never in an inconsistent state.
20423ccda647Slclee */
2043e8fb11a1Sshidokht bcopy(pgeomp, &cl->cl_pgeom, sizeof (cl->cl_pgeom));
20443ccda647Slclee
2045e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl, "cmlb_resync_geom_caches: "
20463ccda647Slclee "(cached from lgeom)\n");
2047e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl,
20483ccda647Slclee " ncyl: %ld; acyl: %d; nhead: %d; nsect: %d\n",
2049e8fb11a1Sshidokht cl->cl_pgeom.g_ncyl, cl->cl_pgeom.g_acyl,
2050e8fb11a1Sshidokht cl->cl_pgeom.g_nhead, cl->cl_pgeom.g_nsect);
2051e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl, " lbasize: %d; capacity: %ld; "
2052e8fb11a1Sshidokht "intrlv: %d; rpm: %d\n", cl->cl_pgeom.g_secsize,
2053e8fb11a1Sshidokht cl->cl_pgeom.g_capacity, cl->cl_pgeom.g_intrlv,
2054e8fb11a1Sshidokht cl->cl_pgeom.g_rpm);
20553ccda647Slclee }
20563ccda647Slclee
20573ccda647Slclee
205886ef0a63SRichard Lowe #if defined(__x86)
2059aa1b14e7SSheshadri Vasudevan /*
2060aa1b14e7SSheshadri Vasudevan * Function: cmlb_update_ext_minor_nodes
2061aa1b14e7SSheshadri Vasudevan *
2062aa1b14e7SSheshadri Vasudevan * Description: Routine to add/remove extended partition device nodes
2063aa1b14e7SSheshadri Vasudevan *
2064aa1b14e7SSheshadri Vasudevan * Arguments:
2065aa1b14e7SSheshadri Vasudevan * cl driver soft state (unit) structure
2066aa1b14e7SSheshadri Vasudevan * num_parts Number of logical drives found on the LUN
2067aa1b14e7SSheshadri Vasudevan *
2068aa1b14e7SSheshadri Vasudevan * Should be called with the mutex held
2069aa1b14e7SSheshadri Vasudevan *
2070aa1b14e7SSheshadri Vasudevan * Return Code: 0 for success
2071aa1b14e7SSheshadri Vasudevan *
2072aa1b14e7SSheshadri Vasudevan * Context: User and Kernel thread
2073aa1b14e7SSheshadri Vasudevan *
2074aa1b14e7SSheshadri Vasudevan */
2075aa1b14e7SSheshadri Vasudevan static int
2076aa1b14e7SSheshadri Vasudevan cmlb_update_ext_minor_nodes(struct cmlb_lun *cl, int num_parts)
2077aa1b14e7SSheshadri Vasudevan {
2078406fc510SToomas Soome int i, count, shift;
2079aa1b14e7SSheshadri Vasudevan char name[48];
2080aa1b14e7SSheshadri Vasudevan int instance;
2081aa1b14e7SSheshadri Vasudevan struct driver_minor_data *demdp, *demdpr;
2082aa1b14e7SSheshadri Vasudevan char *devnm;
2083aa1b14e7SSheshadri Vasudevan dev_info_t *pdip;
2084531d0b66SToomas Soome boolean_t internal;
2085aa1b14e7SSheshadri Vasudevan
2086aa1b14e7SSheshadri Vasudevan ASSERT(mutex_owned(CMLB_MUTEX(cl)));
2087aa1b14e7SSheshadri Vasudevan ASSERT(cl->cl_update_ext_minor_nodes == 1);
2088aa1b14e7SSheshadri Vasudevan
2089aa1b14e7SSheshadri Vasudevan internal = VOID2BOOLEAN(
2090aa1b14e7SSheshadri Vasudevan (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
2091aa1b14e7SSheshadri Vasudevan instance = ddi_get_instance(CMLB_DEVINFO(cl));
2092aa1b14e7SSheshadri Vasudevan demdp = dk_ext_minor_data;
2093aa1b14e7SSheshadri Vasudevan demdpr = &dk_ext_minor_data[MAX_EXT_PARTS];
2094aa1b14e7SSheshadri Vasudevan
2095406fc510SToomas Soome if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
2096406fc510SToomas Soome shift = CMLBUNIT_FORCE_P0_SHIFT;
2097406fc510SToomas Soome else
2098406fc510SToomas Soome shift = CMLBUNIT_SHIFT;
2099aa1b14e7SSheshadri Vasudevan
2100aa1b14e7SSheshadri Vasudevan if (cl->cl_logical_drive_count) {
2101aa1b14e7SSheshadri Vasudevan for (i = 0; i < cl->cl_logical_drive_count; i++) {
2102aa1b14e7SSheshadri Vasudevan (void) sprintf(name, "%s", demdp->name);
2103aa1b14e7SSheshadri Vasudevan ddi_remove_minor_node(CMLB_DEVINFO(cl), name);
2104aa1b14e7SSheshadri Vasudevan (void) sprintf(name, "%s", demdpr->name);
2105aa1b14e7SSheshadri Vasudevan ddi_remove_minor_node(CMLB_DEVINFO(cl), name);
2106aa1b14e7SSheshadri Vasudevan demdp++;
2107aa1b14e7SSheshadri Vasudevan demdpr++;
2108aa1b14e7SSheshadri Vasudevan }
2109aa1b14e7SSheshadri Vasudevan /* There are existing device nodes. Remove them */
2110aa1b14e7SSheshadri Vasudevan devnm = kmem_alloc(MAXNAMELEN + 1, KM_SLEEP);
2111aa1b14e7SSheshadri Vasudevan (void) ddi_deviname(cl->cl_devi, devnm);
2112aa1b14e7SSheshadri Vasudevan pdip = ddi_get_parent(cl->cl_devi);
2113aa1b14e7SSheshadri Vasudevan (void) devfs_clean(pdip, devnm + 1, DV_CLEAN_FORCE);
2114aa1b14e7SSheshadri Vasudevan kmem_free(devnm, MAXNAMELEN + 1);
2115aa1b14e7SSheshadri Vasudevan }
2116aa1b14e7SSheshadri Vasudevan
2117aa1b14e7SSheshadri Vasudevan demdp = dk_ext_minor_data;
2118aa1b14e7SSheshadri Vasudevan demdpr = &dk_ext_minor_data[MAX_EXT_PARTS];
2119aa1b14e7SSheshadri Vasudevan
2120aa1b14e7SSheshadri Vasudevan for (i = 0; i < num_parts; i++) {
2121aa1b14e7SSheshadri Vasudevan (void) sprintf(name, "%s", demdp->name);
2122aa1b14e7SSheshadri Vasudevan if (cmlb_create_minor(CMLB_DEVINFO(cl), name,
2123aa1b14e7SSheshadri Vasudevan demdp->type,
2124406fc510SToomas Soome (instance << shift) | demdp->minor,
2125531d0b66SToomas Soome cl->cl_node_type, 0, internal) == DDI_FAILURE) {
2126aa1b14e7SSheshadri Vasudevan /*
2127aa1b14e7SSheshadri Vasudevan * Clean up any nodes that may have been
2128aa1b14e7SSheshadri Vasudevan * created, in case this fails in the middle
2129aa1b14e7SSheshadri Vasudevan * of the loop.
2130aa1b14e7SSheshadri Vasudevan */
2131aa1b14e7SSheshadri Vasudevan ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
2132aa1b14e7SSheshadri Vasudevan cl->cl_logical_drive_count = 0;
2133aa1b14e7SSheshadri Vasudevan return (ENXIO);
2134aa1b14e7SSheshadri Vasudevan }
2135aa1b14e7SSheshadri Vasudevan (void) sprintf(name, "%s", demdpr->name);
2136aa1b14e7SSheshadri Vasudevan if (ddi_create_minor_node(CMLB_DEVINFO(cl), name,
2137aa1b14e7SSheshadri Vasudevan demdpr->type,
2138406fc510SToomas Soome (instance << shift) | demdpr->minor,
2139531d0b66SToomas Soome cl->cl_node_type, 0) == DDI_FAILURE) {
2140aa1b14e7SSheshadri Vasudevan /*
2141aa1b14e7SSheshadri Vasudevan * Clean up any nodes that may have been
2142aa1b14e7SSheshadri Vasudevan * created, in case this fails in the middle
2143aa1b14e7SSheshadri Vasudevan * of the loop.
2144aa1b14e7SSheshadri Vasudevan */
2145aa1b14e7SSheshadri Vasudevan ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
2146aa1b14e7SSheshadri Vasudevan cl->cl_logical_drive_count = 0;
2147aa1b14e7SSheshadri Vasudevan return (ENXIO);
2148aa1b14e7SSheshadri Vasudevan }
2149aa1b14e7SSheshadri Vasudevan demdp++;
2150aa1b14e7SSheshadri Vasudevan demdpr++;
2151aa1b14e7SSheshadri Vasudevan }
2152aa1b14e7SSheshadri Vasudevan
2153aa1b14e7SSheshadri Vasudevan /* Update the cl_map array for logical drives */
2154aa1b14e7SSheshadri Vasudevan for (count = 0; count < MAX_EXT_PARTS; count++) {
2155aa1b14e7SSheshadri Vasudevan cl->cl_map[FDISK_P4 + 1 + count].dkl_cylno = UINT32_MAX;
2156aa1b14e7SSheshadri Vasudevan cl->cl_map[FDISK_P4 + 1 + count].dkl_nblk =
2157aa1b14e7SSheshadri Vasudevan cl->cl_fmap[FD_NUMPART + count].fmap_nblk;
2158aa1b14e7SSheshadri Vasudevan cl->cl_offset[FDISK_P4 + 1 + count] =
2159aa1b14e7SSheshadri Vasudevan cl->cl_fmap[FD_NUMPART + count].fmap_start;
2160aa1b14e7SSheshadri Vasudevan }
2161aa1b14e7SSheshadri Vasudevan
2162aa1b14e7SSheshadri Vasudevan cl->cl_logical_drive_count = i;
2163aa1b14e7SSheshadri Vasudevan cl->cl_update_ext_minor_nodes = 0;
2164aa1b14e7SSheshadri Vasudevan return (0);
2165aa1b14e7SSheshadri Vasudevan }
2166aa1b14e7SSheshadri Vasudevan /*
2167aa1b14e7SSheshadri Vasudevan * Function: cmlb_validate_ext_part
2168aa1b14e7SSheshadri Vasudevan *
2169aa1b14e7SSheshadri Vasudevan * Description: utility routine to validate an extended partition's
2170aa1b14e7SSheshadri Vasudevan * metadata as found on disk
2171aa1b14e7SSheshadri Vasudevan *
2172aa1b14e7SSheshadri Vasudevan * Arguments:
2173aa1b14e7SSheshadri Vasudevan * cl driver soft state (unit) structure
2174aa1b14e7SSheshadri Vasudevan * part partition number of the extended partition
2175aa1b14e7SSheshadri Vasudevan * epart partition number of the logical drive
2176aa1b14e7SSheshadri Vasudevan * start absolute sector number of the start of the logical
2177aa1b14e7SSheshadri Vasudevan * drive being validated
2178aa1b14e7SSheshadri Vasudevan * size size of logical drive being validated
2179aa1b14e7SSheshadri Vasudevan *
2180aa1b14e7SSheshadri Vasudevan * Return Code: 0 for success
2181aa1b14e7SSheshadri Vasudevan *
2182aa1b14e7SSheshadri Vasudevan * Context: User and Kernel thread
2183aa1b14e7SSheshadri Vasudevan *
2184aa1b14e7SSheshadri Vasudevan * Algorithm :
2185aa1b14e7SSheshadri Vasudevan * Error cases are :
2186aa1b14e7SSheshadri Vasudevan * 1. If start block is lesser than or equal to the end block
2187aa1b14e7SSheshadri Vasudevan * 2. If either start block or end block is beyond the bounadry
2188aa1b14e7SSheshadri Vasudevan * of the extended partition.
2189aa1b14e7SSheshadri Vasudevan * 3. start or end block overlap with existing partitions.
2190aa1b14e7SSheshadri Vasudevan * To check this, first make sure that the start block doesnt
2191aa1b14e7SSheshadri Vasudevan * overlap with existing partitions. Then, calculate the
2192aa1b14e7SSheshadri Vasudevan * possible end block for the given start block that doesnt
2193aa1b14e7SSheshadri Vasudevan * overlap with existing partitions. This can be calculated by
2194aa1b14e7SSheshadri Vasudevan * first setting the possible end block to the end of the
2195aa1b14e7SSheshadri Vasudevan * extended partition (optimistic) and then, checking if there
2196aa1b14e7SSheshadri Vasudevan * is any other partition that lies after the start of the
2197aa1b14e7SSheshadri Vasudevan * partition being validated. If so, set the possible end to
2198aa1b14e7SSheshadri Vasudevan * one block less than the beginning of the next nearest partition
2199aa1b14e7SSheshadri Vasudevan * If the actual end block is greater than the calculated end
2200aa1b14e7SSheshadri Vasudevan * block, we have an overlap.
2201aa1b14e7SSheshadri Vasudevan *
2202aa1b14e7SSheshadri Vasudevan */
2203aa1b14e7SSheshadri Vasudevan static int
2204aa1b14e7SSheshadri Vasudevan cmlb_validate_ext_part(struct cmlb_lun *cl, int part, int epart, uint32_t start,
2205aa1b14e7SSheshadri Vasudevan uint32_t size)
2206aa1b14e7SSheshadri Vasudevan {
2207aa1b14e7SSheshadri Vasudevan int i;
2208aa1b14e7SSheshadri Vasudevan uint32_t end = start + size - 1;
2209aa1b14e7SSheshadri Vasudevan uint32_t ext_start = cl->cl_fmap[part].fmap_start;
2210aa1b14e7SSheshadri Vasudevan uint32_t ext_end = ext_start + cl->cl_fmap[part].fmap_nblk - 1;
2211aa1b14e7SSheshadri Vasudevan uint32_t ts, te;
2212aa1b14e7SSheshadri Vasudevan uint32_t poss_end = ext_end;
2213aa1b14e7SSheshadri Vasudevan
2214aa1b14e7SSheshadri Vasudevan if (end <= start) {
2215aa1b14e7SSheshadri Vasudevan return (1);
2216aa1b14e7SSheshadri Vasudevan }
2217aa1b14e7SSheshadri Vasudevan
2218aa1b14e7SSheshadri Vasudevan /*
2219aa1b14e7SSheshadri Vasudevan * Check if the logical drive boundaries are within that of the
2220aa1b14e7SSheshadri Vasudevan * extended partition.
2221aa1b14e7SSheshadri Vasudevan */
2222aa1b14e7SSheshadri Vasudevan if (start <= ext_start || start > ext_end || end <= ext_start ||
2223aa1b14e7SSheshadri Vasudevan end > ext_end) {
2224aa1b14e7SSheshadri Vasudevan return (1);
2225aa1b14e7SSheshadri Vasudevan }
2226aa1b14e7SSheshadri Vasudevan
2227aa1b14e7SSheshadri Vasudevan /*
2228aa1b14e7SSheshadri Vasudevan * epart will be equal to FD_NUMPART if it is the first logical drive.
2229aa1b14e7SSheshadri Vasudevan * There is no need to check for overlaps with other logical drives,
2230aa1b14e7SSheshadri Vasudevan * since it is the only logical drive that we have come across so far.
2231aa1b14e7SSheshadri Vasudevan */
2232aa1b14e7SSheshadri Vasudevan if (epart == FD_NUMPART) {
2233aa1b14e7SSheshadri Vasudevan return (0);
2234aa1b14e7SSheshadri Vasudevan }
2235aa1b14e7SSheshadri Vasudevan
2236aa1b14e7SSheshadri Vasudevan /* Check for overlaps with existing logical drives */
2237aa1b14e7SSheshadri Vasudevan i = FD_NUMPART;
2238aa1b14e7SSheshadri Vasudevan ts = cl->cl_fmap[FD_NUMPART].fmap_start;
2239aa1b14e7SSheshadri Vasudevan te = ts + cl->cl_fmap[FD_NUMPART].fmap_nblk - 1;
2240aa1b14e7SSheshadri Vasudevan
2241aa1b14e7SSheshadri Vasudevan while ((i < epart) && ts && te) {
2242aa1b14e7SSheshadri Vasudevan if (start >= ts && start <= te) {
2243aa1b14e7SSheshadri Vasudevan return (1);
2244aa1b14e7SSheshadri Vasudevan }
2245aa1b14e7SSheshadri Vasudevan
2246aa1b14e7SSheshadri Vasudevan if ((ts < poss_end) && (ts > start)) {
2247aa1b14e7SSheshadri Vasudevan poss_end = ts - 1;
2248aa1b14e7SSheshadri Vasudevan }
2249aa1b14e7SSheshadri Vasudevan
2250aa1b14e7SSheshadri Vasudevan i++;
2251aa1b14e7SSheshadri Vasudevan ts = cl->cl_fmap[i].fmap_start;
2252aa1b14e7SSheshadri Vasudevan te = ts + cl->cl_fmap[i].fmap_nblk - 1;
2253aa1b14e7SSheshadri Vasudevan }
2254aa1b14e7SSheshadri Vasudevan
2255aa1b14e7SSheshadri Vasudevan if (end > poss_end) {
2256aa1b14e7SSheshadri Vasudevan return (1);
2257aa1b14e7SSheshadri Vasudevan }
2258aa1b14e7SSheshadri Vasudevan
2259aa1b14e7SSheshadri Vasudevan return (0);
2260aa1b14e7SSheshadri Vasudevan }
2261aa1b14e7SSheshadri Vasudevan
2262aa1b14e7SSheshadri Vasudevan
2263aa1b14e7SSheshadri Vasudevan /*
2264aa1b14e7SSheshadri Vasudevan * Function: cmlb_is_linux_swap
2265aa1b14e7SSheshadri Vasudevan *
2266aa1b14e7SSheshadri Vasudevan * Description: utility routine to verify if a partition is a linux swap
2267aa1b14e7SSheshadri Vasudevan * partition or not.
2268aa1b14e7SSheshadri Vasudevan *
2269aa1b14e7SSheshadri Vasudevan * Arguments:
2270aa1b14e7SSheshadri Vasudevan * cl driver soft state (unit) structure
2271aa1b14e7SSheshadri Vasudevan * part_start absolute sector number of the start of the partition
2272aa1b14e7SSheshadri Vasudevan * being verified
2273aa1b14e7SSheshadri Vasudevan * tg_cookie cookie from target driver to be passed back to target
2274aa1b14e7SSheshadri Vasudevan * driver when we call back to it through tg_ops.
2275aa1b14e7SSheshadri Vasudevan *
2276aa1b14e7SSheshadri Vasudevan * Return Code: 0 for success
2277aa1b14e7SSheshadri Vasudevan *
2278aa1b14e7SSheshadri Vasudevan * Context: User and Kernel thread
2279aa1b14e7SSheshadri Vasudevan *
2280aa1b14e7SSheshadri Vasudevan * Notes:
2281aa1b14e7SSheshadri Vasudevan * The linux swap magic "SWAP-SPACE" or "SWAPSPACE2" is found as the
2282aa1b14e7SSheshadri Vasudevan * last 10 bytes of a disk block whose size is that of the linux page
2283aa1b14e7SSheshadri Vasudevan * size. This disk block is found at the beginning of the swap partition.
2284aa1b14e7SSheshadri Vasudevan */
2285aa1b14e7SSheshadri Vasudevan static int
2286aa1b14e7SSheshadri Vasudevan cmlb_is_linux_swap(struct cmlb_lun *cl, uint32_t part_start, void *tg_cookie)
2287aa1b14e7SSheshadri Vasudevan {
2288aa1b14e7SSheshadri Vasudevan int i;
2289aa1b14e7SSheshadri Vasudevan int rval = -1;
2290aa1b14e7SSheshadri Vasudevan uint32_t seek_offset;
2291aa1b14e7SSheshadri Vasudevan uint32_t linux_pg_size;
2292531d0b66SToomas Soome char *buf, *linux_swap_magic;
2293aa1b14e7SSheshadri Vasudevan int sec_sz = cl->cl_sys_blocksize;
2294aa1b14e7SSheshadri Vasudevan /* Known linux kernel page sizes */
2295aa1b14e7SSheshadri Vasudevan uint32_t linux_pg_size_arr[] = {4096, };
2296aa1b14e7SSheshadri Vasudevan
2297aa1b14e7SSheshadri Vasudevan ASSERT(cl != NULL);
2298aa1b14e7SSheshadri Vasudevan ASSERT(mutex_owned(CMLB_MUTEX(cl)));
2299aa1b14e7SSheshadri Vasudevan
2300aa1b14e7SSheshadri Vasudevan if ((buf = kmem_zalloc(sec_sz, KM_NOSLEEP)) == NULL) {
2301aa1b14e7SSheshadri Vasudevan return (ENOMEM);
2302aa1b14e7SSheshadri Vasudevan }
2303aa1b14e7SSheshadri Vasudevan
2304e998e519SSheshadri Vasudevan /*
2305e998e519SSheshadri Vasudevan * Check if there is a sane Solaris VTOC
2306e998e519SSheshadri Vasudevan * If there is a valid vtoc, no need to lookup
2307e998e519SSheshadri Vasudevan * for the linux swap signature.
2308e998e519SSheshadri Vasudevan */
2309e998e519SSheshadri Vasudevan mutex_exit(CMLB_MUTEX(cl));
2310e998e519SSheshadri Vasudevan rval = DK_TG_READ(cl, buf, part_start + DK_LABEL_LOC,
2311e998e519SSheshadri Vasudevan sec_sz, tg_cookie);
2312e998e519SSheshadri Vasudevan mutex_enter(CMLB_MUTEX(cl));
2313e998e519SSheshadri Vasudevan if (rval != 0) {
2314e998e519SSheshadri Vasudevan cmlb_dbg(CMLB_ERROR, cl,
2315e998e519SSheshadri Vasudevan "cmlb_is_linux_swap: disk vtoc read err\n");
2316e998e519SSheshadri Vasudevan rval = EIO;
2317e998e519SSheshadri Vasudevan goto done;
2318e998e519SSheshadri Vasudevan }
2319e998e519SSheshadri Vasudevan
2320e998e519SSheshadri Vasudevan if ((((struct dk_label *)buf)->dkl_magic == DKL_MAGIC) &&
2321e998e519SSheshadri Vasudevan (((struct dk_label *)buf)->dkl_vtoc.v_sanity == VTOC_SANE)) {
2322e998e519SSheshadri Vasudevan rval = -1;
2323e998e519SSheshadri Vasudevan goto done;
2324e998e519SSheshadri Vasudevan }
2325e998e519SSheshadri Vasudevan
2326e998e519SSheshadri Vasudevan
2327e998e519SSheshadri Vasudevan /* No valid vtoc, so check for linux swap signature */
2328aa1b14e7SSheshadri Vasudevan linux_swap_magic = buf + sec_sz - 10;
2329aa1b14e7SSheshadri Vasudevan
2330aa1b14e7SSheshadri Vasudevan for (i = 0; i < sizeof (linux_pg_size_arr)/sizeof (uint32_t); i++) {
2331aa1b14e7SSheshadri Vasudevan linux_pg_size = linux_pg_size_arr[i];
2332aa1b14e7SSheshadri Vasudevan seek_offset = linux_pg_size/sec_sz - 1;
2333aa1b14e7SSheshadri Vasudevan seek_offset += part_start;
2334aa1b14e7SSheshadri Vasudevan
2335aa1b14e7SSheshadri Vasudevan mutex_exit(CMLB_MUTEX(cl));
2336aa1b14e7SSheshadri Vasudevan rval = DK_TG_READ(cl, buf, seek_offset, sec_sz, tg_cookie);
2337aa1b14e7SSheshadri Vasudevan mutex_enter(CMLB_MUTEX(cl));
2338aa1b14e7SSheshadri Vasudevan
2339aa1b14e7SSheshadri Vasudevan if (rval != 0) {
2340aa1b14e7SSheshadri Vasudevan cmlb_dbg(CMLB_ERROR, cl,
2341aa1b14e7SSheshadri Vasudevan "cmlb_is_linux_swap: disk read err\n");
2342aa1b14e7SSheshadri Vasudevan rval = EIO;
2343aa1b14e7SSheshadri Vasudevan break;
2344aa1b14e7SSheshadri Vasudevan }
2345aa1b14e7SSheshadri Vasudevan
2346aa1b14e7SSheshadri Vasudevan rval = -1;
2347aa1b14e7SSheshadri Vasudevan
2348aa1b14e7SSheshadri Vasudevan if ((strncmp(linux_swap_magic, "SWAP-SPACE", 10) == 0) ||
2349aa1b14e7SSheshadri Vasudevan (strncmp(linux_swap_magic, "SWAPSPACE2", 10) == 0)) {
2350aa1b14e7SSheshadri Vasudevan /* Found a linux swap */
2351aa1b14e7SSheshadri Vasudevan rval = 0;
2352aa1b14e7SSheshadri Vasudevan break;
2353aa1b14e7SSheshadri Vasudevan }
2354aa1b14e7SSheshadri Vasudevan }
2355aa1b14e7SSheshadri Vasudevan
2356e998e519SSheshadri Vasudevan done:
2357aa1b14e7SSheshadri Vasudevan kmem_free(buf, sec_sz);
2358aa1b14e7SSheshadri Vasudevan return (rval);
2359aa1b14e7SSheshadri Vasudevan }
2360aa1b14e7SSheshadri Vasudevan #endif
2361aa1b14e7SSheshadri Vasudevan
23623ccda647Slclee /*
23633ccda647Slclee * Function: cmlb_read_fdisk
23643ccda647Slclee *
23653ccda647Slclee * Description: utility routine to read the fdisk table.
23663ccda647Slclee *
2367e8fb11a1Sshidokht * Arguments:
2368e8fb11a1Sshidokht * cl driver soft state (unit) structure
2369e8fb11a1Sshidokht * capacity disk capacity in #blocks
2370e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
2371e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
23723ccda647Slclee *
23733ccda647Slclee * Return Code: 0 for success (includes not reading for no_fdisk_present case
23743ccda647Slclee * errnos from tg_rw if failed to read the first block.
23753ccda647Slclee *
23763ccda647Slclee * Context: Kernel thread only (can sleep).
23773ccda647Slclee */
2378e8fb11a1Sshidokht /*ARGSUSED*/
23793ccda647Slclee static int
2380e8fb11a1Sshidokht cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity, void *tg_cookie)
23813ccda647Slclee {
23823ccda647Slclee #if defined(_NO_FDISK_PRESENT)
23833ccda647Slclee
2384e8fb11a1Sshidokht cl->cl_solaris_offset = 0;
2385e8fb11a1Sshidokht cl->cl_solaris_size = capacity;
2386e8fb11a1Sshidokht bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
23873ccda647Slclee return (0);
23883ccda647Slclee
23893ccda647Slclee #elif defined(_FIRMWARE_NEEDS_FDISK)
23903ccda647Slclee
23913ccda647Slclee struct ipart *fdp;
23923ccda647Slclee struct mboot *mbp;
23933ccda647Slclee struct ipart fdisk[FD_NUMPART];
2394aa1b14e7SSheshadri Vasudevan int i, k;
23953ccda647Slclee char sigbuf[2];
23963ccda647Slclee caddr_t bufp;
23973ccda647Slclee int uidx;
2398531d0b66SToomas Soome int rval;
23993ccda647Slclee int lba = 0;
24003ccda647Slclee uint_t solaris_offset; /* offset to solaris part. */
24013ccda647Slclee daddr_t solaris_size; /* size of solaris partition */
24023ccda647Slclee uint32_t blocksize;
240386ef0a63SRichard Lowe #if defined(__x86)
2404aa1b14e7SSheshadri Vasudevan struct ipart eparts[2];
2405aa1b14e7SSheshadri Vasudevan struct ipart *efdp1 = &eparts[0];
2406aa1b14e7SSheshadri Vasudevan struct ipart *efdp2 = &eparts[1];
2407aa1b14e7SSheshadri Vasudevan int ext_part_exists = 0;
2408aa1b14e7SSheshadri Vasudevan int ld_count = 0;
2409aa1b14e7SSheshadri Vasudevan #endif
24103ccda647Slclee
2411e8fb11a1Sshidokht ASSERT(cl != NULL);
2412e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
24133ccda647Slclee
24143ccda647Slclee /*
24153ccda647Slclee * Start off assuming no fdisk table
24163ccda647Slclee */
24173ccda647Slclee solaris_offset = 0;
24183ccda647Slclee solaris_size = capacity;
24193ccda647Slclee
2420e8fb11a1Sshidokht blocksize = cl->cl_tgt_blocksize;
24213ccda647Slclee
24223ccda647Slclee bufp = kmem_zalloc(blocksize, KM_SLEEP);
24233ccda647Slclee
2424e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
2425e8fb11a1Sshidokht rval = DK_TG_READ(cl, bufp, 0, blocksize, tg_cookie);
2426e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
24273ccda647Slclee
24283ccda647Slclee if (rval != 0) {
2429e8fb11a1Sshidokht cmlb_dbg(CMLB_ERROR, cl,
24303ccda647Slclee "cmlb_read_fdisk: fdisk read err\n");
2431e8fb11a1Sshidokht bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
2432e8fb11a1Sshidokht goto done;
24333ccda647Slclee }
24343ccda647Slclee
24353ccda647Slclee mbp = (struct mboot *)bufp;
24363ccda647Slclee
24373ccda647Slclee /*
24383ccda647Slclee * The fdisk table does not begin on a 4-byte boundary within the
24393ccda647Slclee * master boot record, so we copy it to an aligned structure to avoid
24403ccda647Slclee * alignment exceptions on some processors.
24413ccda647Slclee */
24423ccda647Slclee bcopy(&mbp->parts[0], fdisk, sizeof (fdisk));
24433ccda647Slclee
24443ccda647Slclee /*
24453ccda647Slclee * Check for lba support before verifying sig; sig might not be
24463ccda647Slclee * there, say on a blank disk, but the max_chs mark may still
24473ccda647Slclee * be present.
24483ccda647Slclee *
24493ccda647Slclee * Note: LBA support and BEFs are an x86-only concept but this
24503ccda647Slclee * code should work OK on SPARC as well.
24513ccda647Slclee */
24523ccda647Slclee
24533ccda647Slclee /*
24543ccda647Slclee * First, check for lba-access-ok on root node (or prom root node)
24553ccda647Slclee * if present there, don't need to search fdisk table.
24563ccda647Slclee */
24573ccda647Slclee if (ddi_getprop(DDI_DEV_T_ANY, ddi_root_node(), 0,
24583ccda647Slclee "lba-access-ok", 0) != 0) {
24593ccda647Slclee /* All drives do LBA; don't search fdisk table */
24603ccda647Slclee lba = 1;
24613ccda647Slclee } else {
24623ccda647Slclee /* Okay, look for mark in fdisk table */
24633ccda647Slclee for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) {
24643ccda647Slclee /* accumulate "lba" value from all partitions */
24653ccda647Slclee lba = (lba || cmlb_has_max_chs_vals(fdp));
24663ccda647Slclee }
24673ccda647Slclee }
24683ccda647Slclee
24693ccda647Slclee if (lba != 0) {
2470e8fb11a1Sshidokht dev_t dev = cmlb_make_device(cl);
24713ccda647Slclee
2472e8fb11a1Sshidokht if (ddi_getprop(dev, CMLB_DEVINFO(cl), DDI_PROP_DONTPASS,
24733ccda647Slclee "lba-access-ok", 0) == 0) {
24743ccda647Slclee /* not found; create it */
2475e8fb11a1Sshidokht if (ddi_prop_create(dev, CMLB_DEVINFO(cl), 0,
24763ccda647Slclee "lba-access-ok", (caddr_t)NULL, 0) !=
24773ccda647Slclee DDI_PROP_SUCCESS) {
2478e8fb11a1Sshidokht cmlb_dbg(CMLB_ERROR, cl,
24793ccda647Slclee "cmlb_read_fdisk: Can't create lba "
24803ccda647Slclee "property for instance %d\n",
2481e8fb11a1Sshidokht ddi_get_instance(CMLB_DEVINFO(cl)));
24823ccda647Slclee }
24833ccda647Slclee }
24843ccda647Slclee }
24853ccda647Slclee
24863ccda647Slclee bcopy(&mbp->signature, sigbuf, sizeof (sigbuf));
24873ccda647Slclee
24883ccda647Slclee /*
24893ccda647Slclee * Endian-independent signature check
24903ccda647Slclee */
24913ccda647Slclee if (((sigbuf[1] & 0xFF) != ((MBB_MAGIC >> 8) & 0xFF)) ||
24923ccda647Slclee (sigbuf[0] != (MBB_MAGIC & 0xFF))) {
2493e8fb11a1Sshidokht cmlb_dbg(CMLB_ERROR, cl,
24943ccda647Slclee "cmlb_read_fdisk: no fdisk\n");
2495e8fb11a1Sshidokht bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
24963ccda647Slclee goto done;
24973ccda647Slclee }
24983ccda647Slclee
24993ccda647Slclee #ifdef CMLBDEBUG
2500e8fb11a1Sshidokht if (cmlb_level_mask & CMLB_LOGMASK_INFO) {
25013ccda647Slclee fdp = fdisk;
2502e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl, "cmlb_read_fdisk:\n");
2503e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl, " relsect "
25043ccda647Slclee "numsect sysid bootid\n");
25053ccda647Slclee for (i = 0; i < FD_NUMPART; i++, fdp++) {
2506e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl,
25073ccda647Slclee " %d: %8d %8d 0x%08x 0x%08x\n",
25083ccda647Slclee i, fdp->relsect, fdp->numsect,
25093ccda647Slclee fdp->systid, fdp->bootid);
25103ccda647Slclee }
25113ccda647Slclee }
25123ccda647Slclee #endif
25133ccda647Slclee
25143ccda647Slclee /*
25153ccda647Slclee * Try to find the unix partition
25163ccda647Slclee */
25173ccda647Slclee uidx = -1;
25183ccda647Slclee solaris_offset = 0;
25193ccda647Slclee solaris_size = 0;
25203ccda647Slclee
25213ccda647Slclee for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) {
2522342440ecSPrasad Singamsetty uint32_t relsect;
2523342440ecSPrasad Singamsetty uint32_t numsect;
2524aa1b14e7SSheshadri Vasudevan uchar_t systid;
252586ef0a63SRichard Lowe #if defined(__x86)
2526aa1b14e7SSheshadri Vasudevan /*
2527aa1b14e7SSheshadri Vasudevan * Stores relative block offset from the beginning of the
2528aa1b14e7SSheshadri Vasudevan * Extended Partition.
2529aa1b14e7SSheshadri Vasudevan */
2530aa1b14e7SSheshadri Vasudevan int ext_relsect = 0;
2531aa1b14e7SSheshadri Vasudevan #endif
25323ccda647Slclee
25333ccda647Slclee if (fdp->numsect == 0) {
2534e8fb11a1Sshidokht cl->cl_fmap[i].fmap_start = 0;
2535e8fb11a1Sshidokht cl->cl_fmap[i].fmap_nblk = 0;
25363ccda647Slclee continue;
25373ccda647Slclee }
25383ccda647Slclee
25393ccda647Slclee /*
25403ccda647Slclee * Data in the fdisk table is little-endian.
25413ccda647Slclee */
25423ccda647Slclee relsect = LE_32(fdp->relsect);
25433ccda647Slclee numsect = LE_32(fdp->numsect);
25443ccda647Slclee
2545e8fb11a1Sshidokht cl->cl_fmap[i].fmap_start = relsect;
2546e8fb11a1Sshidokht cl->cl_fmap[i].fmap_nblk = numsect;
2547aa1b14e7SSheshadri Vasudevan cl->cl_fmap[i].fmap_systid = LE_8(fdp->systid);
2548aa1b14e7SSheshadri Vasudevan
254986ef0a63SRichard Lowe #if defined(__x86)
2550aa1b14e7SSheshadri Vasudevan /* Support only one extended partition per LUN */
2551aa1b14e7SSheshadri Vasudevan if ((fdp->systid == EXTDOS || fdp->systid == FDISK_EXTLBA) &&
2552aa1b14e7SSheshadri Vasudevan (ext_part_exists == 0)) {
2553aa1b14e7SSheshadri Vasudevan int j;
2554aa1b14e7SSheshadri Vasudevan uint32_t logdrive_offset;
2555aa1b14e7SSheshadri Vasudevan uint32_t ext_numsect;
2556aa1b14e7SSheshadri Vasudevan uint32_t abs_secnum;
2557aa1b14e7SSheshadri Vasudevan
2558aa1b14e7SSheshadri Vasudevan ext_part_exists = 1;
2559aa1b14e7SSheshadri Vasudevan
2560aa1b14e7SSheshadri Vasudevan for (j = FD_NUMPART; j < FDISK_PARTS; j++) {
2561aa1b14e7SSheshadri Vasudevan mutex_exit(CMLB_MUTEX(cl));
2562aa1b14e7SSheshadri Vasudevan rval = DK_TG_READ(cl, bufp,
2563aa1b14e7SSheshadri Vasudevan (relsect + ext_relsect), blocksize,
2564aa1b14e7SSheshadri Vasudevan tg_cookie);
2565aa1b14e7SSheshadri Vasudevan mutex_enter(CMLB_MUTEX(cl));
2566aa1b14e7SSheshadri Vasudevan
2567aa1b14e7SSheshadri Vasudevan if (rval != 0) {
2568aa1b14e7SSheshadri Vasudevan cmlb_dbg(CMLB_ERROR, cl,
2569aa1b14e7SSheshadri Vasudevan "cmlb_read_fdisk: Extended "
2570aa1b14e7SSheshadri Vasudevan "partition read err\n");
2571aa1b14e7SSheshadri Vasudevan goto done;
2572aa1b14e7SSheshadri Vasudevan }
2573aa1b14e7SSheshadri Vasudevan /*
2574aa1b14e7SSheshadri Vasudevan * The first ipart entry provides the offset
2575aa1b14e7SSheshadri Vasudevan * at which the logical drive starts off from
2576aa1b14e7SSheshadri Vasudevan * the beginning of the container partition
2577aa1b14e7SSheshadri Vasudevan * and the size of the logical drive.
2578aa1b14e7SSheshadri Vasudevan * The second ipart entry provides the offset
2579aa1b14e7SSheshadri Vasudevan * of the next container partition from the
2580aa1b14e7SSheshadri Vasudevan * beginning of the extended partition.
2581aa1b14e7SSheshadri Vasudevan */
2582aa1b14e7SSheshadri Vasudevan bcopy(&bufp[FDISK_PART_TABLE_START], eparts,
2583aa1b14e7SSheshadri Vasudevan sizeof (eparts));
2584aa1b14e7SSheshadri Vasudevan logdrive_offset = LE_32(efdp1->relsect);
2585aa1b14e7SSheshadri Vasudevan ext_numsect = LE_32(efdp1->numsect);
2586aa1b14e7SSheshadri Vasudevan systid = LE_8(efdp1->systid);
2587aa1b14e7SSheshadri Vasudevan if (logdrive_offset <= 0 || ext_numsect <= 0)
2588aa1b14e7SSheshadri Vasudevan break;
2589aa1b14e7SSheshadri Vasudevan abs_secnum = relsect + ext_relsect +
2590aa1b14e7SSheshadri Vasudevan logdrive_offset;
2591aa1b14e7SSheshadri Vasudevan
2592aa1b14e7SSheshadri Vasudevan /* Boundary condition and overlap checking */
2593aa1b14e7SSheshadri Vasudevan if (cmlb_validate_ext_part(cl, i, j, abs_secnum,
2594aa1b14e7SSheshadri Vasudevan ext_numsect)) {
2595aa1b14e7SSheshadri Vasudevan break;
2596aa1b14e7SSheshadri Vasudevan }
2597aa1b14e7SSheshadri Vasudevan
2598aa1b14e7SSheshadri Vasudevan if ((cl->cl_fmap[j].fmap_start != abs_secnum) ||
2599aa1b14e7SSheshadri Vasudevan (cl->cl_fmap[j].fmap_nblk != ext_numsect) ||
2600aa1b14e7SSheshadri Vasudevan (cl->cl_fmap[j].fmap_systid != systid)) {
2601aa1b14e7SSheshadri Vasudevan /*
2602aa1b14e7SSheshadri Vasudevan * Indicates change from previous
2603aa1b14e7SSheshadri Vasudevan * partinfo. Need to recreate
2604aa1b14e7SSheshadri Vasudevan * logical device nodes.
2605aa1b14e7SSheshadri Vasudevan */
2606aa1b14e7SSheshadri Vasudevan cl->cl_update_ext_minor_nodes = 1;
2607aa1b14e7SSheshadri Vasudevan }
2608aa1b14e7SSheshadri Vasudevan cl->cl_fmap[j].fmap_start = abs_secnum;
2609aa1b14e7SSheshadri Vasudevan cl->cl_fmap[j].fmap_nblk = ext_numsect;
2610aa1b14e7SSheshadri Vasudevan cl->cl_fmap[j].fmap_systid = systid;
2611aa1b14e7SSheshadri Vasudevan ld_count++;
2612aa1b14e7SSheshadri Vasudevan
2613e998e519SSheshadri Vasudevan if ((efdp1->systid == SUNIXOS &&
2614e998e519SSheshadri Vasudevan (cmlb_is_linux_swap(cl, abs_secnum,
2615e998e519SSheshadri Vasudevan tg_cookie) != 0)) ||
2616e998e519SSheshadri Vasudevan efdp1->systid == SUNIXOS2) {
2617e998e519SSheshadri Vasudevan if (uidx == -1) {
2618aa1b14e7SSheshadri Vasudevan uidx = 0;
2619aa1b14e7SSheshadri Vasudevan solaris_offset = abs_secnum;
2620aa1b14e7SSheshadri Vasudevan solaris_size = ext_numsect;
2621aa1b14e7SSheshadri Vasudevan }
2622aa1b14e7SSheshadri Vasudevan }
2623aa1b14e7SSheshadri Vasudevan
2624aa1b14e7SSheshadri Vasudevan if ((ext_relsect = LE_32(efdp2->relsect)) == 0)
2625aa1b14e7SSheshadri Vasudevan break;
2626aa1b14e7SSheshadri Vasudevan }
2627aa1b14e7SSheshadri Vasudevan }
2628aa1b14e7SSheshadri Vasudevan
2629aa1b14e7SSheshadri Vasudevan #endif
26303ccda647Slclee
26313ccda647Slclee if (fdp->systid != SUNIXOS &&
26323ccda647Slclee fdp->systid != SUNIXOS2 &&
26333ccda647Slclee fdp->systid != EFI_PMBR) {
26343ccda647Slclee continue;
26353ccda647Slclee }
26363ccda647Slclee
26373ccda647Slclee /*
26383ccda647Slclee * use the last active solaris partition id found
26393ccda647Slclee * (there should only be 1 active partition id)
26403ccda647Slclee *
26413ccda647Slclee * if there are no active solaris partition id
26423ccda647Slclee * then use the first inactive solaris partition id
26433ccda647Slclee */
26443ccda647Slclee if ((uidx == -1) || (fdp->bootid == ACTIVE)) {
264586ef0a63SRichard Lowe #if defined(__x86)
2646e998e519SSheshadri Vasudevan if (fdp->systid != SUNIXOS ||
2647e998e519SSheshadri Vasudevan (fdp->systid == SUNIXOS &&
2648e998e519SSheshadri Vasudevan (cmlb_is_linux_swap(cl, relsect,
2649e998e519SSheshadri Vasudevan tg_cookie) != 0))) {
2650aa1b14e7SSheshadri Vasudevan #endif
2651aa1b14e7SSheshadri Vasudevan uidx = i;
2652aa1b14e7SSheshadri Vasudevan solaris_offset = relsect;
2653aa1b14e7SSheshadri Vasudevan solaris_size = numsect;
265486ef0a63SRichard Lowe #if defined(__x86)
2655aa1b14e7SSheshadri Vasudevan }
2656aa1b14e7SSheshadri Vasudevan #endif
2657c26dc428SSheshadri Vasudevan }
2658c26dc428SSheshadri Vasudevan }
265986ef0a63SRichard Lowe #if defined(__x86)
2660aa1b14e7SSheshadri Vasudevan if (ld_count < cl->cl_logical_drive_count) {
2661aa1b14e7SSheshadri Vasudevan /*
2662aa1b14e7SSheshadri Vasudevan * Some/all logical drives were deleted. Clear out
2663aa1b14e7SSheshadri Vasudevan * the fmap entries correspoding to those deleted drives.
2664aa1b14e7SSheshadri Vasudevan */
2665aa1b14e7SSheshadri Vasudevan for (k = ld_count + FD_NUMPART;
2666aa1b14e7SSheshadri Vasudevan k < cl->cl_logical_drive_count + FD_NUMPART; k++) {
2667aa1b14e7SSheshadri Vasudevan cl->cl_fmap[k].fmap_start = 0;
2668aa1b14e7SSheshadri Vasudevan cl->cl_fmap[k].fmap_nblk = 0;
2669aa1b14e7SSheshadri Vasudevan cl->cl_fmap[k].fmap_systid = 0;
2670aa1b14e7SSheshadri Vasudevan }
2671aa1b14e7SSheshadri Vasudevan cl->cl_update_ext_minor_nodes = 1;
2672aa1b14e7SSheshadri Vasudevan }
2673aa1b14e7SSheshadri Vasudevan if (cl->cl_update_ext_minor_nodes) {
2674aa1b14e7SSheshadri Vasudevan rval = cmlb_update_ext_minor_nodes(cl, ld_count);
2675aa1b14e7SSheshadri Vasudevan if (rval != 0) {
2676aa1b14e7SSheshadri Vasudevan goto done;
2677aa1b14e7SSheshadri Vasudevan }
2678aa1b14e7SSheshadri Vasudevan }
2679aa1b14e7SSheshadri Vasudevan #endif
2680e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl, "fdisk 0x%x 0x%lx",
2681e8fb11a1Sshidokht cl->cl_solaris_offset, cl->cl_solaris_size);
26823ccda647Slclee done:
26833ccda647Slclee
26843ccda647Slclee /*
26853ccda647Slclee * Clear the VTOC info, only if the Solaris partition entry
26863ccda647Slclee * has moved, changed size, been deleted, or if the size of
26873ccda647Slclee * the partition is too small to even fit the label sector.
26883ccda647Slclee */
2689e8fb11a1Sshidokht if ((cl->cl_solaris_offset != solaris_offset) ||
2690e8fb11a1Sshidokht (cl->cl_solaris_size != solaris_size) ||
26913ccda647Slclee solaris_size <= DK_LABEL_LOC) {
2692e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl, "fdisk moved 0x%x 0x%lx",
2693e8fb11a1Sshidokht solaris_offset, solaris_size);
2694e8fb11a1Sshidokht bzero(&cl->cl_g, sizeof (struct dk_geom));
2695e8fb11a1Sshidokht bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
2696e8fb11a1Sshidokht bzero(&cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
26977f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_FALSE;
2698e8fb11a1Sshidokht }
2699e8fb11a1Sshidokht cl->cl_solaris_offset = solaris_offset;
2700e8fb11a1Sshidokht cl->cl_solaris_size = solaris_size;
27013ccda647Slclee kmem_free(bufp, blocksize);
27023ccda647Slclee return (rval);
27033ccda647Slclee
27043ccda647Slclee #else /* #elif defined(_FIRMWARE_NEEDS_FDISK) */
27053ccda647Slclee #error "fdisk table presence undetermined for this platform."
27063ccda647Slclee #endif /* #if defined(_NO_FDISK_PRESENT) */
27073ccda647Slclee }
27083ccda647Slclee
27093ccda647Slclee static void
27103ccda647Slclee cmlb_swap_efi_gpt(efi_gpt_t *e)
27113ccda647Slclee {
27123ccda647Slclee _NOTE(ASSUMING_PROTECTED(*e))
27133ccda647Slclee e->efi_gpt_Signature = LE_64(e->efi_gpt_Signature);
27143ccda647Slclee e->efi_gpt_Revision = LE_32(e->efi_gpt_Revision);
27153ccda647Slclee e->efi_gpt_HeaderSize = LE_32(e->efi_gpt_HeaderSize);
27163ccda647Slclee e->efi_gpt_HeaderCRC32 = LE_32(e->efi_gpt_HeaderCRC32);
27173ccda647Slclee e->efi_gpt_MyLBA = LE_64(e->efi_gpt_MyLBA);
27183ccda647Slclee e->efi_gpt_AlternateLBA = LE_64(e->efi_gpt_AlternateLBA);
27193ccda647Slclee e->efi_gpt_FirstUsableLBA = LE_64(e->efi_gpt_FirstUsableLBA);
27203ccda647Slclee e->efi_gpt_LastUsableLBA = LE_64(e->efi_gpt_LastUsableLBA);
27213ccda647Slclee UUID_LE_CONVERT(e->efi_gpt_DiskGUID, e->efi_gpt_DiskGUID);
27223ccda647Slclee e->efi_gpt_PartitionEntryLBA = LE_64(e->efi_gpt_PartitionEntryLBA);
27233ccda647Slclee e->efi_gpt_NumberOfPartitionEntries =
27243ccda647Slclee LE_32(e->efi_gpt_NumberOfPartitionEntries);
27253ccda647Slclee e->efi_gpt_SizeOfPartitionEntry =
27263ccda647Slclee LE_32(e->efi_gpt_SizeOfPartitionEntry);
27273ccda647Slclee e->efi_gpt_PartitionEntryArrayCRC32 =
27283ccda647Slclee LE_32(e->efi_gpt_PartitionEntryArrayCRC32);
27293ccda647Slclee }
27303ccda647Slclee
27313ccda647Slclee static void
27323ccda647Slclee cmlb_swap_efi_gpe(int nparts, efi_gpe_t *p)
27333ccda647Slclee {
27343ccda647Slclee int i;
27353ccda647Slclee
27363ccda647Slclee _NOTE(ASSUMING_PROTECTED(*p))
27373ccda647Slclee for (i = 0; i < nparts; i++) {
27383ccda647Slclee UUID_LE_CONVERT(p[i].efi_gpe_PartitionTypeGUID,
27393ccda647Slclee p[i].efi_gpe_PartitionTypeGUID);
27403ccda647Slclee p[i].efi_gpe_StartingLBA = LE_64(p[i].efi_gpe_StartingLBA);
27413ccda647Slclee p[i].efi_gpe_EndingLBA = LE_64(p[i].efi_gpe_EndingLBA);
27423ccda647Slclee /* PartitionAttrs */
27433ccda647Slclee }
27443ccda647Slclee }
27453ccda647Slclee
27463ccda647Slclee static int
27473ccda647Slclee cmlb_validate_efi(efi_gpt_t *labp)
27483ccda647Slclee {
27493ccda647Slclee if (labp->efi_gpt_Signature != EFI_SIGNATURE)
27503ccda647Slclee return (EINVAL);
2751fd797736SJohn Levon /* at least 92 bytes in this version of the spec. */
27523ccda647Slclee if (sizeof (efi_gpt_t) - sizeof (labp->efi_gpt_Reserved2) >
27533ccda647Slclee labp->efi_gpt_HeaderSize)
27543ccda647Slclee return (EINVAL);
27553ccda647Slclee /* this should be 128 bytes */
27563ccda647Slclee if (labp->efi_gpt_SizeOfPartitionEntry != sizeof (efi_gpe_t))
27573ccda647Slclee return (EINVAL);
27583ccda647Slclee return (0);
27593ccda647Slclee }
27603ccda647Slclee
2761ab92f716Sshidokht /*
27627f0b8309SEdward Pilatowicz * This function returns B_FALSE if there is a valid MBR signature and no
27637f0b8309SEdward Pilatowicz * partition table entries of type EFI_PMBR (0xEE). Otherwise it returns B_TRUE.
2764ab92f716Sshidokht *
2765ab92f716Sshidokht * The EFI spec (1.10 and later) requires having a Protective MBR (PMBR) to
2766ab92f716Sshidokht * recognize the disk as GPT partitioned. However, some other OS creates an MBR
2767ab92f716Sshidokht * where a PMBR entry is not the only one. Also, if the first block has been
2768ab92f716Sshidokht * corrupted, currently best attempt to allow data access would be to try to
2769ab92f716Sshidokht * check for GPT headers. Hence in case of more than one partition entry, but
2770ab92f716Sshidokht * at least one EFI_PMBR partition type or no valid magic number, the function
27717f0b8309SEdward Pilatowicz * returns B_TRUE to continue with looking for GPT header.
2772ab92f716Sshidokht */
2773ab92f716Sshidokht
27747f0b8309SEdward Pilatowicz static boolean_t
27757f0b8309SEdward Pilatowicz cmlb_check_efi_mbr(uchar_t *buf, boolean_t *is_mbr)
2776ab92f716Sshidokht {
2777ab92f716Sshidokht struct ipart *fdp;
2778ab92f716Sshidokht struct mboot *mbp = (struct mboot *)buf;
2779ab92f716Sshidokht struct ipart fdisk[FD_NUMPART];
2780ab92f716Sshidokht int i;
2781ab92f716Sshidokht
2782342440ecSPrasad Singamsetty if (is_mbr != NULL)
27837f0b8309SEdward Pilatowicz *is_mbr = B_TRUE;
2784342440ecSPrasad Singamsetty
2785342440ecSPrasad Singamsetty if (LE_16(mbp->signature) != MBB_MAGIC) {
2786342440ecSPrasad Singamsetty if (is_mbr != NULL)
27877f0b8309SEdward Pilatowicz *is_mbr = B_FALSE;
27887f0b8309SEdward Pilatowicz return (B_TRUE);
2789342440ecSPrasad Singamsetty }
2790ab92f716Sshidokht
2791ab92f716Sshidokht bcopy(&mbp->parts[0], fdisk, sizeof (fdisk));
2792ab92f716Sshidokht
2793ab92f716Sshidokht for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) {
2794ab92f716Sshidokht if (fdp->systid == EFI_PMBR)
27957f0b8309SEdward Pilatowicz return (B_TRUE);
2796ab92f716Sshidokht }
2797ab92f716Sshidokht
27987f0b8309SEdward Pilatowicz return (B_FALSE);
2799ab92f716Sshidokht }
2800ab92f716Sshidokht
28013ccda647Slclee static int
2802e8fb11a1Sshidokht cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags,
2803e8fb11a1Sshidokht void *tg_cookie)
28043ccda647Slclee {
28053ccda647Slclee int i;
28063ccda647Slclee int rval = 0;
28073ccda647Slclee efi_gpe_t *partitions;
28083ccda647Slclee uchar_t *buf;
28093ccda647Slclee uint_t lbasize; /* is really how much to read */
2810e8fb11a1Sshidokht diskaddr_t cap = 0;
28113ccda647Slclee uint_t nparts;
28123ccda647Slclee diskaddr_t gpe_lba;
2813af007057Syl diskaddr_t alternate_lba;
28141cec2d8cSshidokht int iofailed = 0;
2815e8fb11a1Sshidokht struct uuid uuid_type_reserved = EFI_RESERVED;
2816342440ecSPrasad Singamsetty #if defined(_FIRMWARE_NEEDS_FDISK)
2817531d0b66SToomas Soome boolean_t is_mbr;
2818342440ecSPrasad Singamsetty #endif
28193ccda647Slclee
2820e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
28213ccda647Slclee
2822e8fb11a1Sshidokht lbasize = cl->cl_sys_blocksize;
2823e8fb11a1Sshidokht
2824e8fb11a1Sshidokht cl->cl_reserved = -1;
2825e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
28263ccda647Slclee
28273ccda647Slclee buf = kmem_zalloc(EFI_MIN_ARRAY_SIZE, KM_SLEEP);
28283ccda647Slclee
2829342440ecSPrasad Singamsetty rval = DK_TG_READ(cl, buf, 0, lbasize, tg_cookie);
28303ccda647Slclee if (rval) {
28311cec2d8cSshidokht iofailed = 1;
28323ccda647Slclee goto done_err;
28333ccda647Slclee }
28343ccda647Slclee if (((struct dk_label *)buf)->dkl_magic == DKL_MAGIC) {
28353ccda647Slclee /* not ours */
28363ccda647Slclee rval = ESRCH;
28373ccda647Slclee goto done_err;
28383ccda647Slclee }
28393ccda647Slclee
2840342440ecSPrasad Singamsetty #if defined(_FIRMWARE_NEEDS_FDISK)
28417f0b8309SEdward Pilatowicz if (!cmlb_check_efi_mbr(buf, &is_mbr)) {
28427f0b8309SEdward Pilatowicz if (is_mbr)
2843342440ecSPrasad Singamsetty rval = ESRCH;
2844342440ecSPrasad Singamsetty else
2845342440ecSPrasad Singamsetty rval = EINVAL;
2846342440ecSPrasad Singamsetty goto done_err;
2847342440ecSPrasad Singamsetty }
2848342440ecSPrasad Singamsetty #else
28497f0b8309SEdward Pilatowicz if (!cmlb_check_efi_mbr(buf, NULL)) {
2850ab92f716Sshidokht rval = EINVAL;
2851ab92f716Sshidokht goto done_err;
2852ab92f716Sshidokht }
2853ab92f716Sshidokht
2854342440ecSPrasad Singamsetty #endif
2855342440ecSPrasad Singamsetty
2856e8fb11a1Sshidokht rval = DK_TG_READ(cl, buf, 1, lbasize, tg_cookie);
28573ccda647Slclee if (rval) {
28581cec2d8cSshidokht iofailed = 1;
28593ccda647Slclee goto done_err;
28603ccda647Slclee }
28613ccda647Slclee cmlb_swap_efi_gpt((efi_gpt_t *)buf);
28623ccda647Slclee
28633ccda647Slclee if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0) {
28643ccda647Slclee /*
28653ccda647Slclee * Couldn't read the primary, try the backup. Our
28663ccda647Slclee * capacity at this point could be based on CHS, so
28673ccda647Slclee * check what the device reports.
28683ccda647Slclee */
2869e8fb11a1Sshidokht rval = DK_TG_GETCAP(cl, &cap, tg_cookie);
28703ccda647Slclee if (rval) {
28711cec2d8cSshidokht iofailed = 1;
28723ccda647Slclee goto done_err;
28733ccda647Slclee }
2874e8fb11a1Sshidokht
2875e8fb11a1Sshidokht /*
2876e8fb11a1Sshidokht * CMLB_OFF_BY_ONE case, we check the next to last block first
2877e8fb11a1Sshidokht * for backup GPT header, otherwise check the last block.
2878e8fb11a1Sshidokht */
2879e8fb11a1Sshidokht
2880e8fb11a1Sshidokht if ((rval = DK_TG_READ(cl, buf,
2881e8fb11a1Sshidokht cap - ((cl->cl_alter_behavior & CMLB_OFF_BY_ONE) ? 2 : 1),
2882e8fb11a1Sshidokht lbasize, tg_cookie))
2883e8fb11a1Sshidokht != 0) {
28841cec2d8cSshidokht iofailed = 1;
28853ccda647Slclee goto done_err;
28863ccda647Slclee }
28873ccda647Slclee cmlb_swap_efi_gpt((efi_gpt_t *)buf);
2888e8fb11a1Sshidokht
2889e8fb11a1Sshidokht if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0) {
2890e8fb11a1Sshidokht
2891e8fb11a1Sshidokht if (!(cl->cl_alter_behavior & CMLB_OFF_BY_ONE))
2892e8fb11a1Sshidokht goto done_err;
2893e8fb11a1Sshidokht if ((rval = DK_TG_READ(cl, buf, cap - 1, lbasize,
2894e8fb11a1Sshidokht tg_cookie)) != 0)
2895e8fb11a1Sshidokht goto done_err;
2896e8fb11a1Sshidokht cmlb_swap_efi_gpt((efi_gpt_t *)buf);
2897e8fb11a1Sshidokht if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0)
2898e8fb11a1Sshidokht goto done_err;
2899e8fb11a1Sshidokht }
2900e8fb11a1Sshidokht if (!(flags & CMLB_SILENT))
2901e8fb11a1Sshidokht cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
2902e8fb11a1Sshidokht "primary label corrupt; using backup\n");
29033ccda647Slclee }
29043ccda647Slclee
29053ccda647Slclee nparts = ((efi_gpt_t *)buf)->efi_gpt_NumberOfPartitionEntries;
29063ccda647Slclee gpe_lba = ((efi_gpt_t *)buf)->efi_gpt_PartitionEntryLBA;
2907af007057Syl alternate_lba = ((efi_gpt_t *)buf)->efi_gpt_AlternateLBA;
29083ccda647Slclee
2909e8fb11a1Sshidokht rval = DK_TG_READ(cl, buf, gpe_lba, EFI_MIN_ARRAY_SIZE, tg_cookie);
29103ccda647Slclee if (rval) {
29111cec2d8cSshidokht iofailed = 1;
29123ccda647Slclee goto done_err;
29133ccda647Slclee }
29143ccda647Slclee partitions = (efi_gpe_t *)buf;
29153ccda647Slclee
29163ccda647Slclee if (nparts > MAXPART) {
29173ccda647Slclee nparts = MAXPART;
29183ccda647Slclee }
29193ccda647Slclee cmlb_swap_efi_gpe(nparts, partitions);
29203ccda647Slclee
2921e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
29223ccda647Slclee
29233ccda647Slclee /* Fill in partition table. */
29243ccda647Slclee for (i = 0; i < nparts; i++) {
29253ccda647Slclee if (partitions->efi_gpe_StartingLBA != 0 ||
29263ccda647Slclee partitions->efi_gpe_EndingLBA != 0) {
2927e8fb11a1Sshidokht cl->cl_map[i].dkl_cylno =
29283ccda647Slclee partitions->efi_gpe_StartingLBA;
2929e8fb11a1Sshidokht cl->cl_map[i].dkl_nblk =
29303ccda647Slclee partitions->efi_gpe_EndingLBA -
29313ccda647Slclee partitions->efi_gpe_StartingLBA + 1;
2932e8fb11a1Sshidokht cl->cl_offset[i] =
29333ccda647Slclee partitions->efi_gpe_StartingLBA;
29343ccda647Slclee }
2935e8fb11a1Sshidokht
2936e8fb11a1Sshidokht if (cl->cl_reserved == -1) {
2937e8fb11a1Sshidokht if (bcmp(&partitions->efi_gpe_PartitionTypeGUID,
2938e8fb11a1Sshidokht &uuid_type_reserved, sizeof (struct uuid)) == 0) {
2939e8fb11a1Sshidokht cl->cl_reserved = i;
2940e8fb11a1Sshidokht }
2941e8fb11a1Sshidokht }
29423ccda647Slclee if (i == WD_NODE) {
29433ccda647Slclee /*
29443ccda647Slclee * minor number 7 corresponds to the whole disk
2945af007057Syl * if the disk capacity is expanded after disk is
2946af007057Syl * labeled, minor number 7 represents the capacity
2947af007057Syl * indicated by the disk label.
29483ccda647Slclee */
2949e8fb11a1Sshidokht cl->cl_map[i].dkl_cylno = 0;
2950af007057Syl if (alternate_lba == 1) {
2951af007057Syl /*
2952af007057Syl * We are using backup label. Since we can
2953af007057Syl * find a valid label at the end of disk,
2954af007057Syl * the disk capacity is not expanded.
2955af007057Syl */
2956af007057Syl cl->cl_map[i].dkl_nblk = capacity;
2957af007057Syl } else {
2958af007057Syl cl->cl_map[i].dkl_nblk = alternate_lba + 1;
2959af007057Syl }
2960e8fb11a1Sshidokht cl->cl_offset[i] = 0;
29613ccda647Slclee }
29623ccda647Slclee partitions++;
29633ccda647Slclee }
2964e8fb11a1Sshidokht cl->cl_solaris_offset = 0;
2965e8fb11a1Sshidokht cl->cl_solaris_size = capacity;
2966342440ecSPrasad Singamsetty cl->cl_label_from_media = CMLB_LABEL_EFI;
29677f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_TRUE;
2968e8fb11a1Sshidokht
2969e8fb11a1Sshidokht /* clear the vtoc label */
2970e8fb11a1Sshidokht bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
2971e8fb11a1Sshidokht
29723ccda647Slclee kmem_free(buf, EFI_MIN_ARRAY_SIZE);
29733ccda647Slclee return (0);
29743ccda647Slclee
29753ccda647Slclee done_err:
29763ccda647Slclee kmem_free(buf, EFI_MIN_ARRAY_SIZE);
2977e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
2978e8fb11a1Sshidokht done_err1:
29793ccda647Slclee /*
29803ccda647Slclee * if we didn't find something that could look like a VTOC
29813ccda647Slclee * and the disk is over 1TB, we know there isn't a valid label.
29823ccda647Slclee * Otherwise let cmlb_uselabel decide what to do. We only
29833ccda647Slclee * want to invalidate this if we're certain the label isn't
29843ccda647Slclee * valid because cmlb_prop_op will now fail, which in turn
29853ccda647Slclee * causes things like opens and stats on the partition to fail.
29863ccda647Slclee */
2987342440ecSPrasad Singamsetty if ((capacity > CMLB_EXTVTOC_LIMIT) && (rval != ESRCH) && !iofailed) {
29887f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_FALSE;
29893ccda647Slclee }
29903ccda647Slclee return (rval);
29913ccda647Slclee }
29923ccda647Slclee
29933ccda647Slclee
29943ccda647Slclee /*
29953ccda647Slclee * Function: cmlb_uselabel
29963ccda647Slclee *
29973ccda647Slclee * Description: Validate the disk label and update the relevant data (geometry,
29983ccda647Slclee * partition, vtoc, and capacity data) in the cmlb_lun struct.
29993ccda647Slclee * Marks the geometry of the unit as being valid.
30003ccda647Slclee *
3001e8fb11a1Sshidokht * Arguments: cl: unit struct.
30023ccda647Slclee * dk_label: disk label
30033ccda647Slclee *
30043ccda647Slclee * Return Code: CMLB_LABEL_IS_VALID: Label read from disk is OK; geometry,
30053ccda647Slclee * partition, vtoc, and capacity data are good.
30063ccda647Slclee *
30073ccda647Slclee * CMLB_LABEL_IS_INVALID: Magic number or checksum error in the
30083ccda647Slclee * label; or computed capacity does not jibe with capacity
30093ccda647Slclee * reported from the READ CAPACITY command.
30103ccda647Slclee *
30113ccda647Slclee * Context: Kernel thread only (can sleep).
30123ccda647Slclee */
30133ccda647Slclee static int
3014e8fb11a1Sshidokht cmlb_uselabel(struct cmlb_lun *cl, struct dk_label *labp, int flags)
30153ccda647Slclee {
30163ccda647Slclee short *sp;
30173ccda647Slclee short sum;
30183ccda647Slclee short count;
30193ccda647Slclee int label_error = CMLB_LABEL_IS_VALID;
30203ccda647Slclee int i;
30213ccda647Slclee diskaddr_t label_capacity;
3022342440ecSPrasad Singamsetty uint32_t part_end;
30233ccda647Slclee diskaddr_t track_capacity;
30243ccda647Slclee #if defined(_SUNOS_VTOC_16)
30253ccda647Slclee struct dkl_partition *vpartp;
30263ccda647Slclee #endif
3027e8fb11a1Sshidokht ASSERT(cl != NULL);
3028e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
30293ccda647Slclee
30303ccda647Slclee /* Validate the magic number of the label. */
30313ccda647Slclee if (labp->dkl_magic != DKL_MAGIC) {
30323ccda647Slclee #if defined(__sparc)
3033e8fb11a1Sshidokht if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
3034e8fb11a1Sshidokht if (!(flags & CMLB_SILENT))
3035e8fb11a1Sshidokht cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
3036e8fb11a1Sshidokht CE_WARN,
3037e8fb11a1Sshidokht "Corrupt label; wrong magic number\n");
30383ccda647Slclee }
30393ccda647Slclee #endif
30403ccda647Slclee return (CMLB_LABEL_IS_INVALID);
30413ccda647Slclee }
30423ccda647Slclee
30433ccda647Slclee /* Validate the checksum of the label. */
30443ccda647Slclee sp = (short *)labp;
30453ccda647Slclee sum = 0;
30463ccda647Slclee count = sizeof (struct dk_label) / sizeof (short);
30473ccda647Slclee while (count--) {
30483ccda647Slclee sum ^= *sp++;
30493ccda647Slclee }
30503ccda647Slclee
30513ccda647Slclee if (sum != 0) {
30523ccda647Slclee #if defined(_SUNOS_VTOC_16)
3053e8fb11a1Sshidokht if (!ISCD(cl)) {
30543ccda647Slclee #elif defined(_SUNOS_VTOC_8)
3055e8fb11a1Sshidokht if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
30563ccda647Slclee #endif
3057e8fb11a1Sshidokht if (!(flags & CMLB_SILENT))
3058e8fb11a1Sshidokht cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
3059e8fb11a1Sshidokht CE_WARN,
3060e8fb11a1Sshidokht "Corrupt label - label checksum failed\n");
30613ccda647Slclee }
30623ccda647Slclee return (CMLB_LABEL_IS_INVALID);
30633ccda647Slclee }
30643ccda647Slclee
30653ccda647Slclee
30663ccda647Slclee /*
30673ccda647Slclee * Fill in geometry structure with data from label.
30683ccda647Slclee */
3069e8fb11a1Sshidokht bzero(&cl->cl_g, sizeof (struct dk_geom));
3070e8fb11a1Sshidokht cl->cl_g.dkg_ncyl = labp->dkl_ncyl;
3071e8fb11a1Sshidokht cl->cl_g.dkg_acyl = labp->dkl_acyl;
3072e8fb11a1Sshidokht cl->cl_g.dkg_bcyl = 0;
3073e8fb11a1Sshidokht cl->cl_g.dkg_nhead = labp->dkl_nhead;
3074e8fb11a1Sshidokht cl->cl_g.dkg_nsect = labp->dkl_nsect;
3075e8fb11a1Sshidokht cl->cl_g.dkg_intrlv = labp->dkl_intrlv;
30763ccda647Slclee
30773ccda647Slclee #if defined(_SUNOS_VTOC_8)
3078e8fb11a1Sshidokht cl->cl_g.dkg_gap1 = labp->dkl_gap1;
3079e8fb11a1Sshidokht cl->cl_g.dkg_gap2 = labp->dkl_gap2;
3080e8fb11a1Sshidokht cl->cl_g.dkg_bhead = labp->dkl_bhead;
30813ccda647Slclee #endif
30823ccda647Slclee #if defined(_SUNOS_VTOC_16)
3083e8fb11a1Sshidokht cl->cl_dkg_skew = labp->dkl_skew;
30843ccda647Slclee #endif
30853ccda647Slclee
308686ef0a63SRichard Lowe #if defined(__x86)
3087e8fb11a1Sshidokht cl->cl_g.dkg_apc = labp->dkl_apc;
30883ccda647Slclee #endif
30893ccda647Slclee
30903ccda647Slclee /*
30913ccda647Slclee * Currently we rely on the values in the label being accurate. If
30923ccda647Slclee * dkl_rpm or dkl_pcly are zero in the label, use a default value.
30933ccda647Slclee *
30943ccda647Slclee * Note: In the future a MODE SENSE may be used to retrieve this data,
30953ccda647Slclee * although this command is optional in SCSI-2.
30963ccda647Slclee */
3097e8fb11a1Sshidokht cl->cl_g.dkg_rpm = (labp->dkl_rpm != 0) ? labp->dkl_rpm : 3600;
3098e8fb11a1Sshidokht cl->cl_g.dkg_pcyl = (labp->dkl_pcyl != 0) ? labp->dkl_pcyl :
3099e8fb11a1Sshidokht (cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl);
31003ccda647Slclee
31013ccda647Slclee /*
31023ccda647Slclee * The Read and Write reinstruct values may not be valid
31033ccda647Slclee * for older disks.
31043ccda647Slclee */
3105e8fb11a1Sshidokht cl->cl_g.dkg_read_reinstruct = labp->dkl_read_reinstruct;
3106e8fb11a1Sshidokht cl->cl_g.dkg_write_reinstruct = labp->dkl_write_reinstruct;
31073ccda647Slclee
31083ccda647Slclee /* Fill in partition table. */
31093ccda647Slclee #if defined(_SUNOS_VTOC_8)
31103ccda647Slclee for (i = 0; i < NDKMAP; i++) {
3111e8fb11a1Sshidokht cl->cl_map[i].dkl_cylno = labp->dkl_map[i].dkl_cylno;
3112e8fb11a1Sshidokht cl->cl_map[i].dkl_nblk = labp->dkl_map[i].dkl_nblk;
31133ccda647Slclee }
31143ccda647Slclee #endif
31153ccda647Slclee #if defined(_SUNOS_VTOC_16)
31163ccda647Slclee vpartp = labp->dkl_vtoc.v_part;
31173ccda647Slclee track_capacity = labp->dkl_nhead * labp->dkl_nsect;
31183ccda647Slclee
3119e8fb11a1Sshidokht /* Prevent divide by zero */
3120e8fb11a1Sshidokht if (track_capacity == 0) {
3121e8fb11a1Sshidokht if (!(flags & CMLB_SILENT))
3122e8fb11a1Sshidokht cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
3123e8fb11a1Sshidokht "Corrupt label - zero nhead or nsect value\n");
3124e8fb11a1Sshidokht
3125e8fb11a1Sshidokht return (CMLB_LABEL_IS_INVALID);
3126e8fb11a1Sshidokht }
3127e8fb11a1Sshidokht
31283ccda647Slclee for (i = 0; i < NDKMAP; i++, vpartp++) {
3129e8fb11a1Sshidokht cl->cl_map[i].dkl_cylno = vpartp->p_start / track_capacity;
3130e8fb11a1Sshidokht cl->cl_map[i].dkl_nblk = vpartp->p_size;
31313ccda647Slclee }
31323ccda647Slclee #endif
31333ccda647Slclee
31343ccda647Slclee /* Fill in VTOC Structure. */
3135e8fb11a1Sshidokht bcopy(&labp->dkl_vtoc, &cl->cl_vtoc, sizeof (struct dk_vtoc));
31363ccda647Slclee #if defined(_SUNOS_VTOC_8)
31373ccda647Slclee /*
31383ccda647Slclee * The 8-slice vtoc does not include the ascii label; save it into
31393ccda647Slclee * the device's soft state structure here.
31403ccda647Slclee */
3141e8fb11a1Sshidokht bcopy(labp->dkl_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII);
31423ccda647Slclee #endif
31433ccda647Slclee
31443ccda647Slclee /* Now look for a valid capacity. */
3145e8fb11a1Sshidokht track_capacity = (cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect);
3146e8fb11a1Sshidokht label_capacity = (cl->cl_g.dkg_ncyl * track_capacity);
31473ccda647Slclee
3148e8fb11a1Sshidokht if (cl->cl_g.dkg_acyl) {
314986ef0a63SRichard Lowe #if defined(__x86)
31503ccda647Slclee /* we may have > 1 alts cylinder */
3151e8fb11a1Sshidokht label_capacity += (track_capacity * cl->cl_g.dkg_acyl);
31523ccda647Slclee #else
31533ccda647Slclee label_capacity += track_capacity;
31543ccda647Slclee #endif
31553ccda647Slclee }
31563ccda647Slclee
3157e8fb11a1Sshidokht /*
3158e8fb11a1Sshidokht * Force check here to ensure the computed capacity is valid.
3159e8fb11a1Sshidokht * If capacity is zero, it indicates an invalid label and
3160e8fb11a1Sshidokht * we should abort updating the relevant data then.
3161e8fb11a1Sshidokht */
3162e8fb11a1Sshidokht if (label_capacity == 0) {
3163e8fb11a1Sshidokht if (!(flags & CMLB_SILENT))
3164e8fb11a1Sshidokht cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
3165e8fb11a1Sshidokht "Corrupt label - no valid capacity could be "
3166e8fb11a1Sshidokht "retrieved\n");
3167e8fb11a1Sshidokht
3168e8fb11a1Sshidokht return (CMLB_LABEL_IS_INVALID);
3169e8fb11a1Sshidokht }
3170e8fb11a1Sshidokht
3171e8fb11a1Sshidokht /* Mark the geometry as valid. */
31727f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_TRUE;
3173e8fb11a1Sshidokht
31743ccda647Slclee /*
31753ccda647Slclee * if we got invalidated when mutex exit and entered again,
31763ccda647Slclee * if blockcount different than when we came in, need to
31773ccda647Slclee * retry from beginning of cmlb_validate_geometry.
31783ccda647Slclee * revisit this on next phase of utilizing this for
31793ccda647Slclee * sd.
31803ccda647Slclee */
31813ccda647Slclee
3182e8fb11a1Sshidokht if (label_capacity <= cl->cl_blockcount) {
31833ccda647Slclee #if defined(_SUNOS_VTOC_8)
31843ccda647Slclee /*
31853ccda647Slclee * We can't let this happen on drives that are subdivided
31863ccda647Slclee * into logical disks (i.e., that have an fdisk table).
3187e8fb11a1Sshidokht * The cl_blockcount field should always hold the full media
31883ccda647Slclee * size in sectors, period. This code would overwrite
3189e8fb11a1Sshidokht * cl_blockcount with the size of the Solaris fdisk partition.
31903ccda647Slclee */
3191e8fb11a1Sshidokht cmlb_dbg(CMLB_ERROR, cl,
31923ccda647Slclee "cmlb_uselabel: Label %d blocks; Drive %d blocks\n",
3193e8fb11a1Sshidokht label_capacity, cl->cl_blockcount);
3194e8fb11a1Sshidokht cl->cl_solaris_size = label_capacity;
31953ccda647Slclee
31963ccda647Slclee #endif /* defined(_SUNOS_VTOC_8) */
31973ccda647Slclee goto done;
31983ccda647Slclee }
31993ccda647Slclee
3200e8fb11a1Sshidokht if (ISCD(cl)) {
32013ccda647Slclee /* For CDROMs, we trust that the data in the label is OK. */
32023ccda647Slclee #if defined(_SUNOS_VTOC_8)
32033ccda647Slclee for (i = 0; i < NDKMAP; i++) {
32043ccda647Slclee part_end = labp->dkl_nhead * labp->dkl_nsect *
32053ccda647Slclee labp->dkl_map[i].dkl_cylno +
32063ccda647Slclee labp->dkl_map[i].dkl_nblk - 1;
32073ccda647Slclee
32083ccda647Slclee if ((labp->dkl_map[i].dkl_nblk) &&
3209e8fb11a1Sshidokht (part_end > cl->cl_blockcount)) {
32107f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_FALSE;
32113ccda647Slclee break;
32123ccda647Slclee }
32133ccda647Slclee }
32143ccda647Slclee #endif
32153ccda647Slclee #if defined(_SUNOS_VTOC_16)
32163ccda647Slclee vpartp = &(labp->dkl_vtoc.v_part[0]);
32173ccda647Slclee for (i = 0; i < NDKMAP; i++, vpartp++) {
32183ccda647Slclee part_end = vpartp->p_start + vpartp->p_size;
32193ccda647Slclee if ((vpartp->p_size > 0) &&
3220e8fb11a1Sshidokht (part_end > cl->cl_blockcount)) {
32217f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_FALSE;
32223ccda647Slclee break;
32233ccda647Slclee }
32243ccda647Slclee }
32253ccda647Slclee #endif
32263ccda647Slclee } else {
3227e8fb11a1Sshidokht /* label_capacity > cl->cl_blockcount */
3228e8fb11a1Sshidokht if (!(flags & CMLB_SILENT)) {
3229e8fb11a1Sshidokht cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
3230e8fb11a1Sshidokht "Corrupt label - bad geometry\n");
3231e8fb11a1Sshidokht cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_CONT,
3232e8fb11a1Sshidokht "Label says %llu blocks; Drive says %llu blocks\n",
3233e8fb11a1Sshidokht label_capacity, cl->cl_blockcount);
3234e8fb11a1Sshidokht }
32357f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_FALSE;
32363ccda647Slclee label_error = CMLB_LABEL_IS_INVALID;
32373ccda647Slclee }
32383ccda647Slclee
32393ccda647Slclee done:
32403ccda647Slclee
3241e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl, "cmlb_uselabel: (label geometry)\n");
3242e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl,
32433ccda647Slclee " ncyl: %d; acyl: %d; nhead: %d; nsect: %d\n",
3244e8fb11a1Sshidokht cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
3245e8fb11a1Sshidokht cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
32463ccda647Slclee
3247e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl,
32483ccda647Slclee " label_capacity: %d; intrlv: %d; rpm: %d\n",
3249e8fb11a1Sshidokht cl->cl_blockcount, cl->cl_g.dkg_intrlv, cl->cl_g.dkg_rpm);
3250e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl, " wrt_reinstr: %d; rd_reinstr: %d\n",
3251e8fb11a1Sshidokht cl->cl_g.dkg_write_reinstruct, cl->cl_g.dkg_read_reinstruct);
32523ccda647Slclee
3253e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
32543ccda647Slclee
32553ccda647Slclee return (label_error);
32563ccda647Slclee }
32573ccda647Slclee
32583ccda647Slclee
32593ccda647Slclee /*
32603ccda647Slclee * Function: cmlb_build_default_label
32613ccda647Slclee *
32623ccda647Slclee * Description: Generate a default label for those devices that do not have
32633ccda647Slclee * one, e.g., new media, removable cartridges, etc..
32643ccda647Slclee *
32653ccda647Slclee * Context: Kernel thread only
32663ccda647Slclee */
3267e8fb11a1Sshidokht /*ARGSUSED*/
32683ccda647Slclee static void
3269e8fb11a1Sshidokht cmlb_build_default_label(struct cmlb_lun *cl, void *tg_cookie)
32703ccda647Slclee {
32713ccda647Slclee #if defined(_SUNOS_VTOC_16)
32723ccda647Slclee uint_t phys_spc;
32733ccda647Slclee uint_t disksize;
3274e8fb11a1Sshidokht struct dk_geom cl_g;
3275e8fb11a1Sshidokht diskaddr_t capacity;
32763ccda647Slclee #endif
32773ccda647Slclee
3278e8fb11a1Sshidokht ASSERT(cl != NULL);
3279e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
32803ccda647Slclee
32813ccda647Slclee #if defined(_SUNOS_VTOC_8)
32823ccda647Slclee /*
32833ccda647Slclee * Note: This is a legacy check for non-removable devices on VTOC_8
32843ccda647Slclee * only. This may be a valid check for VTOC_16 as well.
3285e8fb11a1Sshidokht * Once we understand why there is this difference between SPARC and
3286e8fb11a1Sshidokht * x86 platform, we could remove this legacy check.
32873ccda647Slclee */
3288e8fb11a1Sshidokht if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
32893ccda647Slclee return;
32903ccda647Slclee }
32913ccda647Slclee #endif
32923ccda647Slclee
3293e8fb11a1Sshidokht bzero(&cl->cl_g, sizeof (struct dk_geom));
3294e8fb11a1Sshidokht bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
3295e8fb11a1Sshidokht bzero(&cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
32963ccda647Slclee
32973ccda647Slclee #if defined(_SUNOS_VTOC_8)
32983ccda647Slclee
32993ccda647Slclee /*
33003ccda647Slclee * It's a REMOVABLE media, therefore no label (on sparc, anyway).
33013ccda647Slclee * But it is still necessary to set up various geometry information,
33023ccda647Slclee * and we are doing this here.
33033ccda647Slclee */
33043ccda647Slclee
33053ccda647Slclee /*
33063ccda647Slclee * For the rpm, we use the minimum for the disk. For the head, cyl,
33073ccda647Slclee * and number of sector per track, if the capacity <= 1GB, head = 64,
33083ccda647Slclee * sect = 32. else head = 255, sect 63 Note: the capacity should be
33093ccda647Slclee * equal to C*H*S values. This will cause some truncation of size due
33103ccda647Slclee * to round off errors. For CD-ROMs, this truncation can have adverse
33113ccda647Slclee * side effects, so returning ncyl and nhead as 1. The nsect will
33123ccda647Slclee * overflow for most of CD-ROMs as nsect is of type ushort. (4190569)
33133ccda647Slclee */
3314e8fb11a1Sshidokht cl->cl_solaris_size = cl->cl_blockcount;
3315e8fb11a1Sshidokht if (ISCD(cl)) {
33163ccda647Slclee tg_attribute_t tgattribute;
33173ccda647Slclee int is_writable;
33183ccda647Slclee /*
33193ccda647Slclee * Preserve the old behavior for non-writable
33203ccda647Slclee * medias. Since dkg_nsect is a ushort, it
33213ccda647Slclee * will lose bits as cdroms have more than
33223ccda647Slclee * 65536 sectors. So if we recalculate
33233ccda647Slclee * capacity, it will become much shorter.
33243ccda647Slclee * But the dkg_* information is not
33253ccda647Slclee * used for CDROMs so it is OK. But for
33263ccda647Slclee * Writable CDs we need this information
33273ccda647Slclee * to be valid (for newfs say). So we
33283ccda647Slclee * make nsect and nhead > 1 that way
33293ccda647Slclee * nsect can still stay within ushort limit
33303ccda647Slclee * without losing any bits.
33313ccda647Slclee */
33323ccda647Slclee
33333ccda647Slclee bzero(&tgattribute, sizeof (tg_attribute_t));
33343ccda647Slclee
3335e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
3336e8fb11a1Sshidokht is_writable =
3337e8fb11a1Sshidokht (DK_TG_GETATTRIBUTE(cl, &tgattribute, tg_cookie) == 0) ?
33383ccda647Slclee tgattribute.media_is_writable : 1;
3339e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
33403ccda647Slclee
33413ccda647Slclee if (is_writable) {
3342e8fb11a1Sshidokht cl->cl_g.dkg_nhead = 64;
3343e8fb11a1Sshidokht cl->cl_g.dkg_nsect = 32;
3344e8fb11a1Sshidokht cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32);
3345342440ecSPrasad Singamsetty cl->cl_solaris_size = (diskaddr_t)cl->cl_g.dkg_ncyl *
3346e8fb11a1Sshidokht cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
33473ccda647Slclee } else {
3348e8fb11a1Sshidokht cl->cl_g.dkg_ncyl = 1;
3349e8fb11a1Sshidokht cl->cl_g.dkg_nhead = 1;
3350e8fb11a1Sshidokht cl->cl_g.dkg_nsect = cl->cl_blockcount;
33513ccda647Slclee }
33523ccda647Slclee } else {
3353c31fac72SShidokht Yadegari if (cl->cl_blockcount < 160) {
3354c31fac72SShidokht Yadegari /* Less than 80K */
3355c31fac72SShidokht Yadegari cl->cl_g.dkg_nhead = 1;
3356c31fac72SShidokht Yadegari cl->cl_g.dkg_ncyl = cl->cl_blockcount;
3357c31fac72SShidokht Yadegari cl->cl_g.dkg_nsect = 1;
3358c31fac72SShidokht Yadegari } else if (cl->cl_blockcount <= 0x1000) {
33593ccda647Slclee /* unlabeled SCSI floppy device */
3360e8fb11a1Sshidokht cl->cl_g.dkg_nhead = 2;
3361e8fb11a1Sshidokht cl->cl_g.dkg_ncyl = 80;
3362e8fb11a1Sshidokht cl->cl_g.dkg_nsect = cl->cl_blockcount / (2 * 80);
3363e8fb11a1Sshidokht } else if (cl->cl_blockcount <= 0x200000) {
3364e8fb11a1Sshidokht cl->cl_g.dkg_nhead = 64;
3365e8fb11a1Sshidokht cl->cl_g.dkg_nsect = 32;
3366e8fb11a1Sshidokht cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32);
33673ccda647Slclee } else {
3368e8fb11a1Sshidokht cl->cl_g.dkg_nhead = 255;
336998a65dd4Sshidokht
337098a65dd4Sshidokht cl->cl_g.dkg_nsect = ((cl->cl_blockcount +
337198a65dd4Sshidokht (UINT16_MAX * 255 * 63) - 1) /
337298a65dd4Sshidokht (UINT16_MAX * 255 * 63)) * 63;
337398a65dd4Sshidokht
337498a65dd4Sshidokht if (cl->cl_g.dkg_nsect == 0)
337598a65dd4Sshidokht cl->cl_g.dkg_nsect = (UINT16_MAX / 63) * 63;
337698a65dd4Sshidokht
337798a65dd4Sshidokht cl->cl_g.dkg_ncyl = cl->cl_blockcount /
337898a65dd4Sshidokht (255 * cl->cl_g.dkg_nsect);
33793ccda647Slclee }
338098a65dd4Sshidokht
3381e8fb11a1Sshidokht cl->cl_solaris_size =
3382342440ecSPrasad Singamsetty (diskaddr_t)cl->cl_g.dkg_ncyl * cl->cl_g.dkg_nhead *
3383342440ecSPrasad Singamsetty cl->cl_g.dkg_nsect;
33843ccda647Slclee
33853ccda647Slclee }
33863ccda647Slclee
3387e8fb11a1Sshidokht cl->cl_g.dkg_acyl = 0;
3388e8fb11a1Sshidokht cl->cl_g.dkg_bcyl = 0;
3389e8fb11a1Sshidokht cl->cl_g.dkg_rpm = 200;
3390e8fb11a1Sshidokht cl->cl_asciilabel[0] = '\0';
3391e8fb11a1Sshidokht cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl;
33923ccda647Slclee
3393e8fb11a1Sshidokht cl->cl_map[0].dkl_cylno = 0;
3394e8fb11a1Sshidokht cl->cl_map[0].dkl_nblk = cl->cl_solaris_size;
33953ccda647Slclee
3396e8fb11a1Sshidokht cl->cl_map[2].dkl_cylno = 0;
3397e8fb11a1Sshidokht cl->cl_map[2].dkl_nblk = cl->cl_solaris_size;
33983ccda647Slclee
33993ccda647Slclee #elif defined(_SUNOS_VTOC_16)
34003ccda647Slclee
3401e8fb11a1Sshidokht if (cl->cl_solaris_size == 0) {
34023ccda647Slclee /*
34033ccda647Slclee * Got fdisk table but no solaris entry therefore
34043ccda647Slclee * don't create a default label
34053ccda647Slclee */
34067f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_TRUE;
34073ccda647Slclee return;
34083ccda647Slclee }
34093ccda647Slclee
34103ccda647Slclee /*
34113ccda647Slclee * For CDs we continue to use the physical geometry to calculate
34123ccda647Slclee * number of cylinders. All other devices must convert the
34133ccda647Slclee * physical geometry (cmlb_geom) to values that will fit
34143ccda647Slclee * in a dk_geom structure.
34153ccda647Slclee */
3416e8fb11a1Sshidokht if (ISCD(cl)) {
3417e8fb11a1Sshidokht phys_spc = cl->cl_pgeom.g_nhead * cl->cl_pgeom.g_nsect;
34183ccda647Slclee } else {
34193ccda647Slclee /* Convert physical geometry to disk geometry */
3420e8fb11a1Sshidokht bzero(&cl_g, sizeof (struct dk_geom));
3421e8fb11a1Sshidokht
3422e8fb11a1Sshidokht /*
3423e8fb11a1Sshidokht * Refer to comments related to off-by-1 at the
3424e8fb11a1Sshidokht * header of this file.
3425b9ccdc5aScth * Before calculating geometry, capacity should be
3426e8fb11a1Sshidokht * decreased by 1.
3427e8fb11a1Sshidokht */
3428e8fb11a1Sshidokht
3429e8fb11a1Sshidokht if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE)
3430e8fb11a1Sshidokht capacity = cl->cl_blockcount - 1;
3431e8fb11a1Sshidokht else
3432e8fb11a1Sshidokht capacity = cl->cl_blockcount;
3433e8fb11a1Sshidokht
3434e8fb11a1Sshidokht
3435b081f1c4Syu, larry liu - Sun Microsystems - Beijing China cmlb_convert_geometry(cl, capacity, &cl_g, tg_cookie);
3436e8fb11a1Sshidokht bcopy(&cl_g, &cl->cl_g, sizeof (cl->cl_g));
3437e8fb11a1Sshidokht phys_spc = cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
34383ccda647Slclee }
34393ccda647Slclee
34407501b6d5SSheshadri Vasudevan if (phys_spc == 0)
34417501b6d5SSheshadri Vasudevan return;
3442e8fb11a1Sshidokht cl->cl_g.dkg_pcyl = cl->cl_solaris_size / phys_spc;
3443843e1988Sjohnlev if (cl->cl_alter_behavior & CMLB_FAKE_LABEL_ONE_PARTITION) {
3444843e1988Sjohnlev /* disable devid */
3445843e1988Sjohnlev cl->cl_g.dkg_ncyl = cl->cl_g.dkg_pcyl;
3446843e1988Sjohnlev disksize = cl->cl_solaris_size;
3447843e1988Sjohnlev } else {
3448843e1988Sjohnlev cl->cl_g.dkg_acyl = DK_ACYL;
3449843e1988Sjohnlev cl->cl_g.dkg_ncyl = cl->cl_g.dkg_pcyl - DK_ACYL;
3450843e1988Sjohnlev disksize = cl->cl_g.dkg_ncyl * phys_spc;
3451843e1988Sjohnlev }
34523ccda647Slclee
3453e8fb11a1Sshidokht if (ISCD(cl)) {
34543ccda647Slclee /*
34553ccda647Slclee * CD's don't use the "heads * sectors * cyls"-type of
34563ccda647Slclee * geometry, but instead use the entire capacity of the media.
34573ccda647Slclee */
3458e8fb11a1Sshidokht disksize = cl->cl_solaris_size;
3459e8fb11a1Sshidokht cl->cl_g.dkg_nhead = 1;
3460e8fb11a1Sshidokht cl->cl_g.dkg_nsect = 1;
3461e8fb11a1Sshidokht cl->cl_g.dkg_rpm =
3462e8fb11a1Sshidokht (cl->cl_pgeom.g_rpm == 0) ? 200 : cl->cl_pgeom.g_rpm;
34633ccda647Slclee
3464e8fb11a1Sshidokht cl->cl_vtoc.v_part[0].p_start = 0;
3465e8fb11a1Sshidokht cl->cl_vtoc.v_part[0].p_size = disksize;
3466e8fb11a1Sshidokht cl->cl_vtoc.v_part[0].p_tag = V_BACKUP;
3467e8fb11a1Sshidokht cl->cl_vtoc.v_part[0].p_flag = V_UNMNT;
34683ccda647Slclee
3469e8fb11a1Sshidokht cl->cl_map[0].dkl_cylno = 0;
3470e8fb11a1Sshidokht cl->cl_map[0].dkl_nblk = disksize;
3471e8fb11a1Sshidokht cl->cl_offset[0] = 0;
34723ccda647Slclee
34733ccda647Slclee } else {
34743ccda647Slclee /*
34753ccda647Slclee * Hard disks and removable media cartridges
34763ccda647Slclee */
3477e8fb11a1Sshidokht cl->cl_g.dkg_rpm =
3478e8fb11a1Sshidokht (cl->cl_pgeom.g_rpm == 0) ? 3600: cl->cl_pgeom.g_rpm;
3479e8fb11a1Sshidokht cl->cl_vtoc.v_sectorsz = cl->cl_sys_blocksize;
34803ccda647Slclee
34813ccda647Slclee /* Add boot slice */
3482e8fb11a1Sshidokht cl->cl_vtoc.v_part[8].p_start = 0;
3483e8fb11a1Sshidokht cl->cl_vtoc.v_part[8].p_size = phys_spc;
3484e8fb11a1Sshidokht cl->cl_vtoc.v_part[8].p_tag = V_BOOT;
3485e8fb11a1Sshidokht cl->cl_vtoc.v_part[8].p_flag = V_UNMNT;
34863ccda647Slclee
3487e8fb11a1Sshidokht cl->cl_map[8].dkl_cylno = 0;
3488e8fb11a1Sshidokht cl->cl_map[8].dkl_nblk = phys_spc;
3489e8fb11a1Sshidokht cl->cl_offset[8] = 0;
34903ccda647Slclee
3491e8fb11a1Sshidokht if ((cl->cl_alter_behavior &
34923ccda647Slclee CMLB_CREATE_ALTSLICE_VTOC_16_DTYPE_DIRECT) &&
3493e8fb11a1Sshidokht cl->cl_device_type == DTYPE_DIRECT) {
3494e8fb11a1Sshidokht cl->cl_vtoc.v_part[9].p_start = phys_spc;
3495e8fb11a1Sshidokht cl->cl_vtoc.v_part[9].p_size = 2 * phys_spc;
3496e8fb11a1Sshidokht cl->cl_vtoc.v_part[9].p_tag = V_ALTSCTR;
3497e8fb11a1Sshidokht cl->cl_vtoc.v_part[9].p_flag = 0;
3498e8fb11a1Sshidokht
3499e8fb11a1Sshidokht cl->cl_map[9].dkl_cylno = 1;
3500e8fb11a1Sshidokht cl->cl_map[9].dkl_nblk = 2 * phys_spc;
3501e8fb11a1Sshidokht cl->cl_offset[9] = phys_spc;
35023ccda647Slclee }
35033ccda647Slclee }
35043ccda647Slclee
3505e8fb11a1Sshidokht cl->cl_g.dkg_apc = 0;
35063ccda647Slclee
35073ccda647Slclee /* Add backup slice */
3508e8fb11a1Sshidokht cl->cl_vtoc.v_part[2].p_start = 0;
3509e8fb11a1Sshidokht cl->cl_vtoc.v_part[2].p_size = disksize;
3510e8fb11a1Sshidokht cl->cl_vtoc.v_part[2].p_tag = V_BACKUP;
3511e8fb11a1Sshidokht cl->cl_vtoc.v_part[2].p_flag = V_UNMNT;
35123ccda647Slclee
3513e8fb11a1Sshidokht cl->cl_map[2].dkl_cylno = 0;
3514e8fb11a1Sshidokht cl->cl_map[2].dkl_nblk = disksize;
3515e8fb11a1Sshidokht cl->cl_offset[2] = 0;
35163ccda647Slclee
3517843e1988Sjohnlev /*
3518843e1988Sjohnlev * single slice (s0) covering the entire disk
3519843e1988Sjohnlev */
3520843e1988Sjohnlev if (cl->cl_alter_behavior & CMLB_FAKE_LABEL_ONE_PARTITION) {
3521843e1988Sjohnlev cl->cl_vtoc.v_part[0].p_start = 0;
3522843e1988Sjohnlev cl->cl_vtoc.v_part[0].p_tag = V_UNASSIGNED;
3523843e1988Sjohnlev cl->cl_vtoc.v_part[0].p_flag = 0;
3524843e1988Sjohnlev cl->cl_vtoc.v_part[0].p_size = disksize;
3525843e1988Sjohnlev cl->cl_map[0].dkl_cylno = 0;
3526843e1988Sjohnlev cl->cl_map[0].dkl_nblk = disksize;
3527843e1988Sjohnlev cl->cl_offset[0] = 0;
3528843e1988Sjohnlev }
3529843e1988Sjohnlev
3530e8fb11a1Sshidokht (void) sprintf(cl->cl_vtoc.v_asciilabel, "DEFAULT cyl %d alt %d"
3531e8fb11a1Sshidokht " hd %d sec %d", cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
3532e8fb11a1Sshidokht cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
35333ccda647Slclee
35343ccda647Slclee #else
35353ccda647Slclee #error "No VTOC format defined."
35363ccda647Slclee #endif
35373ccda647Slclee
3538e8fb11a1Sshidokht cl->cl_g.dkg_read_reinstruct = 0;
3539e8fb11a1Sshidokht cl->cl_g.dkg_write_reinstruct = 0;
35403ccda647Slclee
3541e8fb11a1Sshidokht cl->cl_g.dkg_intrlv = 1;
35423ccda647Slclee
3543e8fb11a1Sshidokht cl->cl_vtoc.v_sanity = VTOC_SANE;
3544c813bb04SGabriel Carrillo cl->cl_vtoc.v_nparts = V_NUMPAR;
3545c813bb04SGabriel Carrillo cl->cl_vtoc.v_version = V_VERSION;
35463ccda647Slclee
35477f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_TRUE;
3548342440ecSPrasad Singamsetty cl->cl_label_from_media = CMLB_LABEL_UNDEF;
35493ccda647Slclee
3550e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl,
35513ccda647Slclee "cmlb_build_default_label: Default label created: "
35523ccda647Slclee "cyl: %d\tacyl: %d\tnhead: %d\tnsect: %d\tcap: %d\n",
3553e8fb11a1Sshidokht cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl, cl->cl_g.dkg_nhead,
3554e8fb11a1Sshidokht cl->cl_g.dkg_nsect, cl->cl_blockcount);
35553ccda647Slclee }
35563ccda647Slclee
35573ccda647Slclee
35583ccda647Slclee #if defined(_FIRMWARE_NEEDS_FDISK)
35593ccda647Slclee /*
35603ccda647Slclee * Max CHS values, as they are encoded into bytes, for 1022/254/63
35613ccda647Slclee */
35623ccda647Slclee #define LBA_MAX_SECT (63 | ((1022 & 0x300) >> 2))
35633ccda647Slclee #define LBA_MAX_CYL (1022 & 0xFF)
35643ccda647Slclee #define LBA_MAX_HEAD (254)
35653ccda647Slclee
35663ccda647Slclee
35673ccda647Slclee /*
35683ccda647Slclee * Function: cmlb_has_max_chs_vals
35693ccda647Slclee *
35707f0b8309SEdward Pilatowicz * Description: Return B_TRUE if Cylinder-Head-Sector values are all at maximum.
35713ccda647Slclee *
35723ccda647Slclee * Arguments: fdp - ptr to CHS info
35733ccda647Slclee *
35743ccda647Slclee * Return Code: True or false
35753ccda647Slclee *
35763ccda647Slclee * Context: Any.
35773ccda647Slclee */
35787f0b8309SEdward Pilatowicz static boolean_t
35793ccda647Slclee cmlb_has_max_chs_vals(struct ipart *fdp)
35803ccda647Slclee {
35813ccda647Slclee return ((fdp->begcyl == LBA_MAX_CYL) &&
35823ccda647Slclee (fdp->beghead == LBA_MAX_HEAD) &&
35833ccda647Slclee (fdp->begsect == LBA_MAX_SECT) &&
35843ccda647Slclee (fdp->endcyl == LBA_MAX_CYL) &&
35853ccda647Slclee (fdp->endhead == LBA_MAX_HEAD) &&
35863ccda647Slclee (fdp->endsect == LBA_MAX_SECT));
35873ccda647Slclee }
35883ccda647Slclee #endif
35893ccda647Slclee
35903ccda647Slclee /*
35913ccda647Slclee * Function: cmlb_dkio_get_geometry
35923ccda647Slclee *
35933ccda647Slclee * Description: This routine is the driver entry point for handling user
35943ccda647Slclee * requests to get the device geometry (DKIOCGGEOM).
35953ccda647Slclee *
35963ccda647Slclee * Arguments:
3597e8fb11a1Sshidokht * arg pointer to user provided dk_geom structure specifying
35983ccda647Slclee * the controller's notion of the current geometry.
3599e8fb11a1Sshidokht *
3600531d0b66SToomas Soome * flag this argument is a pass through to ddi_copyxxx()
3601e8fb11a1Sshidokht * directly from the mode argument of ioctl().
3602e8fb11a1Sshidokht *
3603e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
3604e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
36053ccda647Slclee *
36063ccda647Slclee * Return Code: 0
36073ccda647Slclee * EFAULT
36083ccda647Slclee * ENXIO
36093ccda647Slclee * EIO
36103ccda647Slclee */
36113ccda647Slclee static int
3612e8fb11a1Sshidokht cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag,
3613e8fb11a1Sshidokht void *tg_cookie)
36143ccda647Slclee {
36153ccda647Slclee struct dk_geom *tmp_geom = NULL;
36163ccda647Slclee int rval = 0;
36173ccda647Slclee
36183ccda647Slclee /*
36193ccda647Slclee * cmlb_validate_geometry does not spin a disk up
3620e8fb11a1Sshidokht * if it was spcl down. We need to make sure it
36213ccda647Slclee * is ready.
36223ccda647Slclee */
3623e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
36247f0b8309SEdward Pilatowicz rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie);
36253ccda647Slclee #if defined(_SUNOS_VTOC_8)
36263ccda647Slclee if (rval == EINVAL &&
3627e8fb11a1Sshidokht cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) {
36283ccda647Slclee /*
36293ccda647Slclee * This is to return a default label geometry even when we
36303ccda647Slclee * do not really assume a default label for the device.
36313ccda647Slclee * dad driver utilizes this.
36323ccda647Slclee */
3633342440ecSPrasad Singamsetty if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
3634e8fb11a1Sshidokht cmlb_setup_default_geometry(cl, tg_cookie);
36353ccda647Slclee rval = 0;
36363ccda647Slclee }
36373ccda647Slclee }
36383ccda647Slclee #endif
36393ccda647Slclee if (rval) {
3640e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
36413ccda647Slclee return (rval);
36423ccda647Slclee }
36433ccda647Slclee
364486ef0a63SRichard Lowe #if defined(__x86)
3645e8fb11a1Sshidokht if (cl->cl_solaris_size == 0) {
3646e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
36473ccda647Slclee return (EIO);
36483ccda647Slclee }
36493ccda647Slclee #endif
36503ccda647Slclee
36513ccda647Slclee /*
36523ccda647Slclee * Make a local copy of the soft state geometry to avoid some potential
36533ccda647Slclee * race conditions associated with holding the mutex and updating the
36543ccda647Slclee * write_reinstruct value
36553ccda647Slclee */
36563ccda647Slclee tmp_geom = kmem_zalloc(sizeof (struct dk_geom), KM_SLEEP);
3657e8fb11a1Sshidokht bcopy(&cl->cl_g, tmp_geom, sizeof (struct dk_geom));
36583ccda647Slclee
36593ccda647Slclee if (tmp_geom->dkg_write_reinstruct == 0) {
36603ccda647Slclee tmp_geom->dkg_write_reinstruct =
36613ccda647Slclee (int)((int)(tmp_geom->dkg_nsect * tmp_geom->dkg_rpm *
36623ccda647Slclee cmlb_rot_delay) / (int)60000);
36633ccda647Slclee }
3664e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
36653ccda647Slclee
36663ccda647Slclee rval = ddi_copyout(tmp_geom, (void *)arg, sizeof (struct dk_geom),
36673ccda647Slclee flag);
36683ccda647Slclee if (rval != 0) {
36693ccda647Slclee rval = EFAULT;
36703ccda647Slclee }
36713ccda647Slclee
36723ccda647Slclee kmem_free(tmp_geom, sizeof (struct dk_geom));
36733ccda647Slclee return (rval);
36743ccda647Slclee
36753ccda647Slclee }
36763ccda647Slclee
36773ccda647Slclee
36783ccda647Slclee /*
36793ccda647Slclee * Function: cmlb_dkio_set_geometry
36803ccda647Slclee *
36813ccda647Slclee * Description: This routine is the driver entry point for handling user
36823ccda647Slclee * requests to set the device geometry (DKIOCSGEOM). The actual
36833ccda647Slclee * device geometry is not updated, just the driver "notion" of it.
36843ccda647Slclee *
36853ccda647Slclee * Arguments:
3686e8fb11a1Sshidokht * arg pointer to user provided dk_geom structure used to set
36873ccda647Slclee * the controller's notion of the current geometry.
3688e8fb11a1Sshidokht *
3689531d0b66SToomas Soome * flag this argument is a pass through to ddi_copyxxx()
3690e8fb11a1Sshidokht * directly from the mode argument of ioctl().
3691e8fb11a1Sshidokht *
3692e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
3693e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
36943ccda647Slclee *
36953ccda647Slclee * Return Code: 0
36963ccda647Slclee * EFAULT
36973ccda647Slclee * ENXIO
36983ccda647Slclee * EIO
36993ccda647Slclee */
37003ccda647Slclee static int
3701e8fb11a1Sshidokht cmlb_dkio_set_geometry(struct cmlb_lun *cl, caddr_t arg, int flag)
37023ccda647Slclee {
37033ccda647Slclee struct dk_geom *tmp_geom;
37043ccda647Slclee struct dk_map *lp;
37053ccda647Slclee int rval = 0;
37063ccda647Slclee int i;
37073ccda647Slclee
37083ccda647Slclee
370986ef0a63SRichard Lowe #if defined(__x86)
3710e8fb11a1Sshidokht if (cl->cl_solaris_size == 0) {
37113ccda647Slclee return (EIO);
37123ccda647Slclee }
37133ccda647Slclee #endif
37143ccda647Slclee /*
37153ccda647Slclee * We need to copy the user specified geometry into local
37163ccda647Slclee * storage and then update the softstate. We don't want to hold
37173ccda647Slclee * the mutex and copyin directly from the user to the soft state
37183ccda647Slclee */
37193ccda647Slclee tmp_geom = (struct dk_geom *)
37203ccda647Slclee kmem_zalloc(sizeof (struct dk_geom), KM_SLEEP);
37213ccda647Slclee rval = ddi_copyin(arg, tmp_geom, sizeof (struct dk_geom), flag);
37223ccda647Slclee if (rval != 0) {
37233ccda647Slclee kmem_free(tmp_geom, sizeof (struct dk_geom));
37243ccda647Slclee return (EFAULT);
37253ccda647Slclee }
37263ccda647Slclee
3727e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
3728e8fb11a1Sshidokht bcopy(tmp_geom, &cl->cl_g, sizeof (struct dk_geom));
37293ccda647Slclee for (i = 0; i < NDKMAP; i++) {
3730e8fb11a1Sshidokht lp = &cl->cl_map[i];
3731e8fb11a1Sshidokht cl->cl_offset[i] =
3732e8fb11a1Sshidokht cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
373386ef0a63SRichard Lowe #if defined(__x86)
3734e8fb11a1Sshidokht cl->cl_offset[i] += cl->cl_solaris_offset;
37353ccda647Slclee #endif
37363ccda647Slclee }
37377f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_FALSE;
3738e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
37393ccda647Slclee kmem_free(tmp_geom, sizeof (struct dk_geom));
37403ccda647Slclee
37413ccda647Slclee return (rval);
37423ccda647Slclee }
37433ccda647Slclee
37443ccda647Slclee /*
37453ccda647Slclee * Function: cmlb_dkio_get_partition
37463ccda647Slclee *
37473ccda647Slclee * Description: This routine is the driver entry point for handling user
37483ccda647Slclee * requests to get the partition table (DKIOCGAPART).
37493ccda647Slclee *
37503ccda647Slclee * Arguments:
3751e8fb11a1Sshidokht * arg pointer to user provided dk_allmap structure specifying
37523ccda647Slclee * the controller's notion of the current partition table.
3753e8fb11a1Sshidokht *
3754e8fb11a1Sshidokht * flag this argument is a pass through to ddi_copyxxx()
3755e8fb11a1Sshidokht * directly from the mode argument of ioctl().
3756e8fb11a1Sshidokht *
3757e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
3758e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
37593ccda647Slclee *
37603ccda647Slclee * Return Code: 0
37613ccda647Slclee * EFAULT
37623ccda647Slclee * ENXIO
37633ccda647Slclee * EIO
37643ccda647Slclee */
37653ccda647Slclee static int
3766e8fb11a1Sshidokht cmlb_dkio_get_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
3767e8fb11a1Sshidokht void *tg_cookie)
37683ccda647Slclee {
37693ccda647Slclee int rval = 0;
37703ccda647Slclee int size;
37713ccda647Slclee
37723ccda647Slclee /*
37733ccda647Slclee * Make sure the geometry is valid before getting the partition
37743ccda647Slclee * information.
37753ccda647Slclee */
3776e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
37777f0b8309SEdward Pilatowicz if ((rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie)) != 0) {
3778e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
37793ccda647Slclee return (rval);
37803ccda647Slclee }
3781e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
37823ccda647Slclee
378386ef0a63SRichard Lowe #if defined(__x86)
3784e8fb11a1Sshidokht if (cl->cl_solaris_size == 0) {
37853ccda647Slclee return (EIO);
37863ccda647Slclee }
37873ccda647Slclee #endif
37883ccda647Slclee
37893ccda647Slclee #ifdef _MULTI_DATAMODEL
37903ccda647Slclee switch (ddi_model_convert_from(flag & FMODELS)) {
37913ccda647Slclee case DDI_MODEL_ILP32: {
37923ccda647Slclee struct dk_map32 dk_map32[NDKMAP];
37933ccda647Slclee int i;
37943ccda647Slclee
37953ccda647Slclee for (i = 0; i < NDKMAP; i++) {
3796e8fb11a1Sshidokht dk_map32[i].dkl_cylno = cl->cl_map[i].dkl_cylno;
3797e8fb11a1Sshidokht dk_map32[i].dkl_nblk = cl->cl_map[i].dkl_nblk;
37983ccda647Slclee }
37993ccda647Slclee size = NDKMAP * sizeof (struct dk_map32);
38003ccda647Slclee rval = ddi_copyout(dk_map32, (void *)arg, size, flag);
38013ccda647Slclee if (rval != 0) {
38023ccda647Slclee rval = EFAULT;
38033ccda647Slclee }
38043ccda647Slclee break;
38053ccda647Slclee }
38063ccda647Slclee case DDI_MODEL_NONE:
38073ccda647Slclee size = NDKMAP * sizeof (struct dk_map);
3808e8fb11a1Sshidokht rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag);
38093ccda647Slclee if (rval != 0) {
38103ccda647Slclee rval = EFAULT;
38113ccda647Slclee }
38123ccda647Slclee break;
38133ccda647Slclee }
38143ccda647Slclee #else /* ! _MULTI_DATAMODEL */
38153ccda647Slclee size = NDKMAP * sizeof (struct dk_map);
3816e8fb11a1Sshidokht rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag);
38173ccda647Slclee if (rval != 0) {
38183ccda647Slclee rval = EFAULT;
38193ccda647Slclee }
38203ccda647Slclee #endif /* _MULTI_DATAMODEL */
38213ccda647Slclee return (rval);
38223ccda647Slclee }
38233ccda647Slclee
38243ccda647Slclee /*
38253ccda647Slclee * Function: cmlb_dkio_set_partition
38263ccda647Slclee *
38273ccda647Slclee * Description: This routine is the driver entry point for handling user
38283ccda647Slclee * requests to set the partition table (DKIOCSAPART). The actual
38293ccda647Slclee * device partition is not updated.
38303ccda647Slclee *
38313ccda647Slclee * Arguments:
38323ccda647Slclee * arg - pointer to user provided dk_allmap structure used to set
38333ccda647Slclee * the controller's notion of the partition table.
38343ccda647Slclee * flag - this argument is a pass through to ddi_copyxxx()
38353ccda647Slclee * directly from the mode argument of ioctl().
38363ccda647Slclee *
38373ccda647Slclee * Return Code: 0
38383ccda647Slclee * EINVAL
38393ccda647Slclee * EFAULT
38403ccda647Slclee * ENXIO
38413ccda647Slclee * EIO
38423ccda647Slclee */
38433ccda647Slclee static int
3844e8fb11a1Sshidokht cmlb_dkio_set_partition(struct cmlb_lun *cl, caddr_t arg, int flag)
38453ccda647Slclee {
38463ccda647Slclee struct dk_map dk_map[NDKMAP];
38473ccda647Slclee struct dk_map *lp;
38483ccda647Slclee int rval = 0;
38493ccda647Slclee int size;
38503ccda647Slclee int i;
38513ccda647Slclee #if defined(_SUNOS_VTOC_16)
38523ccda647Slclee struct dkl_partition *vp;
38533ccda647Slclee #endif
38543ccda647Slclee
38553ccda647Slclee /*
38563ccda647Slclee * Set the map for all logical partitions. We lock
38573ccda647Slclee * the priority just to make sure an interrupt doesn't
38583ccda647Slclee * come in while the map is half updated.
38593ccda647Slclee */
3860e8fb11a1Sshidokht _NOTE(DATA_READABLE_WITHOUT_LOCK(cmlb_lun::cl_solaris_size))
3861e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
38623ccda647Slclee
3863342440ecSPrasad Singamsetty if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
3864e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
38653ccda647Slclee return (ENOTSUP);
38663ccda647Slclee }
3867e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
3868e8fb11a1Sshidokht if (cl->cl_solaris_size == 0) {
38693ccda647Slclee return (EIO);
38703ccda647Slclee }
38713ccda647Slclee
38723ccda647Slclee #ifdef _MULTI_DATAMODEL
38733ccda647Slclee switch (ddi_model_convert_from(flag & FMODELS)) {
38743ccda647Slclee case DDI_MODEL_ILP32: {
38753ccda647Slclee struct dk_map32 dk_map32[NDKMAP];
38763ccda647Slclee
38773ccda647Slclee size = NDKMAP * sizeof (struct dk_map32);
38783ccda647Slclee rval = ddi_copyin((void *)arg, dk_map32, size, flag);
38793ccda647Slclee if (rval != 0) {
38803ccda647Slclee return (EFAULT);
38813ccda647Slclee }
38823ccda647Slclee for (i = 0; i < NDKMAP; i++) {
38833ccda647Slclee dk_map[i].dkl_cylno = dk_map32[i].dkl_cylno;
38843ccda647Slclee dk_map[i].dkl_nblk = dk_map32[i].dkl_nblk;
38853ccda647Slclee }
38863ccda647Slclee break;
38873ccda647Slclee }
38883ccda647Slclee case DDI_MODEL_NONE:
38893ccda647Slclee size = NDKMAP * sizeof (struct dk_map);
38903ccda647Slclee rval = ddi_copyin((void *)arg, dk_map, size, flag);
38913ccda647Slclee if (rval != 0) {
38923ccda647Slclee return (EFAULT);
38933ccda647Slclee }
38943ccda647Slclee break;
38953ccda647Slclee }
38963ccda647Slclee #else /* ! _MULTI_DATAMODEL */
38973ccda647Slclee size = NDKMAP * sizeof (struct dk_map);
38983ccda647Slclee rval = ddi_copyin((void *)arg, dk_map, size, flag);
38993ccda647Slclee if (rval != 0) {
39003ccda647Slclee return (EFAULT);
39013ccda647Slclee }
39023ccda647Slclee #endif /* _MULTI_DATAMODEL */
39033ccda647Slclee
3904e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
39053ccda647Slclee /* Note: The size used in this bcopy is set based upon the data model */
3906e8fb11a1Sshidokht bcopy(dk_map, cl->cl_map, size);
39073ccda647Slclee #if defined(_SUNOS_VTOC_16)
3908e8fb11a1Sshidokht vp = (struct dkl_partition *)&(cl->cl_vtoc);
39093ccda647Slclee #endif /* defined(_SUNOS_VTOC_16) */
39103ccda647Slclee for (i = 0; i < NDKMAP; i++) {
3911e8fb11a1Sshidokht lp = &cl->cl_map[i];
3912e8fb11a1Sshidokht cl->cl_offset[i] =
3913e8fb11a1Sshidokht cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
39143ccda647Slclee #if defined(_SUNOS_VTOC_16)
3915e8fb11a1Sshidokht vp->p_start = cl->cl_offset[i];
39163ccda647Slclee vp->p_size = lp->dkl_nblk;
39173ccda647Slclee vp++;
39183ccda647Slclee #endif /* defined(_SUNOS_VTOC_16) */
391986ef0a63SRichard Lowe #if defined(__x86)
3920e8fb11a1Sshidokht cl->cl_offset[i] += cl->cl_solaris_offset;
39213ccda647Slclee #endif
39223ccda647Slclee }
3923e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
39243ccda647Slclee return (rval);
39253ccda647Slclee }
39263ccda647Slclee
39273ccda647Slclee
39283ccda647Slclee /*
39293ccda647Slclee * Function: cmlb_dkio_get_vtoc
39303ccda647Slclee *
39313ccda647Slclee * Description: This routine is the driver entry point for handling user
39323ccda647Slclee * requests to get the current volume table of contents
39333ccda647Slclee * (DKIOCGVTOC).
39343ccda647Slclee *
39353ccda647Slclee * Arguments:
3936e8fb11a1Sshidokht * arg pointer to user provided vtoc structure specifying
39373ccda647Slclee * the current vtoc.
3938e8fb11a1Sshidokht *
3939e8fb11a1Sshidokht * flag this argument is a pass through to ddi_copyxxx()
3940e8fb11a1Sshidokht * directly from the mode argument of ioctl().
3941e8fb11a1Sshidokht *
3942e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
3943e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
39443ccda647Slclee *
39453ccda647Slclee * Return Code: 0
39463ccda647Slclee * EFAULT
39473ccda647Slclee * ENXIO
39483ccda647Slclee * EIO
39493ccda647Slclee */
39503ccda647Slclee static int
3951e8fb11a1Sshidokht cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
39523ccda647Slclee {
39533ccda647Slclee #if defined(_SUNOS_VTOC_8)
39543ccda647Slclee struct vtoc user_vtoc;
39553ccda647Slclee #endif /* defined(_SUNOS_VTOC_8) */
39563ccda647Slclee int rval = 0;
39573ccda647Slclee
3958e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
3959342440ecSPrasad Singamsetty if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
3960342440ecSPrasad Singamsetty mutex_exit(CMLB_MUTEX(cl));
3961342440ecSPrasad Singamsetty return (EOVERFLOW);
3962342440ecSPrasad Singamsetty }
3963342440ecSPrasad Singamsetty
39647f0b8309SEdward Pilatowicz rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie);
39653ccda647Slclee
39663ccda647Slclee #if defined(_SUNOS_VTOC_8)
39673ccda647Slclee if (rval == EINVAL &&
3968e8fb11a1Sshidokht (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8)) {
39693ccda647Slclee /*
39703ccda647Slclee * This is to return a default label even when we do not
39713ccda647Slclee * really assume a default label for the device.
39723ccda647Slclee * dad driver utilizes this.
39733ccda647Slclee */
3974342440ecSPrasad Singamsetty if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
3975e8fb11a1Sshidokht cmlb_setup_default_geometry(cl, tg_cookie);
39763ccda647Slclee rval = 0;
39773ccda647Slclee }
39783ccda647Slclee }
39793ccda647Slclee #endif
39803ccda647Slclee if (rval) {
3981e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
39823ccda647Slclee return (rval);
39833ccda647Slclee }
39843ccda647Slclee
39853ccda647Slclee #if defined(_SUNOS_VTOC_8)
3986e8fb11a1Sshidokht cmlb_build_user_vtoc(cl, &user_vtoc);
3987e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
39883ccda647Slclee
39893ccda647Slclee #ifdef _MULTI_DATAMODEL
39903ccda647Slclee switch (ddi_model_convert_from(flag & FMODELS)) {
39913ccda647Slclee case DDI_MODEL_ILP32: {
39923ccda647Slclee struct vtoc32 user_vtoc32;
39933ccda647Slclee
39943ccda647Slclee vtoctovtoc32(user_vtoc, user_vtoc32);
39953ccda647Slclee if (ddi_copyout(&user_vtoc32, (void *)arg,
39963ccda647Slclee sizeof (struct vtoc32), flag)) {
39973ccda647Slclee return (EFAULT);
39983ccda647Slclee }
39993ccda647Slclee break;
40003ccda647Slclee }
40013ccda647Slclee
40023ccda647Slclee case DDI_MODEL_NONE:
40033ccda647Slclee if (ddi_copyout(&user_vtoc, (void *)arg,
40043ccda647Slclee sizeof (struct vtoc), flag)) {
40053ccda647Slclee return (EFAULT);
40063ccda647Slclee }
40073ccda647Slclee break;
40083ccda647Slclee }
40093ccda647Slclee #else /* ! _MULTI_DATAMODEL */
40103ccda647Slclee if (ddi_copyout(&user_vtoc, (void *)arg, sizeof (struct vtoc), flag)) {
40113ccda647Slclee return (EFAULT);
40123ccda647Slclee }
40133ccda647Slclee #endif /* _MULTI_DATAMODEL */
40143ccda647Slclee
40153ccda647Slclee #elif defined(_SUNOS_VTOC_16)
4016e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
40173ccda647Slclee
40183ccda647Slclee #ifdef _MULTI_DATAMODEL
40193ccda647Slclee /*
4020e8fb11a1Sshidokht * The cl_vtoc structure is a "struct dk_vtoc" which is always
40213ccda647Slclee * 32-bit to maintain compatibility with existing on-disk
40223ccda647Slclee * structures. Thus, we need to convert the structure when copying
40233ccda647Slclee * it out to a datamodel-dependent "struct vtoc" in a 64-bit
40243ccda647Slclee * program. If the target is a 32-bit program, then no conversion
40253ccda647Slclee * is necessary.
40263ccda647Slclee */
40273ccda647Slclee /* LINTED: logical expression always true: op "||" */
4028e8fb11a1Sshidokht ASSERT(sizeof (cl->cl_vtoc) == sizeof (struct vtoc32));
40293ccda647Slclee switch (ddi_model_convert_from(flag & FMODELS)) {
40303ccda647Slclee case DDI_MODEL_ILP32:
4031e8fb11a1Sshidokht if (ddi_copyout(&(cl->cl_vtoc), (void *)arg,
4032e8fb11a1Sshidokht sizeof (cl->cl_vtoc), flag)) {
40333ccda647Slclee return (EFAULT);
40343ccda647Slclee }
40353ccda647Slclee break;
40363ccda647Slclee
40373ccda647Slclee case DDI_MODEL_NONE: {
40383ccda647Slclee struct vtoc user_vtoc;
40393ccda647Slclee
4040e8fb11a1Sshidokht vtoc32tovtoc(cl->cl_vtoc, user_vtoc);
40413ccda647Slclee if (ddi_copyout(&user_vtoc, (void *)arg,
40423ccda647Slclee sizeof (struct vtoc), flag)) {
40433ccda647Slclee return (EFAULT);
40443ccda647Slclee }
40453ccda647Slclee break;
40463ccda647Slclee }
40473ccda647Slclee }
40483ccda647Slclee #else /* ! _MULTI_DATAMODEL */
4049e8fb11a1Sshidokht if (ddi_copyout(&(cl->cl_vtoc), (void *)arg, sizeof (cl->cl_vtoc),
40503ccda647Slclee flag)) {
40513ccda647Slclee return (EFAULT);
40523ccda647Slclee }
40533ccda647Slclee #endif /* _MULTI_DATAMODEL */
40543ccda647Slclee #else
40553ccda647Slclee #error "No VTOC format defined."
40563ccda647Slclee #endif
40573ccda647Slclee
40583ccda647Slclee return (rval);
40593ccda647Slclee }
40603ccda647Slclee
4061342440ecSPrasad Singamsetty
4062342440ecSPrasad Singamsetty /*
4063342440ecSPrasad Singamsetty * Function: cmlb_dkio_get_extvtoc
4064342440ecSPrasad Singamsetty */
4065342440ecSPrasad Singamsetty static int
4066342440ecSPrasad Singamsetty cmlb_dkio_get_extvtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
4067342440ecSPrasad Singamsetty void *tg_cookie)
4068342440ecSPrasad Singamsetty {
4069342440ecSPrasad Singamsetty struct extvtoc ext_vtoc;
4070342440ecSPrasad Singamsetty #if defined(_SUNOS_VTOC_8)
4071342440ecSPrasad Singamsetty struct vtoc user_vtoc;
4072342440ecSPrasad Singamsetty #endif /* defined(_SUNOS_VTOC_8) */
4073342440ecSPrasad Singamsetty int rval = 0;
4074342440ecSPrasad Singamsetty
4075342440ecSPrasad Singamsetty bzero(&ext_vtoc, sizeof (struct extvtoc));
4076342440ecSPrasad Singamsetty mutex_enter(CMLB_MUTEX(cl));
40777f0b8309SEdward Pilatowicz rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie);
4078342440ecSPrasad Singamsetty
4079342440ecSPrasad Singamsetty #if defined(_SUNOS_VTOC_8)
4080342440ecSPrasad Singamsetty if (rval == EINVAL &&
4081342440ecSPrasad Singamsetty (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8)) {
4082342440ecSPrasad Singamsetty /*
4083342440ecSPrasad Singamsetty * This is to return a default label even when we do not
4084342440ecSPrasad Singamsetty * really assume a default label for the device.
4085342440ecSPrasad Singamsetty * dad driver utilizes this.
4086342440ecSPrasad Singamsetty */
4087342440ecSPrasad Singamsetty if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
4088342440ecSPrasad Singamsetty cmlb_setup_default_geometry(cl, tg_cookie);
4089342440ecSPrasad Singamsetty rval = 0;
4090342440ecSPrasad Singamsetty }
4091342440ecSPrasad Singamsetty }
4092342440ecSPrasad Singamsetty #endif
4093342440ecSPrasad Singamsetty if (rval) {
4094342440ecSPrasad Singamsetty mutex_exit(CMLB_MUTEX(cl));
4095342440ecSPrasad Singamsetty return (rval);
4096342440ecSPrasad Singamsetty }
4097342440ecSPrasad Singamsetty
4098342440ecSPrasad Singamsetty #if defined(_SUNOS_VTOC_8)
4099342440ecSPrasad Singamsetty cmlb_build_user_vtoc(cl, &user_vtoc);
4100342440ecSPrasad Singamsetty mutex_exit(CMLB_MUTEX(cl));
4101342440ecSPrasad Singamsetty
4102342440ecSPrasad Singamsetty /*
4103342440ecSPrasad Singamsetty * Checking callers data model does not make much sense here
4104342440ecSPrasad Singamsetty * since extvtoc will always be equivalent to 64bit vtoc.
4105342440ecSPrasad Singamsetty * What is important is whether the kernel is in 32 or 64 bit
4106342440ecSPrasad Singamsetty */
4107342440ecSPrasad Singamsetty
4108342440ecSPrasad Singamsetty #ifdef _LP64
4109342440ecSPrasad Singamsetty if (ddi_copyout(&user_vtoc, (void *)arg,
4110342440ecSPrasad Singamsetty sizeof (struct extvtoc), flag)) {
4111342440ecSPrasad Singamsetty return (EFAULT);
4112342440ecSPrasad Singamsetty }
4113342440ecSPrasad Singamsetty #else
4114342440ecSPrasad Singamsetty vtoc32tovtoc(user_vtoc, ext_vtoc);
4115342440ecSPrasad Singamsetty if (ddi_copyout(&ext_vtoc, (void *)arg,
4116342440ecSPrasad Singamsetty sizeof (struct extvtoc), flag)) {
4117342440ecSPrasad Singamsetty return (EFAULT);
4118342440ecSPrasad Singamsetty }
4119342440ecSPrasad Singamsetty #endif
4120342440ecSPrasad Singamsetty
4121342440ecSPrasad Singamsetty #elif defined(_SUNOS_VTOC_16)
4122342440ecSPrasad Singamsetty /*
4123342440ecSPrasad Singamsetty * The cl_vtoc structure is a "struct dk_vtoc" which is always
4124342440ecSPrasad Singamsetty * 32-bit to maintain compatibility with existing on-disk
4125342440ecSPrasad Singamsetty * structures. Thus, we need to convert the structure when copying
4126342440ecSPrasad Singamsetty * it out to extvtoc
4127342440ecSPrasad Singamsetty */
4128342440ecSPrasad Singamsetty vtoc32tovtoc(cl->cl_vtoc, ext_vtoc);
41291fad2c0eSXiao Raymond Li mutex_exit(CMLB_MUTEX(cl));
4130342440ecSPrasad Singamsetty
4131342440ecSPrasad Singamsetty if (ddi_copyout(&ext_vtoc, (void *)arg, sizeof (struct extvtoc), flag))
4132342440ecSPrasad Singamsetty return (EFAULT);
4133342440ecSPrasad Singamsetty #else
4134342440ecSPrasad Singamsetty #error "No VTOC format defined."
4135342440ecSPrasad Singamsetty #endif
4136342440ecSPrasad Singamsetty
4137342440ecSPrasad Singamsetty return (rval);
4138342440ecSPrasad Singamsetty }
4139c31fac72SShidokht Yadegari
4140c31fac72SShidokht Yadegari /*
4141c31fac72SShidokht Yadegari * This routine implements the DKIOCGETEFI ioctl. This ioctl is currently
4142c31fac72SShidokht Yadegari * used to read the GPT Partition Table Header (primary/backup), the GUID
4143c31fac72SShidokht Yadegari * partition Entry Array (primary/backup), and the MBR.
4144c31fac72SShidokht Yadegari */
41453ccda647Slclee static int
4146e8fb11a1Sshidokht cmlb_dkio_get_efi(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
41473ccda647Slclee {
41483ccda647Slclee dk_efi_t user_efi;
41493ccda647Slclee int rval = 0;
41503ccda647Slclee void *buffer;
4151e8fb11a1Sshidokht diskaddr_t tgt_lba;
41523ccda647Slclee
41533ccda647Slclee if (ddi_copyin(arg, &user_efi, sizeof (dk_efi_t), flag))
41543ccda647Slclee return (EFAULT);
41553ccda647Slclee
41563ccda647Slclee user_efi.dki_data = (void *)(uintptr_t)user_efi.dki_data_64;
41573ccda647Slclee
4158de6d0fcdSShidokht Yadegari if (user_efi.dki_length == 0 ||
4159de6d0fcdSShidokht Yadegari user_efi.dki_length > cmlb_tg_max_efi_xfer)
4160c31fac72SShidokht Yadegari return (EINVAL);
4161c31fac72SShidokht Yadegari
4162e8fb11a1Sshidokht tgt_lba = user_efi.dki_lba;
4163e8fb11a1Sshidokht
4164e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
4165e8fb11a1Sshidokht if ((cmlb_check_update_blockcount(cl, tg_cookie) != 0) ||
4166de6d0fcdSShidokht Yadegari (cl->cl_tgt_blocksize == 0) ||
4167de6d0fcdSShidokht Yadegari (user_efi.dki_length % cl->cl_sys_blocksize)) {
4168e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
4169e8fb11a1Sshidokht return (EINVAL);
4170e8fb11a1Sshidokht }
4171e8fb11a1Sshidokht if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize)
4172e8fb11a1Sshidokht tgt_lba = tgt_lba * cl->cl_tgt_blocksize /
4173e8fb11a1Sshidokht cl->cl_sys_blocksize;
4174e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
4175e8fb11a1Sshidokht
41763ccda647Slclee buffer = kmem_alloc(user_efi.dki_length, KM_SLEEP);
4177e8fb11a1Sshidokht rval = DK_TG_READ(cl, buffer, tgt_lba, user_efi.dki_length, tg_cookie);
41783ccda647Slclee if (rval == 0 && ddi_copyout(buffer, user_efi.dki_data,
41793ccda647Slclee user_efi.dki_length, flag) != 0)
41803ccda647Slclee rval = EFAULT;
41813ccda647Slclee
41823ccda647Slclee kmem_free(buffer, user_efi.dki_length);
41833ccda647Slclee return (rval);
41843ccda647Slclee }
41853ccda647Slclee
4186e8fb11a1Sshidokht #if defined(_SUNOS_VTOC_8)
41873ccda647Slclee /*
41883ccda647Slclee * Function: cmlb_build_user_vtoc
41893ccda647Slclee *
41903ccda647Slclee * Description: This routine populates a pass by reference variable with the
41913ccda647Slclee * current volume table of contents.
41923ccda647Slclee *
4193e8fb11a1Sshidokht * Arguments: cl - driver soft state (unit) structure
41943ccda647Slclee * user_vtoc - pointer to vtoc structure to be populated
41953ccda647Slclee */
41963ccda647Slclee static void
4197e8fb11a1Sshidokht cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc)
41983ccda647Slclee {
41993ccda647Slclee struct dk_map2 *lpart;
42003ccda647Slclee struct dk_map *lmap;
42013ccda647Slclee struct partition *vpart;
4202342440ecSPrasad Singamsetty uint32_t nblks;
42033ccda647Slclee int i;
42043ccda647Slclee
4205e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
42063ccda647Slclee
42073ccda647Slclee /*
42083ccda647Slclee * Return vtoc structure fields in the provided VTOC area, addressed
42093ccda647Slclee * by *vtoc.
42103ccda647Slclee */
42113ccda647Slclee bzero(user_vtoc, sizeof (struct vtoc));
4212e8fb11a1Sshidokht user_vtoc->v_bootinfo[0] = cl->cl_vtoc.v_bootinfo[0];
4213e8fb11a1Sshidokht user_vtoc->v_bootinfo[1] = cl->cl_vtoc.v_bootinfo[1];
4214e8fb11a1Sshidokht user_vtoc->v_bootinfo[2] = cl->cl_vtoc.v_bootinfo[2];
42153ccda647Slclee user_vtoc->v_sanity = VTOC_SANE;
4216e8fb11a1Sshidokht user_vtoc->v_version = cl->cl_vtoc.v_version;
4217e8fb11a1Sshidokht bcopy(cl->cl_vtoc.v_volume, user_vtoc->v_volume, LEN_DKL_VVOL);
4218e8fb11a1Sshidokht user_vtoc->v_sectorsz = cl->cl_sys_blocksize;
4219e8fb11a1Sshidokht user_vtoc->v_nparts = cl->cl_vtoc.v_nparts;
42203ccda647Slclee
42213ccda647Slclee for (i = 0; i < 10; i++)
4222e8fb11a1Sshidokht user_vtoc->v_reserved[i] = cl->cl_vtoc.v_reserved[i];
42233ccda647Slclee
42243ccda647Slclee /*
42253ccda647Slclee * Convert partitioning information.
42263ccda647Slclee *
42273ccda647Slclee * Note the conversion from starting cylinder number
42283ccda647Slclee * to starting sector number.
42293ccda647Slclee */
4230e8fb11a1Sshidokht lmap = cl->cl_map;
4231e8fb11a1Sshidokht lpart = (struct dk_map2 *)cl->cl_vtoc.v_part;
42323ccda647Slclee vpart = user_vtoc->v_part;
42333ccda647Slclee
4234e8fb11a1Sshidokht nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead;
42353ccda647Slclee
42363ccda647Slclee for (i = 0; i < V_NUMPAR; i++) {
42373ccda647Slclee vpart->p_tag = lpart->p_tag;
42383ccda647Slclee vpart->p_flag = lpart->p_flag;
42393ccda647Slclee vpart->p_start = lmap->dkl_cylno * nblks;
42403ccda647Slclee vpart->p_size = lmap->dkl_nblk;
42413ccda647Slclee lmap++;
42423ccda647Slclee lpart++;
42433ccda647Slclee vpart++;
42443ccda647Slclee
42453ccda647Slclee /* (4364927) */
4246e8fb11a1Sshidokht user_vtoc->timestamp[i] = (time_t)cl->cl_vtoc.v_timestamp[i];
42473ccda647Slclee }
42483ccda647Slclee
4249e8fb11a1Sshidokht bcopy(cl->cl_asciilabel, user_vtoc->v_asciilabel, LEN_DKL_ASCII);
42503ccda647Slclee }
4251e8fb11a1Sshidokht #endif
42523ccda647Slclee
42533ccda647Slclee static int
4254e8fb11a1Sshidokht cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
4255e8fb11a1Sshidokht void *tg_cookie)
42563ccda647Slclee {
42573ccda647Slclee struct partition64 p64;
42583ccda647Slclee int rval = 0;
42593ccda647Slclee uint_t nparts;
42603ccda647Slclee efi_gpe_t *partitions;
42613ccda647Slclee efi_gpt_t *buffer;
42623ccda647Slclee diskaddr_t gpe_lba;
42637e74b1cbSSharath M Srinivasan int n_gpe_per_blk = 0;
42643ccda647Slclee
42653ccda647Slclee if (ddi_copyin((const void *)arg, &p64,
42663ccda647Slclee sizeof (struct partition64), flag)) {
42673ccda647Slclee return (EFAULT);
42683ccda647Slclee }
42693ccda647Slclee
42707e74b1cbSSharath M Srinivasan buffer = kmem_alloc(cl->cl_sys_blocksize, KM_SLEEP);
427165908c77Syu, larry liu - Sun Microsystems - Beijing China rval = DK_TG_READ(cl, buffer, 1, cl->cl_sys_blocksize, tg_cookie);
42723ccda647Slclee if (rval != 0)
42733ccda647Slclee goto done_error;
42743ccda647Slclee
42753ccda647Slclee cmlb_swap_efi_gpt(buffer);
42763ccda647Slclee
42773ccda647Slclee if ((rval = cmlb_validate_efi(buffer)) != 0)
42783ccda647Slclee goto done_error;
42793ccda647Slclee
42803ccda647Slclee nparts = buffer->efi_gpt_NumberOfPartitionEntries;
42813ccda647Slclee gpe_lba = buffer->efi_gpt_PartitionEntryLBA;
42827e74b1cbSSharath M Srinivasan if (p64.p_partno >= nparts) {
42833ccda647Slclee /* couldn't find it */
42843ccda647Slclee rval = ESRCH;
42853ccda647Slclee goto done_error;
42863ccda647Slclee }
42873ccda647Slclee /*
42887e74b1cbSSharath M Srinivasan * Read the block that contains the requested GPE.
42893ccda647Slclee */
42907e74b1cbSSharath M Srinivasan n_gpe_per_blk = cl->cl_sys_blocksize / sizeof (efi_gpe_t);
42917e74b1cbSSharath M Srinivasan gpe_lba += p64.p_partno / n_gpe_per_blk;
42927e74b1cbSSharath M Srinivasan rval = DK_TG_READ(cl, buffer, gpe_lba, cl->cl_sys_blocksize, tg_cookie);
42933ccda647Slclee
42943ccda647Slclee if (rval) {
42953ccda647Slclee goto done_error;
42963ccda647Slclee }
42973ccda647Slclee partitions = (efi_gpe_t *)buffer;
42989cd72fdfSSharath M Srinivasan partitions += p64.p_partno % n_gpe_per_blk;
42993ccda647Slclee
43009cd72fdfSSharath M Srinivasan /* Byte swap only the requested GPE */
43019cd72fdfSSharath M Srinivasan cmlb_swap_efi_gpe(1, partitions);
43023ccda647Slclee
43033ccda647Slclee bcopy(&partitions->efi_gpe_PartitionTypeGUID, &p64.p_type,
43043ccda647Slclee sizeof (struct uuid));
43053ccda647Slclee p64.p_start = partitions->efi_gpe_StartingLBA;
43063ccda647Slclee p64.p_size = partitions->efi_gpe_EndingLBA -
4307e8fb11a1Sshidokht p64.p_start + 1;
43083ccda647Slclee
43093ccda647Slclee if (ddi_copyout(&p64, (void *)arg, sizeof (struct partition64), flag))
43103ccda647Slclee rval = EFAULT;
43113ccda647Slclee
43123ccda647Slclee done_error:
43137e74b1cbSSharath M Srinivasan kmem_free(buffer, cl->cl_sys_blocksize);
43143ccda647Slclee return (rval);
43153ccda647Slclee }
43163ccda647Slclee
43173ccda647Slclee
43183ccda647Slclee /*
43193ccda647Slclee * Function: cmlb_dkio_set_vtoc
43203ccda647Slclee *
43213ccda647Slclee * Description: This routine is the driver entry point for handling user
43223ccda647Slclee * requests to set the current volume table of contents
43233ccda647Slclee * (DKIOCSVTOC).
43243ccda647Slclee *
4325e8fb11a1Sshidokht * Arguments:
4326e8fb11a1Sshidokht * dev the device number
4327e8fb11a1Sshidokht * arg pointer to user provided vtoc structure used to set the
43283ccda647Slclee * current vtoc.
4329e8fb11a1Sshidokht *
4330e8fb11a1Sshidokht * flag this argument is a pass through to ddi_copyxxx()
4331e8fb11a1Sshidokht * directly from the mode argument of ioctl().
4332e8fb11a1Sshidokht *
4333e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
4334e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
43353ccda647Slclee *
43363ccda647Slclee * Return Code: 0
43373ccda647Slclee * EFAULT
43383ccda647Slclee * ENXIO
43393ccda647Slclee * EINVAL
43403ccda647Slclee * ENOTSUP
43413ccda647Slclee */
43423ccda647Slclee static int
4343e8fb11a1Sshidokht cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag,
4344e8fb11a1Sshidokht void *tg_cookie)
43453ccda647Slclee {
43463ccda647Slclee struct vtoc user_vtoc;
4347406fc510SToomas Soome int shift, rval = 0;
434806bbe1e0Sedp boolean_t internal;
434906bbe1e0Sedp
43507f0b8309SEdward Pilatowicz internal = VOID2BOOLEAN(
43517f0b8309SEdward Pilatowicz (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
43523ccda647Slclee
4353406fc510SToomas Soome if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
4354406fc510SToomas Soome shift = CMLBUNIT_FORCE_P0_SHIFT;
4355406fc510SToomas Soome else
4356406fc510SToomas Soome shift = CMLBUNIT_SHIFT;
4357406fc510SToomas Soome
43583ccda647Slclee #ifdef _MULTI_DATAMODEL
43593ccda647Slclee switch (ddi_model_convert_from(flag & FMODELS)) {
43603ccda647Slclee case DDI_MODEL_ILP32: {
43613ccda647Slclee struct vtoc32 user_vtoc32;
43623ccda647Slclee
43633ccda647Slclee if (ddi_copyin((const void *)arg, &user_vtoc32,
43643ccda647Slclee sizeof (struct vtoc32), flag)) {
43653ccda647Slclee return (EFAULT);
43663ccda647Slclee }
43673ccda647Slclee vtoc32tovtoc(user_vtoc32, user_vtoc);
43683ccda647Slclee break;
43693ccda647Slclee }
43703ccda647Slclee
43713ccda647Slclee case DDI_MODEL_NONE:
43723ccda647Slclee if (ddi_copyin((const void *)arg, &user_vtoc,
43733ccda647Slclee sizeof (struct vtoc), flag)) {
43743ccda647Slclee return (EFAULT);
43753ccda647Slclee }
43763ccda647Slclee break;
43773ccda647Slclee }
43783ccda647Slclee #else /* ! _MULTI_DATAMODEL */
43793ccda647Slclee if (ddi_copyin((const void *)arg, &user_vtoc,
43803ccda647Slclee sizeof (struct vtoc), flag)) {
43813ccda647Slclee return (EFAULT);
43823ccda647Slclee }
43833ccda647Slclee #endif /* _MULTI_DATAMODEL */
43843ccda647Slclee
4385e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
4386342440ecSPrasad Singamsetty
4387342440ecSPrasad Singamsetty if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
4388e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
4389342440ecSPrasad Singamsetty return (EOVERFLOW);
43903ccda647Slclee }
4391e8fb11a1Sshidokht
439286ef0a63SRichard Lowe #if defined(__x86)
4393e8fb11a1Sshidokht if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) {
4394e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
43953ccda647Slclee return (EINVAL);
43963ccda647Slclee }
4397e8fb11a1Sshidokht #endif
43983ccda647Slclee
4399e8fb11a1Sshidokht if (cl->cl_g.dkg_ncyl == 0) {
4400e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
4401e8fb11a1Sshidokht return (EINVAL);
4402e8fb11a1Sshidokht }
4403e8fb11a1Sshidokht
4404e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
4405e8fb11a1Sshidokht cmlb_clear_efi(cl, tg_cookie);
4406e8fb11a1Sshidokht ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
4407e8fb11a1Sshidokht ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
440848794f22SSriram Popuri
440948794f22SSriram Popuri /*
441048794f22SSriram Popuri * cmlb_dkio_set_vtoc creates duplicate minor nodes when
441148794f22SSriram Popuri * relabeling an SMI disk. To avoid that we remove them
441248794f22SSriram Popuri * before creating.
441348794f22SSriram Popuri * It should be OK to remove a non-existed minor node.
441448794f22SSriram Popuri */
441548794f22SSriram Popuri ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
441648794f22SSriram Popuri ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
441748794f22SSriram Popuri
441806bbe1e0Sedp (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
4419406fc510SToomas Soome S_IFBLK, (CMLBUNIT(dev, shift) << shift) | WD_NODE,
4420531d0b66SToomas Soome cl->cl_node_type, 0, internal);
442106bbe1e0Sedp (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
4422406fc510SToomas Soome S_IFCHR, (CMLBUNIT(dev, shift) << shift) | WD_NODE,
4423531d0b66SToomas Soome cl->cl_node_type, 0, internal);
4424e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
44253ccda647Slclee
4426e8fb11a1Sshidokht if ((rval = cmlb_build_label_vtoc(cl, &user_vtoc)) == 0) {
4427e8fb11a1Sshidokht if ((rval = cmlb_write_label(cl, tg_cookie)) == 0) {
44287f0b8309SEdward Pilatowicz if (cmlb_validate_geometry(cl,
44297f0b8309SEdward Pilatowicz B_TRUE, 0, tg_cookie) != 0) {
4430e8fb11a1Sshidokht cmlb_dbg(CMLB_ERROR, cl,
44313ccda647Slclee "cmlb_dkio_set_vtoc: "
44323ccda647Slclee "Failed validate geometry\n");
44333ccda647Slclee }
4434342440ecSPrasad Singamsetty cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
44353ccda647Slclee }
44363ccda647Slclee }
4437e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
44383ccda647Slclee return (rval);
44393ccda647Slclee }
44403ccda647Slclee
4441342440ecSPrasad Singamsetty /*
4442342440ecSPrasad Singamsetty * Function: cmlb_dkio_set_extvtoc
4443342440ecSPrasad Singamsetty */
4444342440ecSPrasad Singamsetty static int
4445342440ecSPrasad Singamsetty cmlb_dkio_set_extvtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag,
4446342440ecSPrasad Singamsetty void *tg_cookie)
4447342440ecSPrasad Singamsetty {
4448406fc510SToomas Soome int shift, rval = 0;
4449342440ecSPrasad Singamsetty struct vtoc user_vtoc;
44507e70b434SShidokht Yadegari boolean_t internal;
44517e70b434SShidokht Yadegari
4452406fc510SToomas Soome if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
4453406fc510SToomas Soome shift = CMLBUNIT_FORCE_P0_SHIFT;
4454406fc510SToomas Soome else
4455406fc510SToomas Soome shift = CMLBUNIT_SHIFT;
4456342440ecSPrasad Singamsetty
4457342440ecSPrasad Singamsetty /*
4458342440ecSPrasad Singamsetty * Checking callers data model does not make much sense here
4459342440ecSPrasad Singamsetty * since extvtoc will always be equivalent to 64bit vtoc.
4460342440ecSPrasad Singamsetty * What is important is whether the kernel is in 32 or 64 bit
4461342440ecSPrasad Singamsetty */
4462342440ecSPrasad Singamsetty
4463342440ecSPrasad Singamsetty #ifdef _LP64
4464342440ecSPrasad Singamsetty if (ddi_copyin((const void *)arg, &user_vtoc,
4465342440ecSPrasad Singamsetty sizeof (struct extvtoc), flag)) {
4466342440ecSPrasad Singamsetty return (EFAULT);
4467342440ecSPrasad Singamsetty }
4468342440ecSPrasad Singamsetty #else
4469342440ecSPrasad Singamsetty struct extvtoc user_extvtoc;
4470342440ecSPrasad Singamsetty if (ddi_copyin((const void *)arg, &user_extvtoc,
4471342440ecSPrasad Singamsetty sizeof (struct extvtoc), flag)) {
4472342440ecSPrasad Singamsetty return (EFAULT);
4473342440ecSPrasad Singamsetty }
4474342440ecSPrasad Singamsetty
4475342440ecSPrasad Singamsetty vtoctovtoc32(user_extvtoc, user_vtoc);
4476342440ecSPrasad Singamsetty #endif
4477342440ecSPrasad Singamsetty
44787f0b8309SEdward Pilatowicz internal = VOID2BOOLEAN(
44797f0b8309SEdward Pilatowicz (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
4480342440ecSPrasad Singamsetty mutex_enter(CMLB_MUTEX(cl));
448186ef0a63SRichard Lowe #if defined(__x86)
4482342440ecSPrasad Singamsetty if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) {
4483342440ecSPrasad Singamsetty mutex_exit(CMLB_MUTEX(cl));
4484342440ecSPrasad Singamsetty return (EINVAL);
4485342440ecSPrasad Singamsetty }
4486342440ecSPrasad Singamsetty #endif
4487342440ecSPrasad Singamsetty
4488342440ecSPrasad Singamsetty if (cl->cl_g.dkg_ncyl == 0) {
4489342440ecSPrasad Singamsetty mutex_exit(CMLB_MUTEX(cl));
4490342440ecSPrasad Singamsetty return (EINVAL);
4491342440ecSPrasad Singamsetty }
4492342440ecSPrasad Singamsetty
4493342440ecSPrasad Singamsetty mutex_exit(CMLB_MUTEX(cl));
4494342440ecSPrasad Singamsetty cmlb_clear_efi(cl, tg_cookie);
4495342440ecSPrasad Singamsetty ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
4496342440ecSPrasad Singamsetty ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
44977abd0658SSriram Popuri /*
44987abd0658SSriram Popuri * cmlb_dkio_set_extvtoc creates duplicate minor nodes when
44997abd0658SSriram Popuri * relabeling an SMI disk. To avoid that we remove them
45007abd0658SSriram Popuri * before creating.
45017abd0658SSriram Popuri * It should be OK to remove a non-existed minor node.
45027abd0658SSriram Popuri */
45037abd0658SSriram Popuri ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
45047abd0658SSriram Popuri ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
45057abd0658SSriram Popuri
45067e70b434SShidokht Yadegari (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
4507406fc510SToomas Soome S_IFBLK, (CMLBUNIT(dev, shift) << shift) | WD_NODE,
4508531d0b66SToomas Soome cl->cl_node_type, 0, internal);
45097e70b434SShidokht Yadegari (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
4510406fc510SToomas Soome S_IFCHR, (CMLBUNIT(dev, shift) << shift) | WD_NODE,
4511531d0b66SToomas Soome cl->cl_node_type, 0, internal);
45127e70b434SShidokht Yadegari
4513342440ecSPrasad Singamsetty mutex_enter(CMLB_MUTEX(cl));
4514342440ecSPrasad Singamsetty
4515342440ecSPrasad Singamsetty if ((rval = cmlb_build_label_vtoc(cl, &user_vtoc)) == 0) {
4516342440ecSPrasad Singamsetty if ((rval = cmlb_write_label(cl, tg_cookie)) == 0) {
45177f0b8309SEdward Pilatowicz if (cmlb_validate_geometry(cl,
45187f0b8309SEdward Pilatowicz B_TRUE, 0, tg_cookie) != 0) {
4519342440ecSPrasad Singamsetty cmlb_dbg(CMLB_ERROR, cl,
4520342440ecSPrasad Singamsetty "cmlb_dkio_set_vtoc: "
4521342440ecSPrasad Singamsetty "Failed validate geometry\n");
4522342440ecSPrasad Singamsetty }
4523342440ecSPrasad Singamsetty }
4524342440ecSPrasad Singamsetty }
4525342440ecSPrasad Singamsetty mutex_exit(CMLB_MUTEX(cl));
4526342440ecSPrasad Singamsetty return (rval);
4527342440ecSPrasad Singamsetty }
45283ccda647Slclee
45293ccda647Slclee /*
45303ccda647Slclee * Function: cmlb_build_label_vtoc
45313ccda647Slclee *
45323ccda647Slclee * Description: This routine updates the driver soft state current volume table
45333ccda647Slclee * of contents based on a user specified vtoc.
45343ccda647Slclee *
4535e8fb11a1Sshidokht * Arguments: cl - driver soft state (unit) structure
45363ccda647Slclee * user_vtoc - pointer to vtoc structure specifying vtoc to be used
45373ccda647Slclee * to update the driver soft state.
45383ccda647Slclee *
45393ccda647Slclee * Return Code: 0
45403ccda647Slclee * EINVAL
45413ccda647Slclee */
45423ccda647Slclee static int
4543e8fb11a1Sshidokht cmlb_build_label_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc)
45443ccda647Slclee {
45453ccda647Slclee struct dk_map *lmap;
45463ccda647Slclee struct partition *vpart;
4547342440ecSPrasad Singamsetty uint_t nblks;
45483ccda647Slclee #if defined(_SUNOS_VTOC_8)
45493ccda647Slclee int ncyl;
45503ccda647Slclee struct dk_map2 *lpart;
45513ccda647Slclee #endif /* defined(_SUNOS_VTOC_8) */
45523ccda647Slclee int i;
45533ccda647Slclee
4554e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
45553ccda647Slclee
45563ccda647Slclee /* Sanity-check the vtoc */
45573ccda647Slclee if (user_vtoc->v_sanity != VTOC_SANE ||
4558e8fb11a1Sshidokht user_vtoc->v_sectorsz != cl->cl_sys_blocksize ||
45593ccda647Slclee user_vtoc->v_nparts != V_NUMPAR) {
4560e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl,
45613ccda647Slclee "cmlb_build_label_vtoc: vtoc not valid\n");
45623ccda647Slclee return (EINVAL);
45633ccda647Slclee }
45643ccda647Slclee
4565e8fb11a1Sshidokht nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead;
45663ccda647Slclee if (nblks == 0) {
4567e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl,
45683ccda647Slclee "cmlb_build_label_vtoc: geom nblks is 0\n");
45693ccda647Slclee return (EINVAL);
45703ccda647Slclee }
45713ccda647Slclee
45723ccda647Slclee #if defined(_SUNOS_VTOC_8)
45733ccda647Slclee vpart = user_vtoc->v_part;
45743ccda647Slclee for (i = 0; i < V_NUMPAR; i++) {
4575342440ecSPrasad Singamsetty if (((unsigned)vpart->p_start % nblks) != 0) {
4576e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl,
45773ccda647Slclee "cmlb_build_label_vtoc: p_start not multiply of"
45783ccda647Slclee "nblks part %d p_start %d nblks %d\n", i,
45793ccda647Slclee vpart->p_start, nblks);
45803ccda647Slclee return (EINVAL);
45813ccda647Slclee }
4582342440ecSPrasad Singamsetty ncyl = (unsigned)vpart->p_start / nblks;
4583342440ecSPrasad Singamsetty ncyl += (unsigned)vpart->p_size / nblks;
4584342440ecSPrasad Singamsetty if (((unsigned)vpart->p_size % nblks) != 0) {
45853ccda647Slclee ncyl++;
45863ccda647Slclee }
4587e8fb11a1Sshidokht if (ncyl > (int)cl->cl_g.dkg_ncyl) {
4588e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl,
45893ccda647Slclee "cmlb_build_label_vtoc: ncyl %d > dkg_ncyl %d"
45903ccda647Slclee "p_size %ld p_start %ld nblks %d part number %d"
45913ccda647Slclee "tag %d\n",
4592e8fb11a1Sshidokht ncyl, cl->cl_g.dkg_ncyl, vpart->p_size,
45933ccda647Slclee vpart->p_start, nblks,
45943ccda647Slclee i, vpart->p_tag);
45953ccda647Slclee
45963ccda647Slclee return (EINVAL);
45973ccda647Slclee }
45983ccda647Slclee vpart++;
45993ccda647Slclee }
46003ccda647Slclee #endif /* defined(_SUNOS_VTOC_8) */
46013ccda647Slclee
46023ccda647Slclee /* Put appropriate vtoc structure fields into the disk label */
46033ccda647Slclee #if defined(_SUNOS_VTOC_16)
46043ccda647Slclee /*
46053ccda647Slclee * The vtoc is always a 32bit data structure to maintain the
46063ccda647Slclee * on-disk format. Convert "in place" instead of doing bcopy.
46073ccda647Slclee */
4608e8fb11a1Sshidokht vtoctovtoc32((*user_vtoc), (*((struct vtoc32 *)&(cl->cl_vtoc))));
46093ccda647Slclee
46103ccda647Slclee /*
46113ccda647Slclee * in the 16-slice vtoc, starting sectors are expressed in
46123ccda647Slclee * numbers *relative* to the start of the Solaris fdisk partition.
46133ccda647Slclee */
4614e8fb11a1Sshidokht lmap = cl->cl_map;
46153ccda647Slclee vpart = user_vtoc->v_part;
46163ccda647Slclee
46173ccda647Slclee for (i = 0; i < (int)user_vtoc->v_nparts; i++, lmap++, vpart++) {
4618342440ecSPrasad Singamsetty lmap->dkl_cylno = (unsigned)vpart->p_start / nblks;
4619342440ecSPrasad Singamsetty lmap->dkl_nblk = (unsigned)vpart->p_size;
46203ccda647Slclee }
46213ccda647Slclee
46223ccda647Slclee #elif defined(_SUNOS_VTOC_8)
46233ccda647Slclee
4624e8fb11a1Sshidokht cl->cl_vtoc.v_bootinfo[0] = (uint32_t)user_vtoc->v_bootinfo[0];
4625e8fb11a1Sshidokht cl->cl_vtoc.v_bootinfo[1] = (uint32_t)user_vtoc->v_bootinfo[1];
4626e8fb11a1Sshidokht cl->cl_vtoc.v_bootinfo[2] = (uint32_t)user_vtoc->v_bootinfo[2];
46273ccda647Slclee
4628e8fb11a1Sshidokht cl->cl_vtoc.v_sanity = (uint32_t)user_vtoc->v_sanity;
4629e8fb11a1Sshidokht cl->cl_vtoc.v_version = (uint32_t)user_vtoc->v_version;
46303ccda647Slclee
4631e8fb11a1Sshidokht bcopy(user_vtoc->v_volume, cl->cl_vtoc.v_volume, LEN_DKL_VVOL);
46323ccda647Slclee
4633e8fb11a1Sshidokht cl->cl_vtoc.v_nparts = user_vtoc->v_nparts;
46343ccda647Slclee
46353ccda647Slclee for (i = 0; i < 10; i++)
4636e8fb11a1Sshidokht cl->cl_vtoc.v_reserved[i] = user_vtoc->v_reserved[i];
46373ccda647Slclee
46383ccda647Slclee /*
46393ccda647Slclee * Note the conversion from starting sector number
46403ccda647Slclee * to starting cylinder number.
46413ccda647Slclee * Return error if division results in a remainder.
46423ccda647Slclee */
4643e8fb11a1Sshidokht lmap = cl->cl_map;
4644e8fb11a1Sshidokht lpart = cl->cl_vtoc.v_part;
46453ccda647Slclee vpart = user_vtoc->v_part;
46463ccda647Slclee
46473ccda647Slclee for (i = 0; i < (int)user_vtoc->v_nparts; i++) {
46483ccda647Slclee lpart->p_tag = vpart->p_tag;
46493ccda647Slclee lpart->p_flag = vpart->p_flag;
4650342440ecSPrasad Singamsetty lmap->dkl_cylno = (unsigned)vpart->p_start / nblks;
4651342440ecSPrasad Singamsetty lmap->dkl_nblk = (unsigned)vpart->p_size;
46523ccda647Slclee
46533ccda647Slclee lmap++;
46543ccda647Slclee lpart++;
46553ccda647Slclee vpart++;
46563ccda647Slclee
46573ccda647Slclee /* (4387723) */
46583ccda647Slclee #ifdef _LP64
46593ccda647Slclee if (user_vtoc->timestamp[i] > TIME32_MAX) {
4660e8fb11a1Sshidokht cl->cl_vtoc.v_timestamp[i] = TIME32_MAX;
46613ccda647Slclee } else {
4662e8fb11a1Sshidokht cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i];
46633ccda647Slclee }
46643ccda647Slclee #else
4665e8fb11a1Sshidokht cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i];
46663ccda647Slclee #endif
46673ccda647Slclee }
46683ccda647Slclee
4669e8fb11a1Sshidokht bcopy(user_vtoc->v_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII);
46703ccda647Slclee #else
46713ccda647Slclee #error "No VTOC format defined."
46723ccda647Slclee #endif
46733ccda647Slclee return (0);
46743ccda647Slclee }
46753ccda647Slclee
46763ccda647Slclee /*
46773ccda647Slclee * Function: cmlb_clear_efi
46783ccda647Slclee *
46793ccda647Slclee * Description: This routine clears all EFI labels.
46803ccda647Slclee *
4681e8fb11a1Sshidokht * Arguments:
4682e8fb11a1Sshidokht * cl driver soft state (unit) structure
46833ccda647Slclee *
4684e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
4685e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
46863ccda647Slclee * Return Code: void
46873ccda647Slclee */
46883ccda647Slclee static void
4689e8fb11a1Sshidokht cmlb_clear_efi(struct cmlb_lun *cl, void *tg_cookie)
46903ccda647Slclee {
46913ccda647Slclee efi_gpt_t *gpt;
46923ccda647Slclee diskaddr_t cap;
46933ccda647Slclee int rval;
46943ccda647Slclee
4695e8fb11a1Sshidokht ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
4696e8fb11a1Sshidokht
4697e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
4698e8fb11a1Sshidokht cl->cl_reserved = -1;
4699e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
47003ccda647Slclee
470165908c77Syu, larry liu - Sun Microsystems - Beijing China gpt = kmem_alloc(cl->cl_sys_blocksize, KM_SLEEP);
47023ccda647Slclee
470365908c77Syu, larry liu - Sun Microsystems - Beijing China if (DK_TG_READ(cl, gpt, 1, cl->cl_sys_blocksize, tg_cookie) != 0) {
47043ccda647Slclee goto done;
47053ccda647Slclee }
47063ccda647Slclee
47073ccda647Slclee cmlb_swap_efi_gpt(gpt);
47083ccda647Slclee rval = cmlb_validate_efi(gpt);
47093ccda647Slclee if (rval == 0) {
47103ccda647Slclee /* clear primary */
47113ccda647Slclee bzero(gpt, sizeof (efi_gpt_t));
471265908c77Syu, larry liu - Sun Microsystems - Beijing China if (rval = DK_TG_WRITE(cl, gpt, 1, cl->cl_sys_blocksize,
471365908c77Syu, larry liu - Sun Microsystems - Beijing China tg_cookie)) {
4714e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl,
4715e8fb11a1Sshidokht "cmlb_clear_efi: clear primary label failed\n");
47163ccda647Slclee }
47173ccda647Slclee }
47183ccda647Slclee /* the backup */
4719e8fb11a1Sshidokht rval = DK_TG_GETCAP(cl, &cap, tg_cookie);
47203ccda647Slclee if (rval) {
47213ccda647Slclee goto done;
47223ccda647Slclee }
47233ccda647Slclee
472465908c77Syu, larry liu - Sun Microsystems - Beijing China if ((rval = DK_TG_READ(cl, gpt, cap - 1, cl->cl_sys_blocksize,
472565908c77Syu, larry liu - Sun Microsystems - Beijing China tg_cookie)) != 0) {
47263ccda647Slclee goto done;
47273ccda647Slclee }
47283ccda647Slclee cmlb_swap_efi_gpt(gpt);
47293ccda647Slclee rval = cmlb_validate_efi(gpt);
47303ccda647Slclee if (rval == 0) {
47313ccda647Slclee /* clear backup */
4732e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl,
47333ccda647Slclee "cmlb_clear_efi clear backup@%lu\n", cap - 1);
47343ccda647Slclee bzero(gpt, sizeof (efi_gpt_t));
473565908c77Syu, larry liu - Sun Microsystems - Beijing China if ((rval = DK_TG_WRITE(cl, gpt, cap - 1, cl->cl_sys_blocksize,
4736e8fb11a1Sshidokht tg_cookie))) {
4737e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl,
4738e8fb11a1Sshidokht "cmlb_clear_efi: clear backup label failed\n");
4739e8fb11a1Sshidokht }
4740e8fb11a1Sshidokht } else {
4741e8fb11a1Sshidokht /*
4742e8fb11a1Sshidokht * Refer to comments related to off-by-1 at the
4743e8fb11a1Sshidokht * header of this file
4744e8fb11a1Sshidokht */
4745e8fb11a1Sshidokht if ((rval = DK_TG_READ(cl, gpt, cap - 2,
474665908c77Syu, larry liu - Sun Microsystems - Beijing China cl->cl_sys_blocksize, tg_cookie)) != 0) {
4747e8fb11a1Sshidokht goto done;
4748e8fb11a1Sshidokht }
4749e8fb11a1Sshidokht cmlb_swap_efi_gpt(gpt);
4750e8fb11a1Sshidokht rval = cmlb_validate_efi(gpt);
4751e8fb11a1Sshidokht if (rval == 0) {
4752e8fb11a1Sshidokht /* clear legacy backup EFI label */
4753e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl,
4754e8fb11a1Sshidokht "cmlb_clear_efi clear legacy backup@%lu\n",
4755e8fb11a1Sshidokht cap - 2);
4756e8fb11a1Sshidokht bzero(gpt, sizeof (efi_gpt_t));
4757e8fb11a1Sshidokht if ((rval = DK_TG_WRITE(cl, gpt, cap - 2,
475865908c77Syu, larry liu - Sun Microsystems - Beijing China cl->cl_sys_blocksize, tg_cookie))) {
4759e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl,
4760e8fb11a1Sshidokht "cmlb_clear_efi: clear legacy backup label "
4761e8fb11a1Sshidokht "failed\n");
4762e8fb11a1Sshidokht }
47633ccda647Slclee }
47643ccda647Slclee }
47653ccda647Slclee
47663ccda647Slclee done:
476765908c77Syu, larry liu - Sun Microsystems - Beijing China kmem_free(gpt, cl->cl_sys_blocksize);
47683ccda647Slclee }
47693ccda647Slclee
47703ccda647Slclee /*
47713ccda647Slclee * Function: cmlb_set_vtoc
47723ccda647Slclee *
47733ccda647Slclee * Description: This routine writes data to the appropriate positions
47743ccda647Slclee *
4775e8fb11a1Sshidokht * Arguments:
4776e8fb11a1Sshidokht * cl driver soft state (unit) structure
4777e8fb11a1Sshidokht *
4778e8fb11a1Sshidokht * dkl the data to be written
4779e8fb11a1Sshidokht *
4780e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
4781e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
47823ccda647Slclee *
47833ccda647Slclee * Return: void
47843ccda647Slclee */
47853ccda647Slclee static int
4786e8fb11a1Sshidokht cmlb_set_vtoc(struct cmlb_lun *cl, struct dk_label *dkl, void *tg_cookie)
47873ccda647Slclee {
47883ccda647Slclee uint_t label_addr;
47893ccda647Slclee int sec;
4790342440ecSPrasad Singamsetty diskaddr_t blk;
47913ccda647Slclee int head;
47923ccda647Slclee int cyl;
47933ccda647Slclee int rval;
47943ccda647Slclee
479586ef0a63SRichard Lowe #if defined(__x86)
4796e8fb11a1Sshidokht label_addr = cl->cl_solaris_offset + DK_LABEL_LOC;
47973ccda647Slclee #else
47983ccda647Slclee /* Write the primary label at block 0 of the solaris partition. */
47993ccda647Slclee label_addr = 0;
48003ccda647Slclee #endif
48013ccda647Slclee
4802e8fb11a1Sshidokht rval = DK_TG_WRITE(cl, dkl, label_addr, cl->cl_sys_blocksize,
4803e8fb11a1Sshidokht tg_cookie);
48043ccda647Slclee
48053ccda647Slclee if (rval != 0) {
48063ccda647Slclee return (rval);
48073ccda647Slclee }
48083ccda647Slclee
48093ccda647Slclee /*
48103ccda647Slclee * Calculate where the backup labels go. They are always on
48113ccda647Slclee * the last alternate cylinder, but some older drives put them
48123ccda647Slclee * on head 2 instead of the last head. They are always on the
48133ccda647Slclee * first 5 odd sectors of the appropriate track.
48143ccda647Slclee *
48153ccda647Slclee * We have no choice at this point, but to believe that the
48163ccda647Slclee * disk label is valid. Use the geometry of the disk
48173ccda647Slclee * as described in the label.
48183ccda647Slclee */
48193ccda647Slclee cyl = dkl->dkl_ncyl + dkl->dkl_acyl - 1;
48203ccda647Slclee head = dkl->dkl_nhead - 1;
48213ccda647Slclee
48223ccda647Slclee /*
48233ccda647Slclee * Write and verify the backup labels. Make sure we don't try to
48243ccda647Slclee * write past the last cylinder.
48253ccda647Slclee */
48263ccda647Slclee for (sec = 1; ((sec < 5 * 2 + 1) && (sec < dkl->dkl_nsect)); sec += 2) {
4827342440ecSPrasad Singamsetty blk = (diskaddr_t)(
48283ccda647Slclee (cyl * ((dkl->dkl_nhead * dkl->dkl_nsect) - dkl->dkl_apc)) +
48293ccda647Slclee (head * dkl->dkl_nsect) + sec);
483086ef0a63SRichard Lowe #if defined(__x86)
4831e8fb11a1Sshidokht blk += cl->cl_solaris_offset;
48323ccda647Slclee #endif
4833e8fb11a1Sshidokht rval = DK_TG_WRITE(cl, dkl, blk, cl->cl_sys_blocksize,
4834e8fb11a1Sshidokht tg_cookie);
4835e8fb11a1Sshidokht cmlb_dbg(CMLB_INFO, cl,
4836342440ecSPrasad Singamsetty "cmlb_set_vtoc: wrote backup label %llx\n", blk);
48373ccda647Slclee if (rval != 0) {
48383ccda647Slclee goto exit;
48393ccda647Slclee }
48403ccda647Slclee }
48413ccda647Slclee exit:
48423ccda647Slclee return (rval);
48433ccda647Slclee }
48443ccda647Slclee
48453ccda647Slclee /*
48463ccda647Slclee * Function: cmlb_clear_vtoc
48473ccda647Slclee *
48483ccda647Slclee * Description: This routine clears out the VTOC labels.
48493ccda647Slclee *
4850e8fb11a1Sshidokht * Arguments:
4851e8fb11a1Sshidokht * cl driver soft state (unit) structure
4852e8fb11a1Sshidokht *
4853e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
4854e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
48553ccda647Slclee *
48563ccda647Slclee * Return: void
48573ccda647Slclee */
48583ccda647Slclee static void
4859e8fb11a1Sshidokht cmlb_clear_vtoc(struct cmlb_lun *cl, void *tg_cookie)
48603ccda647Slclee {
48613ccda647Slclee struct dk_label *dkl;
48623ccda647Slclee
4863e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
486465908c77Syu, larry liu - Sun Microsystems - Beijing China dkl = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP);
4865e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
48663ccda647Slclee /*
48673ccda647Slclee * cmlb_set_vtoc uses these fields in order to figure out
48683ccda647Slclee * where to overwrite the backup labels
48693ccda647Slclee */
4870e8fb11a1Sshidokht dkl->dkl_apc = cl->cl_g.dkg_apc;
4871e8fb11a1Sshidokht dkl->dkl_ncyl = cl->cl_g.dkg_ncyl;
4872e8fb11a1Sshidokht dkl->dkl_acyl = cl->cl_g.dkg_acyl;
4873e8fb11a1Sshidokht dkl->dkl_nhead = cl->cl_g.dkg_nhead;
4874e8fb11a1Sshidokht dkl->dkl_nsect = cl->cl_g.dkg_nsect;
4875e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
4876e8fb11a1Sshidokht (void) cmlb_set_vtoc(cl, dkl, tg_cookie);
487765908c77Syu, larry liu - Sun Microsystems - Beijing China kmem_free(dkl, cl->cl_sys_blocksize);
48783ccda647Slclee
4879e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
48803ccda647Slclee }
48813ccda647Slclee
48823ccda647Slclee /*
48833ccda647Slclee * Function: cmlb_write_label
48843ccda647Slclee *
48853ccda647Slclee * Description: This routine will validate and write the driver soft state vtoc
48863ccda647Slclee * contents to the device.
48873ccda647Slclee *
4888e8fb11a1Sshidokht * Arguments:
4889e8fb11a1Sshidokht * cl cmlb handle
4890e8fb11a1Sshidokht *
4891e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
4892e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
4893e8fb11a1Sshidokht *
48943ccda647Slclee *
48953ccda647Slclee * Return Code: the code returned by cmlb_send_scsi_cmd()
48963ccda647Slclee * 0
48973ccda647Slclee * EINVAL
48983ccda647Slclee * ENXIO
48993ccda647Slclee * ENOMEM
49003ccda647Slclee */
49013ccda647Slclee static int
4902e8fb11a1Sshidokht cmlb_write_label(struct cmlb_lun *cl, void *tg_cookie)
49033ccda647Slclee {
49043ccda647Slclee struct dk_label *dkl;
49053ccda647Slclee short sum;
49063ccda647Slclee short *sp;
49073ccda647Slclee int i;
49083ccda647Slclee int rval;
49093ccda647Slclee
4910e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
4911e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
491265908c77Syu, larry liu - Sun Microsystems - Beijing China dkl = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP);
4913e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
4914e8fb11a1Sshidokht
4915e8fb11a1Sshidokht bcopy(&cl->cl_vtoc, &dkl->dkl_vtoc, sizeof (struct dk_vtoc));
4916e8fb11a1Sshidokht dkl->dkl_rpm = cl->cl_g.dkg_rpm;
4917e8fb11a1Sshidokht dkl->dkl_pcyl = cl->cl_g.dkg_pcyl;
4918e8fb11a1Sshidokht dkl->dkl_apc = cl->cl_g.dkg_apc;
4919e8fb11a1Sshidokht dkl->dkl_intrlv = cl->cl_g.dkg_intrlv;
4920e8fb11a1Sshidokht dkl->dkl_ncyl = cl->cl_g.dkg_ncyl;
4921e8fb11a1Sshidokht dkl->dkl_acyl = cl->cl_g.dkg_acyl;
4922e8fb11a1Sshidokht dkl->dkl_nhead = cl->cl_g.dkg_nhead;
4923e8fb11a1Sshidokht dkl->dkl_nsect = cl->cl_g.dkg_nsect;
49243ccda647Slclee
49253ccda647Slclee #if defined(_SUNOS_VTOC_8)
4926e8fb11a1Sshidokht dkl->dkl_obs1 = cl->cl_g.dkg_obs1;
4927e8fb11a1Sshidokht dkl->dkl_obs2 = cl->cl_g.dkg_obs2;
4928e8fb11a1Sshidokht dkl->dkl_obs3 = cl->cl_g.dkg_obs3;
49293ccda647Slclee for (i = 0; i < NDKMAP; i++) {
4930e8fb11a1Sshidokht dkl->dkl_map[i].dkl_cylno = cl->cl_map[i].dkl_cylno;
4931e8fb11a1Sshidokht dkl->dkl_map[i].dkl_nblk = cl->cl_map[i].dkl_nblk;
49323ccda647Slclee }
4933e8fb11a1Sshidokht bcopy(cl->cl_asciilabel, dkl->dkl_asciilabel, LEN_DKL_ASCII);
49343ccda647Slclee #elif defined(_SUNOS_VTOC_16)
4935e8fb11a1Sshidokht dkl->dkl_skew = cl->cl_dkg_skew;
49363ccda647Slclee #else
49373ccda647Slclee #error "No VTOC format defined."
49383ccda647Slclee #endif
49393ccda647Slclee
49403ccda647Slclee dkl->dkl_magic = DKL_MAGIC;
4941e8fb11a1Sshidokht dkl->dkl_write_reinstruct = cl->cl_g.dkg_write_reinstruct;
4942e8fb11a1Sshidokht dkl->dkl_read_reinstruct = cl->cl_g.dkg_read_reinstruct;
49433ccda647Slclee
49443ccda647Slclee /* Construct checksum for the new disk label */
49453ccda647Slclee sum = 0;
49463ccda647Slclee sp = (short *)dkl;
49473ccda647Slclee i = sizeof (struct dk_label) / sizeof (short);
49483ccda647Slclee while (i--) {
49493ccda647Slclee sum ^= *sp++;
49503ccda647Slclee }
49513ccda647Slclee dkl->dkl_cksum = sum;
49523ccda647Slclee
4953e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
49543ccda647Slclee
4955e8fb11a1Sshidokht rval = cmlb_set_vtoc(cl, dkl, tg_cookie);
49563ccda647Slclee exit:
495765908c77Syu, larry liu - Sun Microsystems - Beijing China kmem_free(dkl, cl->cl_sys_blocksize);
4958e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
49593ccda647Slclee return (rval);
49603ccda647Slclee }
49613ccda647Slclee
4962c31fac72SShidokht Yadegari /*
4963c31fac72SShidokht Yadegari * This routine implements the DKIOCSETEFI ioctl. This ioctl is currently
4964c31fac72SShidokht Yadegari * used to write (or clear) the GPT Partition Table header (primary/backup)
4965c31fac72SShidokht Yadegari * and GUID partition Entry Array (primary/backup). It is also used to write
4966c31fac72SShidokht Yadegari * the Protective MBR.
4967c31fac72SShidokht Yadegari */
49683ccda647Slclee static int
4969e8fb11a1Sshidokht cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag,
4970e8fb11a1Sshidokht void *tg_cookie)
49713ccda647Slclee {
49723ccda647Slclee dk_efi_t user_efi;
4973406fc510SToomas Soome int shift, rval = 0;
49743ccda647Slclee void *buffer;
4975e8fb11a1Sshidokht diskaddr_t tgt_lba;
497606bbe1e0Sedp boolean_t internal;
49773ccda647Slclee
49783ccda647Slclee if (ddi_copyin(arg, &user_efi, sizeof (dk_efi_t), flag))
49793ccda647Slclee return (EFAULT);
49803ccda647Slclee
49817f0b8309SEdward Pilatowicz internal = VOID2BOOLEAN(
49827f0b8309SEdward Pilatowicz (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
498306bbe1e0Sedp
4984406fc510SToomas Soome if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
4985406fc510SToomas Soome shift = CMLBUNIT_FORCE_P0_SHIFT;
4986406fc510SToomas Soome else
4987406fc510SToomas Soome shift = CMLBUNIT_SHIFT;
4988406fc510SToomas Soome
49893ccda647Slclee user_efi.dki_data = (void *)(uintptr_t)user_efi.dki_data_64;
49903ccda647Slclee
4991de6d0fcdSShidokht Yadegari if (user_efi.dki_length == 0 ||
4992de6d0fcdSShidokht Yadegari user_efi.dki_length > cmlb_tg_max_efi_xfer)
4993c31fac72SShidokht Yadegari return (EINVAL);
4994c31fac72SShidokht Yadegari
4995de6d0fcdSShidokht Yadegari tgt_lba = user_efi.dki_lba;
4996de6d0fcdSShidokht Yadegari
4997de6d0fcdSShidokht Yadegari mutex_enter(CMLB_MUTEX(cl));
4998de6d0fcdSShidokht Yadegari if ((cmlb_check_update_blockcount(cl, tg_cookie) != 0) ||
4999de6d0fcdSShidokht Yadegari (cl->cl_tgt_blocksize == 0) ||
5000de6d0fcdSShidokht Yadegari (user_efi.dki_length % cl->cl_sys_blocksize)) {
5001de6d0fcdSShidokht Yadegari mutex_exit(CMLB_MUTEX(cl));
5002de6d0fcdSShidokht Yadegari return (EINVAL);
5003de6d0fcdSShidokht Yadegari }
5004de6d0fcdSShidokht Yadegari if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize)
5005de6d0fcdSShidokht Yadegari tgt_lba = tgt_lba *
5006de6d0fcdSShidokht Yadegari cl->cl_tgt_blocksize / cl->cl_sys_blocksize;
5007de6d0fcdSShidokht Yadegari mutex_exit(CMLB_MUTEX(cl));
5008de6d0fcdSShidokht Yadegari
50093ccda647Slclee buffer = kmem_alloc(user_efi.dki_length, KM_SLEEP);
50103ccda647Slclee if (ddi_copyin(user_efi.dki_data, buffer, user_efi.dki_length, flag)) {
50113ccda647Slclee rval = EFAULT;
50123ccda647Slclee } else {
50133ccda647Slclee /*
50143ccda647Slclee * let's clear the vtoc labels and clear the softstate
50153ccda647Slclee * vtoc.
50163ccda647Slclee */
5017e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
5018e8fb11a1Sshidokht if (cl->cl_vtoc.v_sanity == VTOC_SANE) {
5019e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl,
5020e8fb11a1Sshidokht "cmlb_dkio_set_efi: CLEAR VTOC\n");
5021342440ecSPrasad Singamsetty if (cl->cl_label_from_media == CMLB_LABEL_VTOC)
5022e8fb11a1Sshidokht cmlb_clear_vtoc(cl, tg_cookie);
5023e8fb11a1Sshidokht bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
5024e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
5025e8fb11a1Sshidokht ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
5026e8fb11a1Sshidokht ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
502706bbe1e0Sedp (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd",
50283ccda647Slclee S_IFBLK,
5029406fc510SToomas Soome (CMLBUNIT(dev, shift) << shift) | WD_NODE,
5030531d0b66SToomas Soome cl->cl_node_type, 0, internal);
503106bbe1e0Sedp (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd,raw",
50323ccda647Slclee S_IFCHR,
5033406fc510SToomas Soome (CMLBUNIT(dev, shift) << shift) | WD_NODE,
5034531d0b66SToomas Soome cl->cl_node_type, 0, internal);
50353ccda647Slclee } else
5036e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
5037e8fb11a1Sshidokht
5038e8fb11a1Sshidokht rval = DK_TG_WRITE(cl, buffer, tgt_lba, user_efi.dki_length,
5039e8fb11a1Sshidokht tg_cookie);
5040e8fb11a1Sshidokht
50413ccda647Slclee if (rval == 0) {
5042e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
50437f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_FALSE;
5044e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
50453ccda647Slclee }
50463ccda647Slclee }
50473ccda647Slclee kmem_free(buffer, user_efi.dki_length);
50483ccda647Slclee return (rval);
50493ccda647Slclee }
50503ccda647Slclee
50513ccda647Slclee /*
50523ccda647Slclee * Function: cmlb_dkio_get_mboot
50533ccda647Slclee *
50543ccda647Slclee * Description: This routine is the driver entry point for handling user
50553ccda647Slclee * requests to get the current device mboot (DKIOCGMBOOT)
50563ccda647Slclee *
50573ccda647Slclee * Arguments:
5058e8fb11a1Sshidokht * arg pointer to user provided mboot structure specifying
50593ccda647Slclee * the current mboot.
5060e8fb11a1Sshidokht *
5061e8fb11a1Sshidokht * flag this argument is a pass through to ddi_copyxxx()
5062e8fb11a1Sshidokht * directly from the mode argument of ioctl().
5063e8fb11a1Sshidokht *
5064e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
5065e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
50663ccda647Slclee *
50673ccda647Slclee * Return Code: 0
50683ccda647Slclee * EINVAL
50693ccda647Slclee * EFAULT
50703ccda647Slclee * ENXIO
50713ccda647Slclee */
50723ccda647Slclee static int
5073e8fb11a1Sshidokht cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
50743ccda647Slclee {
50753ccda647Slclee struct mboot *mboot;
50763ccda647Slclee int rval;
50773ccda647Slclee size_t buffer_size;
50783ccda647Slclee
50793ccda647Slclee
50803ccda647Slclee #if defined(_SUNOS_VTOC_8)
5081e8fb11a1Sshidokht if ((!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) || (arg == NULL)) {
50823ccda647Slclee #elif defined(_SUNOS_VTOC_16)
50833ccda647Slclee if (arg == NULL) {
50843ccda647Slclee #endif
50853ccda647Slclee return (EINVAL);
50863ccda647Slclee }
50873ccda647Slclee
50883ccda647Slclee /*
50893ccda647Slclee * Read the mboot block, located at absolute block 0 on the target.
50903ccda647Slclee */
509165908c77Syu, larry liu - Sun Microsystems - Beijing China buffer_size = cl->cl_sys_blocksize;
50923ccda647Slclee
5093e8fb11a1Sshidokht cmlb_dbg(CMLB_TRACE, cl,
50943ccda647Slclee "cmlb_dkio_get_mboot: allocation size: 0x%x\n", buffer_size);
50953ccda647Slclee
50963ccda647Slclee mboot = kmem_zalloc(buffer_size, KM_SLEEP);
5097e8fb11a1Sshidokht if ((rval = DK_TG_READ(cl, mboot, 0, buffer_size, tg_cookie)) == 0) {
50983ccda647Slclee if (ddi_copyout(mboot, (void *)arg,
50993ccda647Slclee sizeof (struct mboot), flag) != 0) {
51003ccda647Slclee rval = EFAULT;
51013ccda647Slclee }
51023ccda647Slclee }
51033ccda647Slclee kmem_free(mboot, buffer_size);
51043ccda647Slclee return (rval);
51053ccda647Slclee }
51063ccda647Slclee
51073ccda647Slclee
51083ccda647Slclee /*
51093ccda647Slclee * Function: cmlb_dkio_set_mboot
51103ccda647Slclee *
51113ccda647Slclee * Description: This routine is the driver entry point for handling user
51123ccda647Slclee * requests to validate and set the device master boot
51133ccda647Slclee * (DKIOCSMBOOT).
51143ccda647Slclee *
51153ccda647Slclee * Arguments:
5116e8fb11a1Sshidokht * arg pointer to user provided mboot structure used to set the
51173ccda647Slclee * master boot.
5118e8fb11a1Sshidokht *
5119e8fb11a1Sshidokht * flag this argument is a pass through to ddi_copyxxx()
5120e8fb11a1Sshidokht * directly from the mode argument of ioctl().
5121e8fb11a1Sshidokht *
5122e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
5123e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
51243ccda647Slclee *
51253ccda647Slclee * Return Code: 0
51263ccda647Slclee * EINVAL
51273ccda647Slclee * EFAULT
51283ccda647Slclee * ENXIO
51293ccda647Slclee */
51303ccda647Slclee static int
5131e8fb11a1Sshidokht cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
51323ccda647Slclee {
51333ccda647Slclee struct mboot *mboot = NULL;
51343ccda647Slclee int rval;
51353ccda647Slclee ushort_t magic;
51363ccda647Slclee
51373ccda647Slclee
5138e8fb11a1Sshidokht ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
51393ccda647Slclee
51403ccda647Slclee #if defined(_SUNOS_VTOC_8)
5141e8fb11a1Sshidokht if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
51423ccda647Slclee return (EINVAL);
51433ccda647Slclee }
51443ccda647Slclee #endif
51453ccda647Slclee
51463ccda647Slclee if (arg == NULL) {
51473ccda647Slclee return (EINVAL);
51483ccda647Slclee }
51493ccda647Slclee
515065908c77Syu, larry liu - Sun Microsystems - Beijing China mboot = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP);
51513ccda647Slclee
51523ccda647Slclee if (ddi_copyin((const void *)arg, mboot,
515365908c77Syu, larry liu - Sun Microsystems - Beijing China cl->cl_sys_blocksize, flag) != 0) {
515465908c77Syu, larry liu - Sun Microsystems - Beijing China kmem_free(mboot, cl->cl_sys_blocksize);
51553ccda647Slclee return (EFAULT);
51563ccda647Slclee }
51573ccda647Slclee
51583ccda647Slclee /* Is this really a master boot record? */
51593ccda647Slclee magic = LE_16(mboot->signature);
51603ccda647Slclee if (magic != MBB_MAGIC) {
516165908c77Syu, larry liu - Sun Microsystems - Beijing China kmem_free(mboot, cl->cl_sys_blocksize);
51623ccda647Slclee return (EINVAL);
51633ccda647Slclee }
51643ccda647Slclee
5165e8fb11a1Sshidokht rval = DK_TG_WRITE(cl, mboot, 0, cl->cl_sys_blocksize, tg_cookie);
51663ccda647Slclee
5167e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
516886ef0a63SRichard Lowe #if defined(__x86)
51693ccda647Slclee if (rval == 0) {
51703ccda647Slclee /*
51713ccda647Slclee * mboot has been written successfully.
51723ccda647Slclee * update the fdisk and vtoc tables in memory
51733ccda647Slclee */
5174e8fb11a1Sshidokht rval = cmlb_update_fdisk_and_vtoc(cl, tg_cookie);
51757f0b8309SEdward Pilatowicz if ((!cl->cl_f_geometry_is_valid) || (rval != 0)) {
5176e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
517765908c77Syu, larry liu - Sun Microsystems - Beijing China kmem_free(mboot, cl->cl_sys_blocksize);
51783ccda647Slclee return (rval);
51793ccda647Slclee }
51803ccda647Slclee }
5181e8fb11a1Sshidokht
5182e8fb11a1Sshidokht #ifdef __lock_lint
5183e8fb11a1Sshidokht cmlb_setup_default_geometry(cl, tg_cookie);
5184e8fb11a1Sshidokht #endif
5185e8fb11a1Sshidokht
51863ccda647Slclee #else
51873ccda647Slclee if (rval == 0) {
51883ccda647Slclee /*
51893ccda647Slclee * mboot has been written successfully.
51903ccda647Slclee * set up the default geometry and VTOC
51913ccda647Slclee */
5192342440ecSPrasad Singamsetty if (cl->cl_blockcount <= CMLB_EXTVTOC_LIMIT)
5193e8fb11a1Sshidokht cmlb_setup_default_geometry(cl, tg_cookie);
51943ccda647Slclee }
51953ccda647Slclee #endif
5196342440ecSPrasad Singamsetty cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
5197e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
519865908c77Syu, larry liu - Sun Microsystems - Beijing China kmem_free(mboot, cl->cl_sys_blocksize);
51993ccda647Slclee return (rval);
52003ccda647Slclee }
52013ccda647Slclee
52023ccda647Slclee
520386ef0a63SRichard Lowe #if defined(__x86)
5204aa1b14e7SSheshadri Vasudevan /*ARGSUSED*/
5205aa1b14e7SSheshadri Vasudevan static int
5206aa1b14e7SSheshadri Vasudevan cmlb_dkio_set_ext_part(struct cmlb_lun *cl, caddr_t arg, int flag,
5207aa1b14e7SSheshadri Vasudevan void *tg_cookie)
5208aa1b14e7SSheshadri Vasudevan {
5209aa1b14e7SSheshadri Vasudevan int fdisk_rval;
5210aa1b14e7SSheshadri Vasudevan diskaddr_t capacity;
5211aa1b14e7SSheshadri Vasudevan
5212aa1b14e7SSheshadri Vasudevan ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
5213aa1b14e7SSheshadri Vasudevan
5214aa1b14e7SSheshadri Vasudevan mutex_enter(CMLB_MUTEX(cl));
5215aa1b14e7SSheshadri Vasudevan capacity = cl->cl_blockcount;
5216aa1b14e7SSheshadri Vasudevan fdisk_rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
5217aa1b14e7SSheshadri Vasudevan if (fdisk_rval != 0) {
5218aa1b14e7SSheshadri Vasudevan mutex_exit(CMLB_MUTEX(cl));
5219aa1b14e7SSheshadri Vasudevan return (fdisk_rval);
5220aa1b14e7SSheshadri Vasudevan }
5221aa1b14e7SSheshadri Vasudevan
5222aa1b14e7SSheshadri Vasudevan mutex_exit(CMLB_MUTEX(cl));
5223aa1b14e7SSheshadri Vasudevan return (fdisk_rval);
5224aa1b14e7SSheshadri Vasudevan }
5225aa1b14e7SSheshadri Vasudevan #endif
5226aa1b14e7SSheshadri Vasudevan
52273ccda647Slclee /*
52283ccda647Slclee * Function: cmlb_setup_default_geometry
52293ccda647Slclee *
52303ccda647Slclee * Description: This local utility routine sets the default geometry as part of
52313ccda647Slclee * setting the device mboot.
52323ccda647Slclee *
5233e8fb11a1Sshidokht * Arguments:
5234e8fb11a1Sshidokht * cl driver soft state (unit) structure
5235e8fb11a1Sshidokht *
5236e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
5237e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
5238e8fb11a1Sshidokht *
52393ccda647Slclee *
52403ccda647Slclee * Note: This may be redundant with cmlb_build_default_label.
52413ccda647Slclee */
52423ccda647Slclee static void
5243e8fb11a1Sshidokht cmlb_setup_default_geometry(struct cmlb_lun *cl, void *tg_cookie)
52443ccda647Slclee {
52453ccda647Slclee struct cmlb_geom pgeom;
52463ccda647Slclee struct cmlb_geom *pgeomp = &pgeom;
52473ccda647Slclee int ret;
52483ccda647Slclee int geom_base_cap = 1;
52493ccda647Slclee
52503ccda647Slclee
5251e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
52523ccda647Slclee
52533ccda647Slclee /* zero out the soft state geometry and partition table. */
5254e8fb11a1Sshidokht bzero(&cl->cl_g, sizeof (struct dk_geom));
5255e8fb11a1Sshidokht bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
5256e8fb11a1Sshidokht bzero(cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
52573ccda647Slclee
52583ccda647Slclee /*
52593ccda647Slclee * For the rpm, we use the minimum for the disk.
52603ccda647Slclee * For the head, cyl and number of sector per track,
52613ccda647Slclee * if the capacity <= 1GB, head = 64, sect = 32.
52623ccda647Slclee * else head = 255, sect 63
52633ccda647Slclee * Note: the capacity should be equal to C*H*S values.
52643ccda647Slclee * This will cause some truncation of size due to
52653ccda647Slclee * round off errors. For CD-ROMs, this truncation can
52663ccda647Slclee * have adverse side effects, so returning ncyl and
52673ccda647Slclee * nhead as 1. The nsect will overflow for most of
52683ccda647Slclee * CD-ROMs as nsect is of type ushort.
52693ccda647Slclee */
5270e8fb11a1Sshidokht if (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) {
52713ccda647Slclee /*
52723ccda647Slclee * newfs currently can not handle 255 ntracks for SPARC
52733ccda647Slclee * so get the geometry from target driver instead of coming up
52743ccda647Slclee * with one based on capacity.
52753ccda647Slclee */
5276e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
5277e8fb11a1Sshidokht ret = DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie);
5278e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
52793ccda647Slclee
52807f0b8309SEdward Pilatowicz if (ret == 0) {
52813ccda647Slclee geom_base_cap = 0;
52823ccda647Slclee } else {
5283e8fb11a1Sshidokht cmlb_dbg(CMLB_ERROR, cl,
52843ccda647Slclee "cmlb_setup_default_geometry: "
52853ccda647Slclee "tg_getphygeom failed %d\n", ret);
52863ccda647Slclee
52873ccda647Slclee /* do default setting, geometry based on capacity */
52883ccda647Slclee }
52893ccda647Slclee }
52903ccda647Slclee
52913ccda647Slclee if (geom_base_cap) {
5292e8fb11a1Sshidokht if (ISCD(cl)) {
5293e8fb11a1Sshidokht cl->cl_g.dkg_ncyl = 1;
5294e8fb11a1Sshidokht cl->cl_g.dkg_nhead = 1;
5295e8fb11a1Sshidokht cl->cl_g.dkg_nsect = cl->cl_blockcount;
5296c31fac72SShidokht Yadegari } else if (cl->cl_blockcount < 160) {
5297c31fac72SShidokht Yadegari /* Less than 80K */
5298c31fac72SShidokht Yadegari cl->cl_g.dkg_nhead = 1;
5299c31fac72SShidokht Yadegari cl->cl_g.dkg_ncyl = cl->cl_blockcount;
5300c31fac72SShidokht Yadegari cl->cl_g.dkg_nsect = 1;
5301e8fb11a1Sshidokht } else if (cl->cl_blockcount <= 0x1000) {
53023ccda647Slclee /* Needed for unlabeled SCSI floppies. */
5303e8fb11a1Sshidokht cl->cl_g.dkg_nhead = 2;
5304e8fb11a1Sshidokht cl->cl_g.dkg_ncyl = 80;
5305e8fb11a1Sshidokht cl->cl_g.dkg_pcyl = 80;
5306e8fb11a1Sshidokht cl->cl_g.dkg_nsect = cl->cl_blockcount / (2 * 80);
5307e8fb11a1Sshidokht } else if (cl->cl_blockcount <= 0x200000) {
5308e8fb11a1Sshidokht cl->cl_g.dkg_nhead = 64;
5309e8fb11a1Sshidokht cl->cl_g.dkg_nsect = 32;
5310e8fb11a1Sshidokht cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32);
53113ccda647Slclee } else {
5312e8fb11a1Sshidokht cl->cl_g.dkg_nhead = 255;
531398a65dd4Sshidokht
531498a65dd4Sshidokht cl->cl_g.dkg_nsect = ((cl->cl_blockcount +
531598a65dd4Sshidokht (UINT16_MAX * 255 * 63) - 1) /
531698a65dd4Sshidokht (UINT16_MAX * 255 * 63)) * 63;
531798a65dd4Sshidokht
531898a65dd4Sshidokht if (cl->cl_g.dkg_nsect == 0)
531998a65dd4Sshidokht cl->cl_g.dkg_nsect = (UINT16_MAX / 63) * 63;
532098a65dd4Sshidokht
532198a65dd4Sshidokht cl->cl_g.dkg_ncyl = cl->cl_blockcount /
532298a65dd4Sshidokht (255 * cl->cl_g.dkg_nsect);
53233ccda647Slclee }
53243ccda647Slclee
5325e8fb11a1Sshidokht cl->cl_g.dkg_acyl = 0;
5326e8fb11a1Sshidokht cl->cl_g.dkg_bcyl = 0;
5327e8fb11a1Sshidokht cl->cl_g.dkg_intrlv = 1;
5328e8fb11a1Sshidokht cl->cl_g.dkg_rpm = 200;
5329e8fb11a1Sshidokht if (cl->cl_g.dkg_pcyl == 0)
5330e8fb11a1Sshidokht cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl +
5331e8fb11a1Sshidokht cl->cl_g.dkg_acyl;
53323ccda647Slclee } else {
5333e8fb11a1Sshidokht cl->cl_g.dkg_ncyl = (short)pgeomp->g_ncyl;
5334e8fb11a1Sshidokht cl->cl_g.dkg_acyl = pgeomp->g_acyl;
5335e8fb11a1Sshidokht cl->cl_g.dkg_nhead = pgeomp->g_nhead;
5336e8fb11a1Sshidokht cl->cl_g.dkg_nsect = pgeomp->g_nsect;
5337e8fb11a1Sshidokht cl->cl_g.dkg_intrlv = pgeomp->g_intrlv;
5338e8fb11a1Sshidokht cl->cl_g.dkg_rpm = pgeomp->g_rpm;
5339e8fb11a1Sshidokht cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl;
5340e8fb11a1Sshidokht }
5341e8fb11a1Sshidokht
5342e8fb11a1Sshidokht cl->cl_g.dkg_read_reinstruct = 0;
5343e8fb11a1Sshidokht cl->cl_g.dkg_write_reinstruct = 0;
5344e8fb11a1Sshidokht cl->cl_solaris_size = cl->cl_g.dkg_ncyl *
5345e8fb11a1Sshidokht cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
5346e8fb11a1Sshidokht
5347e8fb11a1Sshidokht cl->cl_map['a'-'a'].dkl_cylno = 0;
5348e8fb11a1Sshidokht cl->cl_map['a'-'a'].dkl_nblk = cl->cl_solaris_size;
5349e8fb11a1Sshidokht
5350e8fb11a1Sshidokht cl->cl_map['c'-'a'].dkl_cylno = 0;
5351e8fb11a1Sshidokht cl->cl_map['c'-'a'].dkl_nblk = cl->cl_solaris_size;
5352e8fb11a1Sshidokht
5353e8fb11a1Sshidokht cl->cl_vtoc.v_part[2].p_tag = V_BACKUP;
5354e8fb11a1Sshidokht cl->cl_vtoc.v_part[2].p_flag = V_UNMNT;
5355e8fb11a1Sshidokht cl->cl_vtoc.v_nparts = V_NUMPAR;
5356e8fb11a1Sshidokht cl->cl_vtoc.v_version = V_VERSION;
5357e8fb11a1Sshidokht (void) sprintf((char *)cl->cl_asciilabel, "DEFAULT cyl %d alt %d"
5358e8fb11a1Sshidokht " hd %d sec %d", cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
5359e8fb11a1Sshidokht cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
5360e8fb11a1Sshidokht
53617f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_FALSE;
53623ccda647Slclee }
53633ccda647Slclee
53643ccda647Slclee
536586ef0a63SRichard Lowe #if defined(__x86)
53663ccda647Slclee /*
53673ccda647Slclee * Function: cmlb_update_fdisk_and_vtoc
53683ccda647Slclee *
53693ccda647Slclee * Description: This local utility routine updates the device fdisk and vtoc
53703ccda647Slclee * as part of setting the device mboot.
53713ccda647Slclee *
5372e8fb11a1Sshidokht * Arguments:
5373e8fb11a1Sshidokht * cl driver soft state (unit) structure
5374e8fb11a1Sshidokht *
5375e8fb11a1Sshidokht * tg_cookie cookie from target driver to be passed back to target
5376e8fb11a1Sshidokht * driver when we call back to it through tg_ops.
5377e8fb11a1Sshidokht *
53783ccda647Slclee *
53793ccda647Slclee * Return Code: 0 for success or errno-type return code.
53803ccda647Slclee *
53813ccda647Slclee * Note:x86: This looks like a duplicate of cmlb_validate_geometry(), but
53823ccda647Slclee * these did exist separately in x86 sd.c.
53833ccda647Slclee */
53843ccda647Slclee static int
5385e8fb11a1Sshidokht cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie)
53863ccda647Slclee {
53873ccda647Slclee int count;
53883ccda647Slclee int label_rc = 0;
53893ccda647Slclee int fdisk_rval;
53903ccda647Slclee diskaddr_t capacity;
53913ccda647Slclee
5392e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
53933ccda647Slclee
5394e8fb11a1Sshidokht if (cmlb_check_update_blockcount(cl, tg_cookie) != 0)
53953ccda647Slclee return (EINVAL);
53963ccda647Slclee
53973ccda647Slclee /*
53983ccda647Slclee * Set up the "whole disk" fdisk partition; this should always
53993ccda647Slclee * exist, regardless of whether the disk contains an fdisk table
54003ccda647Slclee * or vtoc.
54013ccda647Slclee */
5402e8fb11a1Sshidokht cl->cl_map[P0_RAW_DISK].dkl_cylno = 0;
5403e8fb11a1Sshidokht cl->cl_map[P0_RAW_DISK].dkl_nblk = cl->cl_blockcount;
54043ccda647Slclee
54053ccda647Slclee /*
54063ccda647Slclee * copy the lbasize and capacity so that if they're
5407e8fb11a1Sshidokht * reset while we're not holding the CMLB_MUTEX(cl), we will
5408e8fb11a1Sshidokht * continue to use valid values after the CMLB_MUTEX(cl) is
54093ccda647Slclee * reacquired.
54103ccda647Slclee */
5411e8fb11a1Sshidokht capacity = cl->cl_blockcount;
54123ccda647Slclee
54133ccda647Slclee /*
54143ccda647Slclee * refresh the logical and physical geometry caches.
54153ccda647Slclee * (data from mode sense format/rigid disk geometry pages,
54163ccda647Slclee * and scsi_ifgetcap("geometry").
54173ccda647Slclee */
5418e8fb11a1Sshidokht cmlb_resync_geom_caches(cl, capacity, tg_cookie);
54193ccda647Slclee
54203ccda647Slclee /*
5421e8fb11a1Sshidokht * Only DIRECT ACCESS devices will have Scl labels.
5422e8fb11a1Sshidokht * CD's supposedly have a Scl label, too
54233ccda647Slclee */
5424e8fb11a1Sshidokht if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) {
5425e8fb11a1Sshidokht fdisk_rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
54263ccda647Slclee if (fdisk_rval != 0) {
5427e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
54283ccda647Slclee return (fdisk_rval);
54293ccda647Slclee }
54303ccda647Slclee
5431e8fb11a1Sshidokht if (cl->cl_solaris_size <= DK_LABEL_LOC) {
54323ccda647Slclee /*
54333ccda647Slclee * Found fdisk table but no Solaris partition entry,
54343ccda647Slclee * so don't call cmlb_uselabel() and don't create
54353ccda647Slclee * a default label.
54363ccda647Slclee */
54373ccda647Slclee label_rc = 0;
54387f0b8309SEdward Pilatowicz cl->cl_f_geometry_is_valid = B_TRUE;
54393ccda647Slclee goto no_solaris_partition;
54403ccda647Slclee }
54413ccda647Slclee } else if (capacity < 0) {
5442e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
54433ccda647Slclee return (EINVAL);
54443ccda647Slclee }
54453ccda647Slclee
54463ccda647Slclee /*
54473ccda647Slclee * For Removable media We reach here if we have found a
54483ccda647Slclee * SOLARIS PARTITION.
54497f0b8309SEdward Pilatowicz * If cl_f_geometry_is_valid is B_FALSE it indicates that the SOLARIS
54503ccda647Slclee * PARTITION has changed from the previous one, hence we will setup a
54513ccda647Slclee * default VTOC in this case.
54523ccda647Slclee */
54537f0b8309SEdward Pilatowicz if (!cl->cl_f_geometry_is_valid) {
54543ccda647Slclee /* if we get here it is writable */
54553ccda647Slclee /* we are called from SMBOOT, and after a write of fdisk */
5456e8fb11a1Sshidokht cmlb_build_default_label(cl, tg_cookie);
54573ccda647Slclee label_rc = 0;
54583ccda647Slclee }
54593ccda647Slclee
54603ccda647Slclee no_solaris_partition:
54613ccda647Slclee
54623ccda647Slclee #if defined(_SUNOS_VTOC_16)
54633ccda647Slclee /*
54643ccda647Slclee * If we have valid geometry, set up the remaining fdisk partitions.
54653ccda647Slclee * Note that dkl_cylno is not used for the fdisk map entries, so
54663ccda647Slclee * we set it to an entirely bogus value.
54673ccda647Slclee */
5468aa1b14e7SSheshadri Vasudevan for (count = 0; count < FDISK_PARTS; count++) {
5469342440ecSPrasad Singamsetty cl->cl_map[FDISK_P1 + count].dkl_cylno = UINT32_MAX;
5470e8fb11a1Sshidokht cl->cl_map[FDISK_P1 + count].dkl_nblk =
5471e8fb11a1Sshidokht cl->cl_fmap[count].fmap_nblk;
5472e8fb11a1Sshidokht cl->cl_offset[FDISK_P1 + count] =
5473e8fb11a1Sshidokht cl->cl_fmap[count].fmap_start;
54743ccda647Slclee }
54753ccda647Slclee #endif
54763ccda647Slclee
54773ccda647Slclee for (count = 0; count < NDKMAP; count++) {
54783ccda647Slclee #if defined(_SUNOS_VTOC_8)
5479e8fb11a1Sshidokht struct dk_map *lp = &cl->cl_map[count];
5480e8fb11a1Sshidokht cl->cl_offset[count] =
5481e8fb11a1Sshidokht cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
54823ccda647Slclee #elif defined(_SUNOS_VTOC_16)
5483e8fb11a1Sshidokht struct dkl_partition *vp = &cl->cl_vtoc.v_part[count];
5484e8fb11a1Sshidokht cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset;
54853ccda647Slclee #else
54863ccda647Slclee #error "No VTOC format defined."
54873ccda647Slclee #endif
54883ccda647Slclee }
54893ccda647Slclee
5490e8fb11a1Sshidokht ASSERT(mutex_owned(CMLB_MUTEX(cl)));
54913ccda647Slclee return (label_rc);
54923ccda647Slclee }
54933ccda647Slclee #endif
54943ccda647Slclee
549586ef0a63SRichard Lowe #if defined(__x86)
54963ccda647Slclee static int
5497e8fb11a1Sshidokht cmlb_dkio_get_virtgeom(struct cmlb_lun *cl, caddr_t arg, int flag)
54983ccda647Slclee {
54993ccda647Slclee int err = 0;
55003ccda647Slclee
55013ccda647Slclee /* Return the driver's notion of the media's logical geometry */
55023ccda647Slclee struct dk_geom disk_geom;
55033ccda647Slclee struct dk_geom *dkgp = &disk_geom;
55043ccda647Slclee
5505e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
55063ccda647Slclee /*
55073ccda647Slclee * If there is no HBA geometry available, or
55083ccda647Slclee * if the HBA returned us something that doesn't
55093ccda647Slclee * really fit into an Int 13/function 8 geometry
55103ccda647Slclee * result, just fail the ioctl. See PSARC 1998/313.
55113ccda647Slclee */
5512e8fb11a1Sshidokht if (cl->cl_lgeom.g_nhead == 0 ||
5513e8fb11a1Sshidokht cl->cl_lgeom.g_nsect == 0 ||
5514e8fb11a1Sshidokht cl->cl_lgeom.g_ncyl > 1024) {
5515e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
55163ccda647Slclee err = EINVAL;
55173ccda647Slclee } else {
5518e8fb11a1Sshidokht dkgp->dkg_ncyl = cl->cl_lgeom.g_ncyl;
5519e8fb11a1Sshidokht dkgp->dkg_acyl = cl->cl_lgeom.g_acyl;
55203ccda647Slclee dkgp->dkg_pcyl = dkgp->dkg_ncyl + dkgp->dkg_acyl;
5521e8fb11a1Sshidokht dkgp->dkg_nhead = cl->cl_lgeom.g_nhead;
5522e8fb11a1Sshidokht dkgp->dkg_nsect = cl->cl_lgeom.g_nsect;
55233ccda647Slclee
55241c97599bSshidokht mutex_exit(CMLB_MUTEX(cl));
55253ccda647Slclee if (ddi_copyout(dkgp, (void *)arg,
55263ccda647Slclee sizeof (struct dk_geom), flag)) {
55273ccda647Slclee err = EFAULT;
55283ccda647Slclee } else {
55293ccda647Slclee err = 0;
55303ccda647Slclee }
55313ccda647Slclee }
55323ccda647Slclee return (err);
55333ccda647Slclee }
55343ccda647Slclee #endif
55353ccda647Slclee
553686ef0a63SRichard Lowe #if defined(__x86)
55373ccda647Slclee static int
5538b081f1c4Syu, larry liu - Sun Microsystems - Beijing China cmlb_dkio_get_phygeom(struct cmlb_lun *cl, caddr_t arg, int flag,
5539b081f1c4Syu, larry liu - Sun Microsystems - Beijing China void *tg_cookie)
55403ccda647Slclee {
55413ccda647Slclee int err = 0;
5542e8fb11a1Sshidokht diskaddr_t capacity;
55433ccda647Slclee
55443ccda647Slclee
55453ccda647Slclee /* Return the driver's notion of the media physical geometry */
55463ccda647Slclee struct dk_geom disk_geom;
55473ccda647Slclee struct dk_geom *dkgp = &disk_geom;
55483ccda647Slclee
5549e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
55503ccda647Slclee
5551e8fb11a1Sshidokht if (cl->cl_g.dkg_nhead != 0 &&
5552e8fb11a1Sshidokht cl->cl_g.dkg_nsect != 0) {
55533ccda647Slclee /*
55543ccda647Slclee * We succeeded in getting a geometry, but
55553ccda647Slclee * right now it is being reported as just the
55563ccda647Slclee * Solaris fdisk partition, just like for
55573ccda647Slclee * DKIOCGGEOM. We need to change that to be
55583ccda647Slclee * correct for the entire disk now.
55593ccda647Slclee */
5560e8fb11a1Sshidokht bcopy(&cl->cl_g, dkgp, sizeof (*dkgp));
55613ccda647Slclee dkgp->dkg_acyl = 0;
5562e8fb11a1Sshidokht dkgp->dkg_ncyl = cl->cl_blockcount /
55633ccda647Slclee (dkgp->dkg_nhead * dkgp->dkg_nsect);
55643ccda647Slclee } else {
55653ccda647Slclee bzero(dkgp, sizeof (struct dk_geom));
55663ccda647Slclee /*
55673ccda647Slclee * This disk does not have a Solaris VTOC
55683ccda647Slclee * so we must present a physical geometry
55693ccda647Slclee * that will remain consistent regardless
55703ccda647Slclee * of how the disk is used. This will ensure
55713ccda647Slclee * that the geometry does not change regardless
55723ccda647Slclee * of the fdisk partition type (ie. EFI, FAT32,
55733ccda647Slclee * Solaris, etc).
55743ccda647Slclee */
5575e8fb11a1Sshidokht if (ISCD(cl)) {
5576e8fb11a1Sshidokht dkgp->dkg_nhead = cl->cl_pgeom.g_nhead;
5577e8fb11a1Sshidokht dkgp->dkg_nsect = cl->cl_pgeom.g_nsect;
5578e8fb11a1Sshidokht dkgp->dkg_ncyl = cl->cl_pgeom.g_ncyl;
5579e8fb11a1Sshidokht dkgp->dkg_acyl = cl->cl_pgeom.g_acyl;
55803ccda647Slclee } else {
5581e8fb11a1Sshidokht /*
5582e8fb11a1Sshidokht * Invalid cl_blockcount can generate invalid
5583e8fb11a1Sshidokht * dk_geom and may result in division by zero
5584e8fb11a1Sshidokht * system failure. Should make sure blockcount
5585e8fb11a1Sshidokht * is valid before using it here.
5586e8fb11a1Sshidokht */
5587e8fb11a1Sshidokht if (cl->cl_blockcount == 0) {
5588e8fb11a1Sshidokht mutex_exit(CMLB_MUTEX(cl));
5589e8fb11a1Sshidokht err = EIO;
5590e8fb11a1Sshidokht return (err);
5591e8fb11a1Sshidokht }
5592e8fb11a1Sshidokht /*
5593e8fb11a1Sshidokht * Refer to comments related to off-by-1 at the
5594e8fb11a1Sshidokht * header of this file
5595e8fb11a1Sshidokht */
5596e8fb11a1Sshidokht if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE)
5597e8fb11a1Sshidokht capacity = cl->cl_blockcount - 1;
5598e8fb11a1Sshidokht else
5599e8fb11a1Sshidokht capacity = cl->cl_blockcount;
5600e8fb11a1Sshidokht
5601b081f1c4Syu, larry liu - Sun Microsystems - Beijing China cmlb_convert_geometry(cl, capacity, dkgp, tg_cookie);
56023ccda647Slclee dkgp->dkg_acyl = 0;
5603e8fb11a1Sshidokht dkgp->dkg_ncyl = capacity /
56043ccda647Slclee (dkgp->dkg_nhead * dkgp->dkg_nsect);
56053ccda647Slclee }
56063ccda647Slclee }
56073ccda647Slclee dkgp->dkg_pcyl = dkgp->dkg_ncyl + dkgp->dkg_acyl;
56083ccda647Slclee
56091c97599bSshidokht mutex_exit(CMLB_MUTEX(cl));
56101c97599bSshidokht if (ddi_copyout(dkgp, (void *)arg, sizeof (struct dk_geom), flag))
56113ccda647Slclee err = EFAULT;
56121c97599bSshidokht
56133ccda647Slclee return (err);
56143ccda647Slclee }
56153ccda647Slclee #endif
56163ccda647Slclee
561786ef0a63SRichard Lowe #if defined(__x86)
56183ccda647Slclee static int
5619e8fb11a1Sshidokht cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag)
56203ccda647Slclee {
56213ccda647Slclee int err = 0;
56223ccda647Slclee
56233ccda647Slclee /*
56243ccda647Slclee * Return parameters describing the selected disk slice.
56253ccda647Slclee * Note: this ioctl is for the intel platform only
56263ccda647Slclee */
56273ccda647Slclee int part;
56283ccda647Slclee
5629406fc510SToomas Soome if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
5630406fc510SToomas Soome part = getminor(dev) & ((1 << CMLBUNIT_FORCE_P0_SHIFT) - 1);
5631406fc510SToomas Soome else
5632406fc510SToomas Soome part = CMLBPART(dev);
56333ccda647Slclee
5634e8fb11a1Sshidokht mutex_enter(CMLB_MUTEX(cl));
5635e8fb11a1Sshidokht /* don't check cl_solaris_size for pN */
5636e8fb11a1Sshidokht if (part < P0_RAW_DISK && cl->cl_solaris_size == 0) {
56373ccda647Slclee err = EIO;
56381c97599bSshidokht mutex_exit(CMLB_MUTEX(cl));
56393ccda647Slclee } else {
56403ccda647Slclee struct part_info p;
56413ccda647Slclee
5642e8fb11a1Sshidokht p.p_start = (daddr_t)cl->cl_offset[part];
5643e8fb11a1Sshidokht p.p_length = (int)cl->cl_map[part].dkl_nblk;
56441c97599bSshidokht mutex_exit(CMLB_MUTEX(cl));
56453ccda647Slclee #ifdef _MULTI_DATAMODEL
56463ccda647Slclee switch (ddi_model_convert_from(flag & FMODELS)) {
56473ccda647Slclee case DDI_MODEL_ILP32:
56483ccda647Slclee {
56493ccda647Slclee struct part_info32 p32;
56503ccda647Slclee
56513ccda647Slclee p32.p_start = (daddr32_t)p.p_start;
56523ccda647Slclee p32.p_length = p.p_length;
56533ccda647Slclee if (ddi_copyout(&p32, (void *)arg,
56543ccda647Slclee sizeof (p32), flag))
56553ccda647Slclee err = EFAULT;
56563ccda647Slclee break;
56573ccda647Slclee }
56583ccda647Slclee
56593ccda647Slclee case DDI_MODEL_NONE:
56603ccda647Slclee {
56613ccda647Slclee if (ddi_copyout(&p, (void *)arg, sizeof (p),
56623ccda647Slclee flag))
56633ccda647Slclee err = EFAULT;
56643ccda647Slclee break;
56653ccda647Slclee }
56663ccda647Slclee }
56673ccda647Slclee #else /* ! _MULTI_DATAMODEL */
56683ccda647Slclee if (ddi_copyout(&p, (void *)arg, sizeof (p), flag))
56693ccda647Slclee err = EFAULT;
56703ccda647Slclee #endif /* _MULTI_DATAMODEL */
56713ccda647Slclee }
56723ccda647Slclee return (err);
56733ccda647Slclee }
5674342440ecSPrasad Singamsetty static int
5675342440ecSPrasad Singamsetty cmlb_dkio_extpartinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag)
5676342440ecSPrasad Singamsetty {
5677342440ecSPrasad Singamsetty int err = 0;
5678342440ecSPrasad Singamsetty
5679342440ecSPrasad Singamsetty /*
5680342440ecSPrasad Singamsetty * Return parameters describing the selected disk slice.
5681342440ecSPrasad Singamsetty * Note: this ioctl is for the intel platform only
5682342440ecSPrasad Singamsetty */
5683342440ecSPrasad Singamsetty int part;
5684342440ecSPrasad Singamsetty
5685406fc510SToomas Soome if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
5686406fc510SToomas Soome part = getminor(dev) & ((1 << CMLBUNIT_FORCE_P0_SHIFT) - 1);
5687406fc510SToomas Soome else
5688406fc510SToomas Soome part = CMLBPART(dev);
5689342440ecSPrasad Singamsetty
5690342440ecSPrasad Singamsetty mutex_enter(CMLB_MUTEX(cl));
5691342440ecSPrasad Singamsetty /* don't check cl_solaris_size for pN */
5692342440ecSPrasad Singamsetty if (part < P0_RAW_DISK && cl->cl_solaris_size == 0) {
5693342440ecSPrasad Singamsetty err = EIO;
5694342440ecSPrasad Singamsetty mutex_exit(CMLB_MUTEX(cl));
5695342440ecSPrasad Singamsetty } else {
5696342440ecSPrasad Singamsetty struct extpart_info p;
5697342440ecSPrasad Singamsetty
5698342440ecSPrasad Singamsetty p.p_start = (diskaddr_t)cl->cl_offset[part];
5699342440ecSPrasad Singamsetty p.p_length = (diskaddr_t)cl->cl_map[part].dkl_nblk;
5700342440ecSPrasad Singamsetty mutex_exit(CMLB_MUTEX(cl));
5701342440ecSPrasad Singamsetty if (ddi_copyout(&p, (void *)arg, sizeof (p), flag))
5702342440ecSPrasad Singamsetty err = EFAULT;
5703342440ecSPrasad Singamsetty }
5704342440ecSPrasad Singamsetty return (err);
5705342440ecSPrasad Singamsetty }
57063ccda647Slclee #endif
5707b9ccdc5aScth
5708b9ccdc5aScth int
5709b9ccdc5aScth cmlb_prop_op(cmlb_handle_t cmlbhandle,
5710b9ccdc5aScth dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
5711b9ccdc5aScth char *name, caddr_t valuep, int *lengthp, int part, void *tg_cookie)
5712b9ccdc5aScth {
5713b9ccdc5aScth struct cmlb_lun *cl;
5714b9ccdc5aScth diskaddr_t capacity;
5715b9ccdc5aScth uint32_t lbasize;
5716acb450ddSYuri Pankov enum dp { DP_NBLOCKS, DP_BLKSIZE, DP_SSD, DP_ROT } dp;
5717b9ccdc5aScth int callers_length;
5718b9ccdc5aScth caddr_t buffer;
5719b9ccdc5aScth uint64_t nblocks64;
5720b9ccdc5aScth uint_t dblk;
572159d8f100SGarrett D'Amore tg_attribute_t tgattr;
5722b9ccdc5aScth
5723b9ccdc5aScth /* Always fallback to ddi_prop_op... */
5724b9ccdc5aScth cl = (struct cmlb_lun *)cmlbhandle;
5725b9ccdc5aScth if (cl == NULL) {
5726b9ccdc5aScth fallback: return (ddi_prop_op(dev, dip, prop_op, mod_flags,
5727b9ccdc5aScth name, valuep, lengthp));
5728b9ccdc5aScth }
5729b9ccdc5aScth
5730b9ccdc5aScth /* Pick up capacity and blocksize information. */
5731b9ccdc5aScth capacity = cl->cl_blockcount;
5732b9ccdc5aScth if (capacity == 0)
5733b9ccdc5aScth goto fallback;
5734b9ccdc5aScth lbasize = cl->cl_tgt_blocksize;
5735b9ccdc5aScth if (lbasize == 0)
5736b9ccdc5aScth lbasize = DEV_BSIZE; /* 0 -> DEV_BSIZE units */
5737b9ccdc5aScth
5738b9ccdc5aScth /* Check for dynamic property of whole device. */
5739b9ccdc5aScth if (dev == DDI_DEV_T_ANY) {
5740b9ccdc5aScth /* Fallback to ddi_prop_op if we don't understand. */
5741b9ccdc5aScth if (strcmp(name, "device-nblocks") == 0)
5742b9ccdc5aScth dp = DP_NBLOCKS;
5743b9ccdc5aScth else if (strcmp(name, "device-blksize") == 0)
5744b9ccdc5aScth dp = DP_BLKSIZE;
574559d8f100SGarrett D'Amore else if (strcmp(name, "device-solid-state") == 0)
574659d8f100SGarrett D'Amore dp = DP_SSD;
5747acb450ddSYuri Pankov else if (strcmp(name, "device-rotational") == 0)
5748acb450ddSYuri Pankov dp = DP_ROT;
5749b9ccdc5aScth else
5750b9ccdc5aScth goto fallback;
5751b9ccdc5aScth
5752b9ccdc5aScth /* get callers length, establish length of our dynamic prop */
5753b9ccdc5aScth callers_length = *lengthp;
5754b9ccdc5aScth if (dp == DP_NBLOCKS)
5755b9ccdc5aScth *lengthp = sizeof (uint64_t);
575659d8f100SGarrett D'Amore else if ((dp == DP_BLKSIZE) || (dp == DP_SSD))
5757b9ccdc5aScth *lengthp = sizeof (uint32_t);
5758b9ccdc5aScth
5759b9ccdc5aScth /* service request for the length of the property */
5760b9ccdc5aScth if (prop_op == PROP_LEN)
5761b9ccdc5aScth return (DDI_PROP_SUCCESS);
5762b9ccdc5aScth
5763b9ccdc5aScth switch (prop_op) {
5764b9ccdc5aScth case PROP_LEN_AND_VAL_ALLOC:
5765b9ccdc5aScth if ((buffer = kmem_alloc(*lengthp,
5766b9ccdc5aScth (mod_flags & DDI_PROP_CANSLEEP) ?
5767b9ccdc5aScth KM_SLEEP : KM_NOSLEEP)) == NULL)
5768b9ccdc5aScth return (DDI_PROP_NO_MEMORY);
5769b9ccdc5aScth *(caddr_t *)valuep = buffer; /* set callers buf */
5770b9ccdc5aScth break;
5771b9ccdc5aScth
5772b9ccdc5aScth case PROP_LEN_AND_VAL_BUF:
5773b9ccdc5aScth /* the length of the prop and the request must match */
5774b9ccdc5aScth if (callers_length != *lengthp)
5775b9ccdc5aScth return (DDI_PROP_INVAL_ARG);
5776b9ccdc5aScth buffer = valuep; /* get callers buf */
5777b9ccdc5aScth break;
5778b9ccdc5aScth
5779b9ccdc5aScth default:
5780b9ccdc5aScth return (DDI_PROP_INVAL_ARG);
5781b9ccdc5aScth }
5782b9ccdc5aScth
5783b9ccdc5aScth /* transfer the value into the buffer */
578459d8f100SGarrett D'Amore switch (dp) {
578559d8f100SGarrett D'Amore case DP_NBLOCKS:
5786b9ccdc5aScth *((uint64_t *)buffer) = capacity;
578759d8f100SGarrett D'Amore break;
578859d8f100SGarrett D'Amore case DP_BLKSIZE:
5789b9ccdc5aScth *((uint32_t *)buffer) = lbasize;
579059d8f100SGarrett D'Amore break;
579159d8f100SGarrett D'Amore case DP_SSD:
579259d8f100SGarrett D'Amore if (DK_TG_GETATTRIBUTE(cl, &tgattr, tg_cookie) != 0)
579359d8f100SGarrett D'Amore tgattr.media_is_solid_state = B_FALSE;
579459d8f100SGarrett D'Amore *((uint32_t *)buffer) =
579559d8f100SGarrett D'Amore tgattr.media_is_solid_state ? 1 : 0;
579659d8f100SGarrett D'Amore break;
5797acb450ddSYuri Pankov case DP_ROT:
5798acb450ddSYuri Pankov if (DK_TG_GETATTRIBUTE(cl, &tgattr, tg_cookie) != 0)
5799acb450ddSYuri Pankov tgattr.media_is_rotational = B_TRUE;
5800acb450ddSYuri Pankov *((uint32_t *)buffer) =
5801acb450ddSYuri Pankov tgattr.media_is_rotational ? 1 : 0;
5802acb450ddSYuri Pankov break;
580359d8f100SGarrett D'Amore }
5804b9ccdc5aScth return (DDI_PROP_SUCCESS);
5805b9ccdc5aScth }
5806b9ccdc5aScth
5807b9ccdc5aScth /*
5808b9ccdc5aScth * Support dynamic size oriented properties of partition. Requests
5809b9ccdc5aScth * issued under conditions where size is valid are passed to
5810b9ccdc5aScth * ddi_prop_op_nblocks with the size information, otherwise the
5811b9ccdc5aScth * request is passed to ddi_prop_op. Size depends on valid geometry.
5812b9ccdc5aScth */
5813b9ccdc5aScth if (!cmlb_is_valid(cmlbhandle))
5814b9ccdc5aScth goto fallback;
5815b9ccdc5aScth
5816b9ccdc5aScth /* Get partition nblocks value. */
5817b9ccdc5aScth (void) cmlb_partinfo(cmlbhandle, part,
5818b9ccdc5aScth (diskaddr_t *)&nblocks64, NULL, NULL, NULL, tg_cookie);
5819b9ccdc5aScth
5820b9ccdc5aScth /*
582165908c77Syu, larry liu - Sun Microsystems - Beijing China * Assume partition information is in sys_blocksize units, compute
5822b9ccdc5aScth * divisor for size(9P) property representation.
5823b9ccdc5aScth */
582465908c77Syu, larry liu - Sun Microsystems - Beijing China dblk = lbasize / cl->cl_sys_blocksize;
5825b9ccdc5aScth
5826b9ccdc5aScth /* Now let ddi_prop_op_nblocks_blksize() handle the request. */
5827b9ccdc5aScth return (ddi_prop_op_nblocks_blksize(dev, dip, prop_op, mod_flags,
5828b9ccdc5aScth name, valuep, lengthp, nblocks64 / dblk, lbasize));
5829b9ccdc5aScth }
5830