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