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