1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2012 DEY Storage Systems, Inc. All rights reserved. 24 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 25 * Use is subject to license terms. 26 * Copyright 2016 Toomas Soome <tsoome@me.com> 27 * Copyright (c) 2019, Joyent, Inc. 28 */ 29 30 /* 31 * This module provides support for labeling operations for target 32 * drivers. 33 */ 34 35 #include <sys/scsi/scsi.h> 36 #include <sys/sunddi.h> 37 #include <sys/dklabel.h> 38 #include <sys/dkio.h> 39 #include <sys/vtoc.h> 40 #include <sys/dktp/fdisk.h> 41 #include <sys/vtrace.h> 42 #include <sys/efi_partition.h> 43 #include <sys/cmlb.h> 44 #include <sys/cmlb_impl.h> 45 #if defined(__i386) || defined(__amd64) 46 #include <sys/fs/dv_node.h> 47 #endif 48 #include <sys/ddi_impldefs.h> 49 50 /* 51 * Driver minor node structure and data table 52 */ 53 struct driver_minor_data { 54 char *name; 55 minor_t minor; 56 int type; 57 }; 58 59 static struct driver_minor_data dk_minor_data[] = { 60 {"a", 0, S_IFBLK}, 61 {"b", 1, S_IFBLK}, 62 {"c", 2, S_IFBLK}, 63 {"d", 3, S_IFBLK}, 64 {"e", 4, S_IFBLK}, 65 {"f", 5, S_IFBLK}, 66 {"g", 6, S_IFBLK}, 67 {"h", 7, S_IFBLK}, 68 #if defined(_SUNOS_VTOC_16) 69 {"i", 8, S_IFBLK}, 70 {"j", 9, S_IFBLK}, 71 {"k", 10, S_IFBLK}, 72 {"l", 11, S_IFBLK}, 73 {"m", 12, S_IFBLK}, 74 {"n", 13, S_IFBLK}, 75 {"o", 14, S_IFBLK}, 76 {"p", 15, S_IFBLK}, 77 #endif /* defined(_SUNOS_VTOC_16) */ 78 #if defined(_FIRMWARE_NEEDS_FDISK) 79 {"q", 16, S_IFBLK}, 80 {"r", 17, S_IFBLK}, 81 {"s", 18, S_IFBLK}, 82 {"t", 19, S_IFBLK}, 83 {"u", 20, S_IFBLK}, 84 #endif /* defined(_FIRMWARE_NEEDS_FDISK) */ 85 {"a,raw", 0, S_IFCHR}, 86 {"b,raw", 1, S_IFCHR}, 87 {"c,raw", 2, S_IFCHR}, 88 {"d,raw", 3, S_IFCHR}, 89 {"e,raw", 4, S_IFCHR}, 90 {"f,raw", 5, S_IFCHR}, 91 {"g,raw", 6, S_IFCHR}, 92 {"h,raw", 7, S_IFCHR}, 93 #if defined(_SUNOS_VTOC_16) 94 {"i,raw", 8, S_IFCHR}, 95 {"j,raw", 9, S_IFCHR}, 96 {"k,raw", 10, S_IFCHR}, 97 {"l,raw", 11, S_IFCHR}, 98 {"m,raw", 12, S_IFCHR}, 99 {"n,raw", 13, S_IFCHR}, 100 {"o,raw", 14, S_IFCHR}, 101 {"p,raw", 15, S_IFCHR}, 102 #endif /* defined(_SUNOS_VTOC_16) */ 103 #if defined(_FIRMWARE_NEEDS_FDISK) 104 {"q,raw", 16, S_IFCHR}, 105 {"r,raw", 17, S_IFCHR}, 106 {"s,raw", 18, S_IFCHR}, 107 {"t,raw", 19, S_IFCHR}, 108 {"u,raw", 20, S_IFCHR}, 109 #endif /* defined(_FIRMWARE_NEEDS_FDISK) */ 110 {0} 111 }; 112 113 #if defined(__i386) || defined(__amd64) 114 #if defined(_FIRMWARE_NEEDS_FDISK) 115 static struct driver_minor_data dk_ext_minor_data[] = { 116 {"p5", 21, S_IFBLK}, 117 {"p6", 22, S_IFBLK}, 118 {"p7", 23, S_IFBLK}, 119 {"p8", 24, S_IFBLK}, 120 {"p9", 25, S_IFBLK}, 121 {"p10", 26, S_IFBLK}, 122 {"p11", 27, S_IFBLK}, 123 {"p12", 28, S_IFBLK}, 124 {"p13", 29, S_IFBLK}, 125 {"p14", 30, S_IFBLK}, 126 {"p15", 31, S_IFBLK}, 127 {"p16", 32, S_IFBLK}, 128 {"p17", 33, S_IFBLK}, 129 {"p18", 34, S_IFBLK}, 130 {"p19", 35, S_IFBLK}, 131 {"p20", 36, S_IFBLK}, 132 {"p21", 37, S_IFBLK}, 133 {"p22", 38, S_IFBLK}, 134 {"p23", 39, S_IFBLK}, 135 {"p24", 40, S_IFBLK}, 136 {"p25", 41, S_IFBLK}, 137 {"p26", 42, S_IFBLK}, 138 {"p27", 43, S_IFBLK}, 139 {"p28", 44, S_IFBLK}, 140 {"p29", 45, S_IFBLK}, 141 {"p30", 46, S_IFBLK}, 142 {"p31", 47, S_IFBLK}, 143 {"p32", 48, S_IFBLK}, 144 {"p33", 49, S_IFBLK}, 145 {"p34", 50, S_IFBLK}, 146 {"p35", 51, S_IFBLK}, 147 {"p36", 52, S_IFBLK}, 148 {"p5,raw", 21, S_IFCHR}, 149 {"p6,raw", 22, S_IFCHR}, 150 {"p7,raw", 23, S_IFCHR}, 151 {"p8,raw", 24, S_IFCHR}, 152 {"p9,raw", 25, S_IFCHR}, 153 {"p10,raw", 26, S_IFCHR}, 154 {"p11,raw", 27, S_IFCHR}, 155 {"p12,raw", 28, S_IFCHR}, 156 {"p13,raw", 29, S_IFCHR}, 157 {"p14,raw", 30, S_IFCHR}, 158 {"p15,raw", 31, S_IFCHR}, 159 {"p16,raw", 32, S_IFCHR}, 160 {"p17,raw", 33, S_IFCHR}, 161 {"p18,raw", 34, S_IFCHR}, 162 {"p19,raw", 35, S_IFCHR}, 163 {"p20,raw", 36, S_IFCHR}, 164 {"p21,raw", 37, S_IFCHR}, 165 {"p22,raw", 38, S_IFCHR}, 166 {"p23,raw", 39, S_IFCHR}, 167 {"p24,raw", 40, S_IFCHR}, 168 {"p25,raw", 41, S_IFCHR}, 169 {"p26,raw", 42, S_IFCHR}, 170 {"p27,raw", 43, S_IFCHR}, 171 {"p28,raw", 44, S_IFCHR}, 172 {"p29,raw", 45, S_IFCHR}, 173 {"p30,raw", 46, S_IFCHR}, 174 {"p31,raw", 47, S_IFCHR}, 175 {"p32,raw", 48, S_IFCHR}, 176 {"p33,raw", 49, S_IFCHR}, 177 {"p34,raw", 50, S_IFCHR}, 178 {"p35,raw", 51, S_IFCHR}, 179 {"p36,raw", 52, S_IFCHR}, 180 {0} 181 }; 182 #endif /* defined(_FIRMWARE_NEEDS_FDISK) */ 183 #endif /* if defined(__i386) || defined(__amd64) */ 184 185 static struct driver_minor_data dk_minor_data_efi[] = { 186 {"a", 0, S_IFBLK}, 187 {"b", 1, S_IFBLK}, 188 {"c", 2, S_IFBLK}, 189 {"d", 3, S_IFBLK}, 190 {"e", 4, S_IFBLK}, 191 {"f", 5, S_IFBLK}, 192 {"g", 6, S_IFBLK}, 193 {"wd", 7, S_IFBLK}, 194 #if defined(_SUNOS_VTOC_16) 195 {"i", 8, S_IFBLK}, 196 {"j", 9, S_IFBLK}, 197 {"k", 10, S_IFBLK}, 198 {"l", 11, S_IFBLK}, 199 {"m", 12, S_IFBLK}, 200 {"n", 13, S_IFBLK}, 201 {"o", 14, S_IFBLK}, 202 {"p", 15, S_IFBLK}, 203 #endif /* defined(_SUNOS_VTOC_16) */ 204 #if defined(_FIRMWARE_NEEDS_FDISK) 205 {"q", 16, S_IFBLK}, 206 {"r", 17, S_IFBLK}, 207 {"s", 18, S_IFBLK}, 208 {"t", 19, S_IFBLK}, 209 {"u", 20, S_IFBLK}, 210 #endif /* defined(_FIRMWARE_NEEDS_FDISK) */ 211 {"a,raw", 0, S_IFCHR}, 212 {"b,raw", 1, S_IFCHR}, 213 {"c,raw", 2, S_IFCHR}, 214 {"d,raw", 3, S_IFCHR}, 215 {"e,raw", 4, S_IFCHR}, 216 {"f,raw", 5, S_IFCHR}, 217 {"g,raw", 6, S_IFCHR}, 218 {"wd,raw", 7, S_IFCHR}, 219 #if defined(_SUNOS_VTOC_16) 220 {"i,raw", 8, S_IFCHR}, 221 {"j,raw", 9, S_IFCHR}, 222 {"k,raw", 10, S_IFCHR}, 223 {"l,raw", 11, S_IFCHR}, 224 {"m,raw", 12, S_IFCHR}, 225 {"n,raw", 13, S_IFCHR}, 226 {"o,raw", 14, S_IFCHR}, 227 {"p,raw", 15, S_IFCHR}, 228 #endif /* defined(_SUNOS_VTOC_16) */ 229 #if defined(_FIRMWARE_NEEDS_FDISK) 230 {"q,raw", 16, S_IFCHR}, 231 {"r,raw", 17, S_IFCHR}, 232 {"s,raw", 18, S_IFCHR}, 233 {"t,raw", 19, S_IFCHR}, 234 {"u,raw", 20, S_IFCHR}, 235 #endif /* defined(_FIRMWARE_NEEDS_FDISK) */ 236 {0} 237 }; 238 239 /* 240 * Declare the dynamic properties implemented in prop_op(9E) implementation 241 * that we want to have show up in a di_init(3DEVINFO) device tree snapshot 242 * of drivers that call cmlb_attach(). 243 */ 244 static i_ddi_prop_dyn_t cmlb_prop_dyn[] = { 245 {"Nblocks", DDI_PROP_TYPE_INT64, S_IFBLK}, 246 {"Size", DDI_PROP_TYPE_INT64, S_IFCHR}, 247 {"device-nblocks", DDI_PROP_TYPE_INT64}, 248 {"device-blksize", DDI_PROP_TYPE_INT}, 249 {"device-solid-state", DDI_PROP_TYPE_INT}, 250 {"device-rotational", DDI_PROP_TYPE_INT}, 251 {NULL} 252 }; 253 254 /* 255 * This implies an upper limit of 8192 GPT partitions 256 * in one transfer for GUID Partition Entry Array. 257 */ 258 len_t cmlb_tg_max_efi_xfer = 1024 * 1024; 259 260 /* 261 * External kernel interfaces 262 */ 263 extern struct mod_ops mod_miscops; 264 265 extern int ddi_create_internal_pathname(dev_info_t *dip, char *name, 266 int spec_type, minor_t minor_num); 267 268 /* 269 * Global buffer and mutex for debug logging 270 */ 271 static char cmlb_log_buffer[1024]; 272 static kmutex_t cmlb_log_mutex; 273 274 275 struct cmlb_lun *cmlb_debug_cl = NULL; 276 uint_t cmlb_level_mask = 0x0; 277 278 int cmlb_rot_delay = 4; /* default rotational delay */ 279 280 static struct modlmisc modlmisc = { 281 &mod_miscops, /* Type of module */ 282 "Common Labeling module" 283 }; 284 285 static struct modlinkage modlinkage = { 286 MODREV_1, (void *)&modlmisc, NULL 287 }; 288 289 /* Local function prototypes */ 290 static dev_t cmlb_make_device(struct cmlb_lun *cl); 291 static int cmlb_validate_geometry(struct cmlb_lun *cl, boolean_t forcerevalid, 292 int flags, void *tg_cookie); 293 static void cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity, 294 void *tg_cookie); 295 static int cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity, 296 void *tg_cookie); 297 static void cmlb_swap_efi_gpt(efi_gpt_t *e); 298 static void cmlb_swap_efi_gpe(int nparts, efi_gpe_t *p); 299 static int cmlb_validate_efi(efi_gpt_t *labp); 300 static int cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags, 301 void *tg_cookie); 302 static void cmlb_build_default_label(struct cmlb_lun *cl, void *tg_cookie); 303 static int cmlb_uselabel(struct cmlb_lun *cl, struct dk_label *l, int flags); 304 #if defined(_SUNOS_VTOC_8) 305 static void cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc); 306 #endif 307 static int cmlb_build_label_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc); 308 static int cmlb_write_label(struct cmlb_lun *cl, void *tg_cookie); 309 static int cmlb_set_vtoc(struct cmlb_lun *cl, struct dk_label *dkl, 310 void *tg_cookie); 311 static void cmlb_clear_efi(struct cmlb_lun *cl, void *tg_cookie); 312 static void cmlb_clear_vtoc(struct cmlb_lun *cl, void *tg_cookie); 313 static void cmlb_setup_default_geometry(struct cmlb_lun *cl, void *tg_cookie); 314 static int cmlb_create_minor_nodes(struct cmlb_lun *cl); 315 static int cmlb_check_update_blockcount(struct cmlb_lun *cl, void *tg_cookie); 316 static boolean_t cmlb_check_efi_mbr(uchar_t *buf, boolean_t *is_mbr); 317 318 #if defined(__i386) || defined(__amd64) 319 static int cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie); 320 #endif 321 322 #if defined(_FIRMWARE_NEEDS_FDISK) 323 static boolean_t cmlb_has_max_chs_vals(struct ipart *fdp); 324 #endif 325 326 #if defined(_SUNOS_VTOC_16) 327 static void cmlb_convert_geometry(struct cmlb_lun *cl, diskaddr_t capacity, 328 struct dk_geom *cl_g, void *tg_cookie); 329 #endif 330 331 static int cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag, 332 void *tg_cookie); 333 static int cmlb_dkio_set_geometry(struct cmlb_lun *cl, caddr_t arg, int flag); 334 static int cmlb_dkio_get_partition(struct cmlb_lun *cl, caddr_t arg, int flag, 335 void *tg_cookie); 336 static int cmlb_dkio_set_partition(struct cmlb_lun *cl, caddr_t arg, int flag); 337 static int cmlb_dkio_get_efi(struct cmlb_lun *cl, caddr_t arg, int flag, 338 void *tg_cookie); 339 static int cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg, 340 int flag, void *tg_cookie); 341 static int cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag, 342 void *tg_cookie); 343 static int cmlb_dkio_get_extvtoc(struct cmlb_lun *cl, caddr_t arg, int flag, 344 void *tg_cookie); 345 static int cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, 346 int flag, void *tg_cookie); 347 static int cmlb_dkio_set_extvtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, 348 int flag, void *tg_cookie); 349 static int cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, 350 void *tg_cookie); 351 static int cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, 352 void *tg_cookie); 353 static int cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag, 354 void *tg_cookie); 355 356 #if defined(__i386) || defined(__amd64) 357 static int cmlb_dkio_set_ext_part(struct cmlb_lun *cl, caddr_t arg, int flag, 358 void *tg_cookie); 359 static int cmlb_validate_ext_part(struct cmlb_lun *cl, int part, int epart, 360 uint32_t start, uint32_t size); 361 static int cmlb_is_linux_swap(struct cmlb_lun *cl, uint32_t part_start, 362 void *tg_cookie); 363 static int cmlb_dkio_get_virtgeom(struct cmlb_lun *cl, caddr_t arg, int flag); 364 static int cmlb_dkio_get_phygeom(struct cmlb_lun *cl, caddr_t arg, int flag, 365 void *tg_cookie); 366 static int cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg, 367 int flag); 368 static int cmlb_dkio_extpartinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg, 369 int flag); 370 #endif 371 372 static void cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...); 373 static void cmlb_v_log(dev_info_t *dev, const char *label, uint_t level, 374 const char *fmt, va_list ap); 375 static void cmlb_log(dev_info_t *dev, const char *label, uint_t level, 376 const char *fmt, ...); 377 378 int 379 _init(void) 380 { 381 mutex_init(&cmlb_log_mutex, NULL, MUTEX_DRIVER, NULL); 382 return (mod_install(&modlinkage)); 383 } 384 385 int 386 _info(struct modinfo *modinfop) 387 { 388 return (mod_info(&modlinkage, modinfop)); 389 } 390 391 int 392 _fini(void) 393 { 394 int err; 395 396 if ((err = mod_remove(&modlinkage)) != 0) { 397 return (err); 398 } 399 400 mutex_destroy(&cmlb_log_mutex); 401 return (err); 402 } 403 404 /* 405 * cmlb_dbg is used for debugging to log additional info 406 * Level of output is controlled via cmlb_level_mask setting. 407 */ 408 static void 409 cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...) 410 { 411 va_list ap; 412 dev_info_t *dev; 413 uint_t level_mask = 0; 414 415 ASSERT(cl != NULL); 416 dev = CMLB_DEVINFO(cl); 417 ASSERT(dev != NULL); 418 /* 419 * Filter messages based on the global component and level masks, 420 * also print if cl matches the value of cmlb_debug_cl, or if 421 * cmlb_debug_cl is set to NULL. 422 */ 423 if (comp & CMLB_TRACE) 424 level_mask |= CMLB_LOGMASK_TRACE; 425 426 if (comp & CMLB_INFO) 427 level_mask |= CMLB_LOGMASK_INFO; 428 429 if (comp & CMLB_ERROR) 430 level_mask |= CMLB_LOGMASK_ERROR; 431 432 if ((cmlb_level_mask & level_mask) && 433 ((cmlb_debug_cl == NULL) || (cmlb_debug_cl == cl))) { 434 va_start(ap, fmt); 435 cmlb_v_log(dev, CMLB_LABEL(cl), CE_CONT, fmt, ap); 436 va_end(ap); 437 } 438 } 439 440 /* 441 * cmlb_log is basically a duplicate of scsi_log. It is redefined here 442 * so that this module does not depend on scsi module. 443 */ 444 static void 445 cmlb_log(dev_info_t *dev, const char *label, uint_t level, const char *fmt, ...) 446 { 447 va_list ap; 448 449 va_start(ap, fmt); 450 cmlb_v_log(dev, label, level, fmt, ap); 451 va_end(ap); 452 } 453 454 static void 455 cmlb_v_log(dev_info_t *dev, const char *label, uint_t level, const char *fmt, 456 va_list ap) 457 { 458 static char name[256]; 459 int log_only = 0; 460 int boot_only = 0; 461 int console_only = 0; 462 463 mutex_enter(&cmlb_log_mutex); 464 465 if (dev) { 466 if (level == CE_PANIC || level == CE_WARN || 467 level == CE_NOTE) { 468 (void) sprintf(name, "%s (%s%d):\n", 469 ddi_pathname(dev, cmlb_log_buffer), 470 label, ddi_get_instance(dev)); 471 } else { 472 name[0] = '\0'; 473 } 474 } else { 475 (void) sprintf(name, "%s:", label); 476 } 477 478 (void) vsprintf(cmlb_log_buffer, fmt, ap); 479 480 switch (cmlb_log_buffer[0]) { 481 case '!': 482 log_only = 1; 483 break; 484 case '?': 485 boot_only = 1; 486 break; 487 case '^': 488 console_only = 1; 489 break; 490 } 491 492 switch (level) { 493 case CE_NOTE: 494 level = CE_CONT; 495 /* FALLTHROUGH */ 496 case CE_CONT: 497 case CE_WARN: 498 case CE_PANIC: 499 if (boot_only) { 500 cmn_err(level, "?%s\t%s", name, &cmlb_log_buffer[1]); 501 } else if (console_only) { 502 cmn_err(level, "^%s\t%s", name, &cmlb_log_buffer[1]); 503 } else if (log_only) { 504 cmn_err(level, "!%s\t%s", name, &cmlb_log_buffer[1]); 505 } else { 506 cmn_err(level, "%s\t%s", name, cmlb_log_buffer); 507 } 508 break; 509 case CE_IGNORE: 510 break; 511 default: 512 cmn_err(CE_CONT, "^DEBUG: %s\t%s", name, cmlb_log_buffer); 513 break; 514 } 515 mutex_exit(&cmlb_log_mutex); 516 } 517 518 519 /* 520 * cmlb_alloc_handle: 521 * 522 * Allocates a handle. 523 * 524 * Arguments: 525 * cmlbhandlep pointer to handle 526 * 527 * Notes: 528 * Allocates a handle and stores the allocated handle in the area 529 * pointed to by cmlbhandlep 530 * 531 * Context: 532 * Kernel thread only (can sleep). 533 */ 534 void 535 cmlb_alloc_handle(cmlb_handle_t *cmlbhandlep) 536 { 537 struct cmlb_lun *cl; 538 539 cl = kmem_zalloc(sizeof (struct cmlb_lun), KM_SLEEP); 540 ASSERT(cmlbhandlep != NULL); 541 542 cl->cl_state = CMLB_INITED; 543 cl->cl_def_labeltype = CMLB_LABEL_UNDEF; 544 mutex_init(CMLB_MUTEX(cl), NULL, MUTEX_DRIVER, NULL); 545 546 *cmlbhandlep = (cmlb_handle_t)(cl); 547 } 548 549 /* 550 * cmlb_free_handle 551 * 552 * Frees handle. 553 * 554 * Arguments: 555 * cmlbhandlep pointer to handle 556 */ 557 void 558 cmlb_free_handle(cmlb_handle_t *cmlbhandlep) 559 { 560 struct cmlb_lun *cl; 561 562 cl = (struct cmlb_lun *)*cmlbhandlep; 563 if (cl != NULL) { 564 mutex_destroy(CMLB_MUTEX(cl)); 565 kmem_free(cl, sizeof (struct cmlb_lun)); 566 } 567 568 } 569 570 /* 571 * cmlb_attach: 572 * 573 * Attach handle to device, create minor nodes for device. 574 * 575 * Arguments: 576 * devi pointer to device's dev_info structure. 577 * tgopsp pointer to array of functions cmlb can use to callback 578 * to target driver. 579 * 580 * device_type Peripheral device type as defined in 581 * scsi/generic/inquiry.h 582 * 583 * is_removable whether or not device is removable. 584 * 585 * is_hotpluggable whether or not device is hotpluggable. 586 * 587 * node_type minor node type (as used by ddi_create_minor_node) 588 * 589 * alter_behavior 590 * bit flags: 591 * 592 * CMLB_CREATE_ALTSLICE_VTOC_16_DTYPE_DIRECT: create 593 * an alternate slice for the default label, if 594 * device type is DTYPE_DIRECT an architectures default 595 * label type is VTOC16. 596 * Otherwise alternate slice will no be created. 597 * 598 * 599 * CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8: report a default 600 * geometry and label for DKIOCGGEOM and DKIOCGVTOC 601 * on architecture with VTOC8 label types. 602 * 603 * CMLB_OFF_BY_ONE: do the workaround for legacy off-by- 604 * one bug in obtaining capacity (in sd): 605 * SCSI READ_CAPACITY command returns the LBA number of the 606 * last logical block, but sd once treated this number as 607 * disks' capacity on x86 platform. And LBAs are addressed 608 * based 0. So the last block was lost on x86 platform. 609 * 610 * Now, we remove this workaround. In order for present sd 611 * driver to work with disks which are labeled/partitioned 612 * via previous sd, we add workaround as follows: 613 * 614 * 1) Locate backup EFI label: cmlb searches the next to 615 * last 616 * block for backup EFI label. If fails, it will 617 * turn to the last block for backup EFI label; 618 * 619 * 2) Clear backup EFI label: cmlb first search the last 620 * block for backup EFI label, and will search the 621 * next to last block only if failed for the last 622 * block. 623 * 624 * 3) Calculate geometry:refer to cmlb_convert_geometry() 625 * If capacity increasing by 1 causes disks' capacity 626 * to cross over the limits in geometry calculation, 627 * geometry info will change. This will raise an issue: 628 * In case that primary VTOC label is destroyed, format 629 * commandline can restore it via backup VTOC labels. 630 * And format locates backup VTOC labels by use of 631 * geometry. So changing geometry will 632 * prevent format from finding backup VTOC labels. To 633 * eliminate this side effect for compatibility, 634 * sd uses (capacity -1) to calculate geometry; 635 * 636 * 4) 1TB disks: some important data structures use 637 * 32-bit signed long/int (for example, daddr_t), 638 * so that sd doesn't support a disk with capacity 639 * larger than 1TB on 32-bit platform. However, 640 * for exactly 1TB disk, it was treated as (1T - 512)B 641 * in the past, and could have valid Solaris 642 * partitions. To workaround this, if an exactly 1TB 643 * disk has Solaris fdisk partition, it will be allowed 644 * to work with sd. 645 * 646 * 647 * 648 * CMLB_FAKE_LABEL_ONE_PARTITION: create s0 and s2 covering 649 * the entire disk, if there is no valid partition info. 650 * If there is a valid Solaris partition, s0 and s2 will 651 * only cover the entire Solaris partition. 652 * 653 * CMLB_CREATE_P0_MINOR_NODE: create p0 node covering 654 * the entire disk. Used by lofi to ensure presence of 655 * whole disk device node in case of LOFI_MAP_FILE ioctl. 656 * 657 * cmlbhandle cmlb handle associated with device 658 * 659 * tg_cookie cookie from target driver to be passed back to target 660 * driver when we call back to it through tg_ops. 661 * 662 * Notes: 663 * Assumes a default label based on capacity for non-removable devices. 664 * If capacity > 1TB, EFI is assumed otherwise VTOC (default VTOC 665 * for the architecture). 666 * 667 * For removable devices, default label type is assumed to be VTOC 668 * type. Create minor nodes based on a default label type. 669 * Label on the media is not validated. 670 * minor number consists of: 671 * if _SUNOS_VTOC_8 is defined 672 * lowest 3 bits is taken as partition number 673 * the rest is instance number 674 * if _SUNOS_VTOC_16 is defined 675 * lowest 6 bits is taken as partition number 676 * the rest is instance number 677 * 678 * 679 * Return values: 680 * 0 Success 681 * ENXIO creating minor nodes failed. 682 * EINVAL invalid arg, unsupported tg_ops version 683 */ 684 int 685 cmlb_attach(dev_info_t *devi, cmlb_tg_ops_t *tgopsp, int device_type, 686 boolean_t is_removable, boolean_t is_hotpluggable, char *node_type, 687 int alter_behavior, cmlb_handle_t cmlbhandle, void *tg_cookie) 688 { 689 690 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; 691 diskaddr_t cap; 692 int status; 693 694 ASSERT(VALID_BOOLEAN(is_removable)); 695 ASSERT(VALID_BOOLEAN(is_hotpluggable)); 696 697 if (tgopsp->tg_version < TG_DK_OPS_VERSION_1) 698 return (EINVAL); 699 700 mutex_enter(CMLB_MUTEX(cl)); 701 702 CMLB_DEVINFO(cl) = devi; 703 cl->cmlb_tg_ops = tgopsp; 704 cl->cl_device_type = device_type; 705 cl->cl_is_removable = is_removable; 706 cl->cl_is_hotpluggable = is_hotpluggable; 707 cl->cl_node_type = node_type; 708 cl->cl_sys_blocksize = DEV_BSIZE; 709 cl->cl_f_geometry_is_valid = B_FALSE; 710 cl->cl_def_labeltype = CMLB_LABEL_VTOC; 711 cl->cl_alter_behavior = alter_behavior; 712 cl->cl_reserved = -1; 713 cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN; 714 #if defined(__i386) || defined(__amd64) 715 cl->cl_logical_drive_count = 0; 716 #endif 717 718 if (!is_removable) { 719 mutex_exit(CMLB_MUTEX(cl)); 720 status = DK_TG_GETCAP(cl, &cap, tg_cookie); 721 mutex_enter(CMLB_MUTEX(cl)); 722 if (status == 0 && cap > CMLB_EXTVTOC_LIMIT) { 723 /* set default EFI if > 2TB */ 724 cl->cl_def_labeltype = CMLB_LABEL_EFI; 725 } 726 } 727 728 /* create minor nodes based on default label type */ 729 cl->cl_last_labeltype = CMLB_LABEL_UNDEF; 730 cl->cl_cur_labeltype = CMLB_LABEL_UNDEF; 731 732 if (cmlb_create_minor_nodes(cl) != 0) { 733 mutex_exit(CMLB_MUTEX(cl)); 734 return (ENXIO); 735 } 736 737 /* Define the dynamic properties for devinfo spapshots. */ 738 i_ddi_prop_dyn_driver_set(CMLB_DEVINFO(cl), cmlb_prop_dyn); 739 740 cl->cl_state = CMLB_ATTACHED; 741 742 mutex_exit(CMLB_MUTEX(cl)); 743 return (0); 744 } 745 746 /* 747 * cmlb_detach: 748 * 749 * Invalidate in-core labeling data and remove all minor nodes for 750 * the device associate with handle. 751 * 752 * Arguments: 753 * cmlbhandle cmlb handle associated with device. 754 * 755 * tg_cookie cookie from target driver to be passed back to target 756 * driver when we call back to it through tg_ops. 757 * 758 */ 759 /*ARGSUSED1*/ 760 void 761 cmlb_detach(cmlb_handle_t cmlbhandle, void *tg_cookie) 762 { 763 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; 764 765 mutex_enter(CMLB_MUTEX(cl)); 766 cl->cl_def_labeltype = CMLB_LABEL_UNDEF; 767 cl->cl_f_geometry_is_valid = B_FALSE; 768 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL); 769 i_ddi_prop_dyn_driver_set(CMLB_DEVINFO(cl), NULL); 770 cl->cl_state = CMLB_INITED; 771 mutex_exit(CMLB_MUTEX(cl)); 772 } 773 774 /* 775 * cmlb_validate: 776 * 777 * Validates label. 778 * 779 * Arguments 780 * cmlbhandle cmlb handle associated with device. 781 * 782 * flags operation flags. used for verbosity control 783 * 784 * tg_cookie cookie from target driver to be passed back to target 785 * driver when we call back to it through tg_ops. 786 * 787 * 788 * Notes: 789 * If new label type is different from the current, adjust minor nodes 790 * accordingly. 791 * 792 * Return values: 793 * 0 success 794 * Note: having fdisk but no solaris partition is assumed 795 * success. 796 * 797 * ENOMEM memory allocation failed 798 * EIO i/o errors during read or get capacity 799 * EACCESS reservation conflicts 800 * EINVAL label was corrupt, or no default label was assumed 801 * ENXIO invalid handle 802 */ 803 int 804 cmlb_validate(cmlb_handle_t cmlbhandle, int flags, void *tg_cookie) 805 { 806 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; 807 int rval; 808 int ret = 0; 809 810 /* 811 * Temp work-around checking cl for NULL since there is a bug 812 * in sd_detach calling this routine from taskq_dispatch 813 * inited function. 814 */ 815 if (cl == NULL) 816 return (ENXIO); 817 818 mutex_enter(CMLB_MUTEX(cl)); 819 if (cl->cl_state < CMLB_ATTACHED) { 820 mutex_exit(CMLB_MUTEX(cl)); 821 return (ENXIO); 822 } 823 824 rval = cmlb_validate_geometry((struct cmlb_lun *)cmlbhandle, B_TRUE, 825 flags, tg_cookie); 826 827 if (rval == ENOTSUP) { 828 if (cl->cl_f_geometry_is_valid) { 829 cl->cl_cur_labeltype = CMLB_LABEL_EFI; 830 ret = 0; 831 } else { 832 ret = EINVAL; 833 } 834 } else { 835 ret = rval; 836 if (ret == 0) 837 cl->cl_cur_labeltype = CMLB_LABEL_VTOC; 838 } 839 840 if (ret == 0) 841 (void) cmlb_create_minor_nodes(cl); 842 843 mutex_exit(CMLB_MUTEX(cl)); 844 return (ret); 845 } 846 847 /* 848 * cmlb_invalidate: 849 * Invalidate in core label data 850 * 851 * Arguments: 852 * cmlbhandle cmlb handle associated with device. 853 * tg_cookie cookie from target driver to be passed back to target 854 * driver when we call back to it through tg_ops. 855 */ 856 /*ARGSUSED1*/ 857 void 858 cmlb_invalidate(cmlb_handle_t cmlbhandle, void *tg_cookie) 859 { 860 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; 861 862 if (cl == NULL) 863 return; 864 865 mutex_enter(CMLB_MUTEX(cl)); 866 cl->cl_f_geometry_is_valid = B_FALSE; 867 mutex_exit(CMLB_MUTEX(cl)); 868 } 869 870 /* 871 * cmlb_is_valid 872 * Get status on whether the incore label/geom data is valid 873 * 874 * Arguments: 875 * cmlbhandle cmlb handle associated with device. 876 * 877 * Return values: 878 * B_TRUE if incore label/geom data is valid. 879 * B_FALSE otherwise. 880 * 881 */ 882 883 884 boolean_t 885 cmlb_is_valid(cmlb_handle_t cmlbhandle) 886 { 887 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; 888 889 if (cmlbhandle == NULL) 890 return (B_FALSE); 891 892 return (cl->cl_f_geometry_is_valid); 893 894 } 895 896 897 898 /* 899 * cmlb_close: 900 * 901 * Close the device, revert to a default label minor node for the device, 902 * if it is removable. 903 * 904 * Arguments: 905 * cmlbhandle cmlb handle associated with device. 906 * 907 * tg_cookie cookie from target driver to be passed back to target 908 * driver when we call back to it through tg_ops. 909 * Return values: 910 * 0 Success 911 * ENXIO Re-creating minor node failed. 912 */ 913 /*ARGSUSED1*/ 914 int 915 cmlb_close(cmlb_handle_t cmlbhandle, void *tg_cookie) 916 { 917 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; 918 919 mutex_enter(CMLB_MUTEX(cl)); 920 cl->cl_f_geometry_is_valid = B_FALSE; 921 922 /* revert to default minor node for this device */ 923 if (ISREMOVABLE(cl)) { 924 cl->cl_cur_labeltype = CMLB_LABEL_UNDEF; 925 (void) cmlb_create_minor_nodes(cl); 926 } 927 928 mutex_exit(CMLB_MUTEX(cl)); 929 return (0); 930 } 931 932 /* 933 * cmlb_get_devid_block: 934 * get the block number where device id is stored. 935 * 936 * Arguments: 937 * cmlbhandle cmlb handle associated with device. 938 * devidblockp pointer to block number. 939 * tg_cookie cookie from target driver to be passed back to target 940 * driver when we call back to it through tg_ops. 941 * 942 * Notes: 943 * It stores the block number of device id in the area pointed to 944 * by devidblockp. 945 * with the block number of device id. 946 * 947 * Return values: 948 * 0 success 949 * EINVAL device id does not apply to current label type. 950 */ 951 /*ARGSUSED2*/ 952 int 953 cmlb_get_devid_block(cmlb_handle_t cmlbhandle, diskaddr_t *devidblockp, 954 void *tg_cookie) 955 { 956 daddr_t spc, blk, head, cyl; 957 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; 958 959 mutex_enter(CMLB_MUTEX(cl)); 960 if (cl->cl_state < CMLB_ATTACHED) { 961 mutex_exit(CMLB_MUTEX(cl)); 962 return (EINVAL); 963 } 964 965 if ((!cl->cl_f_geometry_is_valid) || 966 (cl->cl_solaris_size < DK_LABEL_LOC)) { 967 mutex_exit(CMLB_MUTEX(cl)); 968 return (EINVAL); 969 } 970 971 if (cl->cl_cur_labeltype == CMLB_LABEL_EFI) { 972 if (cl->cl_reserved != -1) { 973 blk = cl->cl_map[cl->cl_reserved].dkl_cylno; 974 } else { 975 mutex_exit(CMLB_MUTEX(cl)); 976 return (EINVAL); 977 } 978 } else { 979 /* if the disk is unlabeled, don't write a devid to it */ 980 if (cl->cl_label_from_media != CMLB_LABEL_VTOC) { 981 mutex_exit(CMLB_MUTEX(cl)); 982 return (EINVAL); 983 } 984 985 /* this geometry doesn't allow us to write a devid */ 986 if (cl->cl_g.dkg_acyl < 2) { 987 mutex_exit(CMLB_MUTEX(cl)); 988 return (EINVAL); 989 } 990 991 /* 992 * Subtract 2 guarantees that the next to last cylinder 993 * is used 994 */ 995 cyl = cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl - 2; 996 spc = cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect; 997 head = cl->cl_g.dkg_nhead - 1; 998 blk = cl->cl_solaris_offset + 999 (cyl * (spc - cl->cl_g.dkg_apc)) + 1000 (head * cl->cl_g.dkg_nsect) + 1; 1001 } 1002 1003 *devidblockp = blk; 1004 mutex_exit(CMLB_MUTEX(cl)); 1005 return (0); 1006 } 1007 1008 /* 1009 * cmlb_partinfo: 1010 * Get partition info for specified partition number. 1011 * 1012 * Arguments: 1013 * cmlbhandle cmlb handle associated with device. 1014 * part partition number 1015 * nblocksp pointer to number of blocks 1016 * startblockp pointer to starting block 1017 * partnamep pointer to name of partition 1018 * tagp pointer to tag info 1019 * tg_cookie cookie from target driver to be passed back to target 1020 * driver when we call back to it through tg_ops. 1021 * 1022 * 1023 * Notes: 1024 * If in-core label is not valid, this functions tries to revalidate 1025 * the label. If label is valid, it stores the total number of blocks 1026 * in this partition in the area pointed to by nblocksp, starting 1027 * block number in area pointed to by startblockp, pointer to partition 1028 * name in area pointed to by partnamep, and tag value in area 1029 * pointed by tagp. 1030 * For EFI labels, tag value will be set to 0. 1031 * 1032 * For all nblocksp, startblockp and partnamep, tagp, a value of NULL 1033 * indicates the corresponding info is not requested. 1034 * 1035 * 1036 * Return values: 1037 * 0 success 1038 * EINVAL no valid label or requested partition number is invalid. 1039 * 1040 */ 1041 int 1042 cmlb_partinfo(cmlb_handle_t cmlbhandle, int part, diskaddr_t *nblocksp, 1043 diskaddr_t *startblockp, char **partnamep, uint16_t *tagp, void *tg_cookie) 1044 { 1045 1046 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; 1047 int rval; 1048 #if defined(__i386) || defined(__amd64) 1049 int ext_part; 1050 #endif 1051 1052 ASSERT(cl != NULL); 1053 mutex_enter(CMLB_MUTEX(cl)); 1054 if (cl->cl_state < CMLB_ATTACHED) { 1055 mutex_exit(CMLB_MUTEX(cl)); 1056 return (EINVAL); 1057 } 1058 1059 if (part < 0 || part >= MAXPART) { 1060 rval = EINVAL; 1061 } else { 1062 if (!cl->cl_f_geometry_is_valid) 1063 (void) cmlb_validate_geometry((struct cmlb_lun *)cl, 1064 B_FALSE, 0, tg_cookie); 1065 1066 if (((!cl->cl_f_geometry_is_valid) || 1067 (part < NDKMAP && cl->cl_solaris_size == 0)) && 1068 (part != P0_RAW_DISK)) { 1069 rval = EINVAL; 1070 } else { 1071 if (startblockp != NULL) 1072 *startblockp = (diskaddr_t)cl->cl_offset[part]; 1073 1074 if (nblocksp != NULL) 1075 *nblocksp = (diskaddr_t) 1076 cl->cl_map[part].dkl_nblk; 1077 1078 if (tagp != NULL) 1079 *tagp = 1080 ((cl->cl_cur_labeltype == CMLB_LABEL_EFI) || 1081 (part >= NDKMAP)) ? V_UNASSIGNED : 1082 cl->cl_vtoc.v_part[part].p_tag; 1083 rval = 0; 1084 } 1085 1086 /* consistent with behavior of sd for getting minor name */ 1087 if (partnamep != NULL) { 1088 #if defined(__i386) || defined(__amd64) 1089 #if defined(_FIRMWARE_NEEDS_FDISK) 1090 if (part > FDISK_P4) { 1091 ext_part = part-FDISK_P4-1; 1092 *partnamep = dk_ext_minor_data[ext_part].name; 1093 } else 1094 #endif 1095 #endif 1096 *partnamep = dk_minor_data[part].name; 1097 } 1098 1099 } 1100 1101 mutex_exit(CMLB_MUTEX(cl)); 1102 return (rval); 1103 } 1104 1105 /* 1106 * cmlb_efi_label_capacity: 1107 * Get capacity stored in EFI disk label. 1108 * 1109 * Arguments: 1110 * cmlbhandle cmlb handle associated with device. 1111 * capacity pointer to capacity stored in EFI disk label. 1112 * tg_cookie cookie from target driver to be passed back to target 1113 * driver when we call back to it through tg_ops. 1114 * 1115 * 1116 * Notes: 1117 * If in-core label is not valid, this functions tries to revalidate 1118 * the label. If label is valid and is an EFI label, it stores the capacity 1119 * in disk label in the area pointed to by capacity. 1120 * 1121 * 1122 * Return values: 1123 * 0 success 1124 * EINVAL no valid EFI label or capacity is NULL. 1125 * 1126 */ 1127 int 1128 cmlb_efi_label_capacity(cmlb_handle_t cmlbhandle, diskaddr_t *capacity, 1129 void *tg_cookie) 1130 { 1131 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; 1132 int rval; 1133 1134 ASSERT(cl != NULL); 1135 mutex_enter(CMLB_MUTEX(cl)); 1136 if (cl->cl_state < CMLB_ATTACHED) { 1137 mutex_exit(CMLB_MUTEX(cl)); 1138 return (EINVAL); 1139 } 1140 1141 if (!cl->cl_f_geometry_is_valid) 1142 (void) cmlb_validate_geometry((struct cmlb_lun *)cl, B_FALSE, 1143 0, tg_cookie); 1144 1145 if ((!cl->cl_f_geometry_is_valid) || (capacity == NULL) || 1146 (cl->cl_cur_labeltype != CMLB_LABEL_EFI)) { 1147 rval = EINVAL; 1148 } else { 1149 *capacity = (diskaddr_t)cl->cl_map[WD_NODE].dkl_nblk; 1150 rval = 0; 1151 } 1152 1153 mutex_exit(CMLB_MUTEX(cl)); 1154 return (rval); 1155 } 1156 1157 /* Caller should make sure Test Unit Ready succeeds before calling this. */ 1158 /*ARGSUSED*/ 1159 int 1160 cmlb_ioctl(cmlb_handle_t cmlbhandle, dev_t dev, int cmd, intptr_t arg, 1161 int flag, cred_t *cred_p, int *rval_p, void *tg_cookie) 1162 { 1163 1164 int err; 1165 struct cmlb_lun *cl; 1166 1167 cl = (struct cmlb_lun *)cmlbhandle; 1168 1169 ASSERT(cl != NULL); 1170 1171 mutex_enter(CMLB_MUTEX(cl)); 1172 if (cl->cl_state < CMLB_ATTACHED) { 1173 mutex_exit(CMLB_MUTEX(cl)); 1174 return (EIO); 1175 } 1176 1177 switch (cmd) { 1178 case DKIOCSEXTVTOC: 1179 case DKIOCSGEOM: 1180 case DKIOCSETEFI: 1181 case DKIOCSMBOOT: 1182 #if defined(__i386) || defined(__amd64) 1183 case DKIOCSETEXTPART: 1184 #endif 1185 break; 1186 case DKIOCSVTOC: 1187 #if defined(__i386) || defined(__amd64) 1188 case DKIOCPARTINFO: 1189 #endif 1190 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) { 1191 mutex_exit(CMLB_MUTEX(cl)); 1192 return (EOVERFLOW); 1193 } 1194 break; 1195 default: 1196 (void) cmlb_validate_geometry(cl, 1, CMLB_SILENT, 1197 tg_cookie); 1198 1199 switch (cmd) { 1200 case DKIOCGVTOC: 1201 case DKIOCGAPART: 1202 case DKIOCSAPART: 1203 1204 if (cl->cl_label_from_media == CMLB_LABEL_EFI) { 1205 /* GPT label on disk */ 1206 mutex_exit(CMLB_MUTEX(cl)); 1207 return (ENOTSUP); 1208 } else if 1209 (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) { 1210 mutex_exit(CMLB_MUTEX(cl)); 1211 return (EOVERFLOW); 1212 } 1213 break; 1214 1215 case DKIOCGGEOM: 1216 if (cl->cl_label_from_media == CMLB_LABEL_EFI) { 1217 /* GPT label on disk */ 1218 mutex_exit(CMLB_MUTEX(cl)); 1219 return (ENOTSUP); 1220 } 1221 break; 1222 default: 1223 break; 1224 } 1225 } 1226 1227 mutex_exit(CMLB_MUTEX(cl)); 1228 1229 switch (cmd) { 1230 case DKIOCGGEOM: 1231 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGGEOM\n"); 1232 err = cmlb_dkio_get_geometry(cl, (caddr_t)arg, flag, tg_cookie); 1233 break; 1234 1235 case DKIOCSGEOM: 1236 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSGEOM\n"); 1237 err = cmlb_dkio_set_geometry(cl, (caddr_t)arg, flag); 1238 break; 1239 1240 case DKIOCGAPART: 1241 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGAPART\n"); 1242 err = cmlb_dkio_get_partition(cl, (caddr_t)arg, 1243 flag, tg_cookie); 1244 break; 1245 1246 case DKIOCSAPART: 1247 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSAPART\n"); 1248 err = cmlb_dkio_set_partition(cl, (caddr_t)arg, flag); 1249 break; 1250 1251 case DKIOCGVTOC: 1252 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGVTOC\n"); 1253 err = cmlb_dkio_get_vtoc(cl, (caddr_t)arg, flag, tg_cookie); 1254 break; 1255 1256 case DKIOCGEXTVTOC: 1257 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGVTOC\n"); 1258 err = cmlb_dkio_get_extvtoc(cl, (caddr_t)arg, flag, tg_cookie); 1259 break; 1260 1261 case DKIOCGETEFI: 1262 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGETEFI\n"); 1263 err = cmlb_dkio_get_efi(cl, (caddr_t)arg, flag, tg_cookie); 1264 break; 1265 1266 case DKIOCPARTITION: 1267 cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTITION\n"); 1268 err = cmlb_dkio_partition(cl, (caddr_t)arg, flag, tg_cookie); 1269 break; 1270 1271 case DKIOCSVTOC: 1272 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSVTOC\n"); 1273 err = cmlb_dkio_set_vtoc(cl, dev, (caddr_t)arg, flag, 1274 tg_cookie); 1275 break; 1276 1277 case DKIOCSEXTVTOC: 1278 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSVTOC\n"); 1279 err = cmlb_dkio_set_extvtoc(cl, dev, (caddr_t)arg, flag, 1280 tg_cookie); 1281 break; 1282 1283 case DKIOCSETEFI: 1284 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSETEFI\n"); 1285 err = cmlb_dkio_set_efi(cl, dev, (caddr_t)arg, flag, tg_cookie); 1286 break; 1287 1288 case DKIOCGMBOOT: 1289 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGMBOOT\n"); 1290 err = cmlb_dkio_get_mboot(cl, (caddr_t)arg, flag, tg_cookie); 1291 break; 1292 1293 case DKIOCSMBOOT: 1294 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSMBOOT\n"); 1295 err = cmlb_dkio_set_mboot(cl, (caddr_t)arg, flag, tg_cookie); 1296 break; 1297 case DKIOCG_PHYGEOM: 1298 cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_PHYGEOM\n"); 1299 #if defined(__i386) || defined(__amd64) 1300 err = cmlb_dkio_get_phygeom(cl, (caddr_t)arg, flag, tg_cookie); 1301 #else 1302 err = ENOTTY; 1303 #endif 1304 break; 1305 case DKIOCG_VIRTGEOM: 1306 cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_VIRTGEOM\n"); 1307 #if defined(__i386) || defined(__amd64) 1308 err = cmlb_dkio_get_virtgeom(cl, (caddr_t)arg, flag); 1309 #else 1310 err = ENOTTY; 1311 #endif 1312 break; 1313 case DKIOCPARTINFO: 1314 cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTINFO"); 1315 #if defined(__i386) || defined(__amd64) 1316 err = cmlb_dkio_partinfo(cl, dev, (caddr_t)arg, flag); 1317 #else 1318 err = ENOTTY; 1319 #endif 1320 break; 1321 case DKIOCEXTPARTINFO: 1322 cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTINFO"); 1323 #if defined(__i386) || defined(__amd64) 1324 err = cmlb_dkio_extpartinfo(cl, dev, (caddr_t)arg, flag); 1325 #else 1326 err = ENOTTY; 1327 #endif 1328 break; 1329 #if defined(__i386) || defined(__amd64) 1330 case DKIOCSETEXTPART: 1331 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSETEXTPART"); 1332 err = cmlb_dkio_set_ext_part(cl, (caddr_t)arg, flag, tg_cookie); 1333 break; 1334 #endif 1335 default: 1336 err = ENOTTY; 1337 1338 } 1339 1340 /* 1341 * An ioctl that succeeds and changed ('set') size(9P) information 1342 * needs to invalidate the cached devinfo snapshot to avoid having 1343 * old information being returned in a snapshots. 1344 * 1345 * NB: When available, call ddi_change_minor_node() to clear 1346 * SSIZEVALID in specfs vnodes via spec_size_invalidate(). 1347 */ 1348 if (err == 0) { 1349 switch (cmd) { 1350 case DKIOCSGEOM: 1351 case DKIOCSAPART: 1352 case DKIOCSVTOC: 1353 case DKIOCSEXTVTOC: 1354 case DKIOCSETEFI: 1355 i_ddi_prop_dyn_cache_invalidate(CMLB_DEVINFO(cl), 1356 i_ddi_prop_dyn_driver_get(CMLB_DEVINFO(cl))); 1357 } 1358 } 1359 return (err); 1360 } 1361 1362 dev_t 1363 cmlb_make_device(struct cmlb_lun *cl) 1364 { 1365 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) { 1366 return (makedevice(ddi_driver_major(CMLB_DEVINFO(cl)), 1367 ddi_get_instance( 1368 CMLB_DEVINFO(cl)) << CMLBUNIT_FORCE_P0_SHIFT)); 1369 } else { 1370 return (makedevice(ddi_driver_major(CMLB_DEVINFO(cl)), 1371 ddi_get_instance(CMLB_DEVINFO(cl)) << CMLBUNIT_SHIFT)); 1372 } 1373 } 1374 1375 /* 1376 * Function: cmlb_check_update_blockcount 1377 * 1378 * Description: If current capacity value is invalid, obtains the 1379 * current capacity from target driver. 1380 * 1381 * Return Code: 0 success 1382 * EIO failure 1383 */ 1384 static int 1385 cmlb_check_update_blockcount(struct cmlb_lun *cl, void *tg_cookie) 1386 { 1387 int status; 1388 diskaddr_t capacity; 1389 uint32_t lbasize; 1390 1391 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 1392 1393 if (cl->cl_f_geometry_is_valid) 1394 return (0); 1395 1396 mutex_exit(CMLB_MUTEX(cl)); 1397 status = DK_TG_GETCAP(cl, &capacity, tg_cookie); 1398 if (status != 0) { 1399 mutex_enter(CMLB_MUTEX(cl)); 1400 return (EIO); 1401 } 1402 1403 status = DK_TG_GETBLOCKSIZE(cl, &lbasize, tg_cookie); 1404 mutex_enter(CMLB_MUTEX(cl)); 1405 if (status != 0) 1406 return (EIO); 1407 1408 if ((capacity != 0) && (lbasize != 0)) { 1409 cl->cl_blockcount = capacity; 1410 cl->cl_tgt_blocksize = lbasize; 1411 if (!cl->cl_is_removable) { 1412 cl->cl_sys_blocksize = lbasize; 1413 } 1414 return (0); 1415 } else { 1416 return (EIO); 1417 } 1418 } 1419 1420 static int 1421 cmlb_create_minor(dev_info_t *dip, char *name, int spec_type, 1422 minor_t minor_num, char *node_type, int flag, boolean_t internal) 1423 { 1424 ASSERT(VALID_BOOLEAN(internal)); 1425 1426 if (internal) 1427 return (ddi_create_internal_pathname(dip, 1428 name, spec_type, minor_num)); 1429 else 1430 return (ddi_create_minor_node(dip, 1431 name, spec_type, minor_num, node_type, flag)); 1432 } 1433 1434 /* 1435 * Function: cmlb_create_minor_nodes 1436 * 1437 * Description: Create or adjust the minor device nodes for the instance. 1438 * Minor nodes are created based on default label type, 1439 * current label type and last label type we created 1440 * minor nodes based on. 1441 * 1442 * 1443 * Arguments: cl - driver soft state (unit) structure 1444 * 1445 * Return Code: 0 success 1446 * ENXIO failure. 1447 * 1448 * Context: Kernel thread context 1449 */ 1450 static int 1451 cmlb_create_minor_nodes(struct cmlb_lun *cl) 1452 { 1453 struct driver_minor_data *dmdp; 1454 int instance, shift; 1455 char name[48]; 1456 cmlb_label_t newlabeltype; 1457 boolean_t internal; 1458 1459 ASSERT(cl != NULL); 1460 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 1461 1462 internal = VOID2BOOLEAN( 1463 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0); 1464 1465 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) 1466 shift = CMLBUNIT_FORCE_P0_SHIFT; 1467 else 1468 shift = CMLBUNIT_SHIFT; 1469 1470 /* check the most common case */ 1471 if (cl->cl_cur_labeltype != CMLB_LABEL_UNDEF && 1472 cl->cl_last_labeltype == cl->cl_cur_labeltype) { 1473 /* do nothing */ 1474 return (0); 1475 } 1476 1477 if (cl->cl_def_labeltype == CMLB_LABEL_UNDEF) { 1478 /* we should never get here */ 1479 return (ENXIO); 1480 } 1481 1482 if (cl->cl_last_labeltype == CMLB_LABEL_UNDEF) { 1483 /* first time during attach */ 1484 newlabeltype = cl->cl_def_labeltype; 1485 1486 instance = ddi_get_instance(CMLB_DEVINFO(cl)); 1487 1488 /* Create all the minor nodes for this target. */ 1489 dmdp = (newlabeltype == CMLB_LABEL_EFI) ? dk_minor_data_efi : 1490 dk_minor_data; 1491 while (dmdp->name != NULL) { 1492 1493 (void) sprintf(name, "%s", dmdp->name); 1494 1495 if (cmlb_create_minor(CMLB_DEVINFO(cl), name, 1496 dmdp->type, 1497 (instance << shift) | dmdp->minor, 1498 cl->cl_node_type, 0, internal) == DDI_FAILURE) { 1499 /* 1500 * Clean up any nodes that may have been 1501 * created, in case this fails in the middle 1502 * of the loop. 1503 */ 1504 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL); 1505 return (ENXIO); 1506 } 1507 dmdp++; 1508 } 1509 cl->cl_last_labeltype = newlabeltype; 1510 #if defined(_SUNOS_VTOC_8) 1511 /* 1512 * "emulate" p0 device for sparc, used by lofi 1513 */ 1514 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) { 1515 if (cmlb_create_minor(CMLB_DEVINFO(cl), "q", S_IFBLK, 1516 (instance << CMLBUNIT_FORCE_P0_SHIFT) | P0_RAW_DISK, 1517 cl->cl_node_type, NULL, internal) == DDI_FAILURE) { 1518 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL); 1519 return (ENXIO); 1520 } 1521 1522 if (cmlb_create_minor(CMLB_DEVINFO(cl), "q,raw", 1523 S_IFCHR, 1524 (instance << CMLBUNIT_FORCE_P0_SHIFT) | P0_RAW_DISK, 1525 cl->cl_node_type, NULL, internal) == DDI_FAILURE) { 1526 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL); 1527 return (ENXIO); 1528 } 1529 } 1530 #endif /* defined(_SUNOS_VTOC_8) */ 1531 return (0); 1532 } 1533 1534 /* Not first time */ 1535 if (cl->cl_cur_labeltype == CMLB_LABEL_UNDEF) { 1536 if (cl->cl_last_labeltype != cl->cl_def_labeltype) { 1537 /* close time, revert to default. */ 1538 newlabeltype = cl->cl_def_labeltype; 1539 } else { 1540 /* 1541 * do nothing since the type for which we last created 1542 * nodes matches the default 1543 */ 1544 return (0); 1545 } 1546 } else { 1547 if (cl->cl_cur_labeltype != cl->cl_last_labeltype) { 1548 /* We are not closing, use current label type */ 1549 newlabeltype = cl->cl_cur_labeltype; 1550 } else { 1551 /* 1552 * do nothing since the type for which we last created 1553 * nodes matches the current label type 1554 */ 1555 return (0); 1556 } 1557 } 1558 1559 instance = ddi_get_instance(CMLB_DEVINFO(cl)); 1560 1561 /* 1562 * Currently we only fix up the s7 node when we are switching 1563 * label types from or to EFI. This is consistent with 1564 * current behavior of sd. 1565 */ 1566 if (newlabeltype == CMLB_LABEL_EFI && 1567 cl->cl_last_labeltype != CMLB_LABEL_EFI) { 1568 /* from vtoc to EFI */ 1569 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h"); 1570 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw"); 1571 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd", 1572 S_IFBLK, (instance << shift) | WD_NODE, 1573 cl->cl_node_type, 0, internal); 1574 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd,raw", 1575 S_IFCHR, (instance << shift) | WD_NODE, 1576 cl->cl_node_type, 0, internal); 1577 } else { 1578 /* from efi to vtoc */ 1579 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd"); 1580 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw"); 1581 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h", 1582 S_IFBLK, (instance << shift) | WD_NODE, 1583 cl->cl_node_type, 0, internal); 1584 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw", 1585 S_IFCHR, (instance << shift) | WD_NODE, 1586 cl->cl_node_type, 0, internal); 1587 } 1588 1589 cl->cl_last_labeltype = newlabeltype; 1590 return (0); 1591 } 1592 1593 /* 1594 * Function: cmlb_validate_geometry 1595 * 1596 * Description: Read the label from the disk (if present). Update the unit's 1597 * geometry and vtoc information from the data in the label. 1598 * Verify that the label is valid. 1599 * 1600 * Arguments: 1601 * cl driver soft state (unit) structure 1602 * 1603 * forcerevalid force revalidation even if we are already valid. 1604 * flags operation flags from target driver. Used for verbosity 1605 * control at this time. 1606 * tg_cookie cookie from target driver to be passed back to target 1607 * driver when we call back to it through tg_ops. 1608 * 1609 * Return Code: 0 - Successful completion 1610 * EINVAL - Invalid value in cl->cl_tgt_blocksize or 1611 * cl->cl_blockcount; or label on disk is corrupted 1612 * or unreadable. 1613 * EACCES - Reservation conflict at the device. 1614 * ENOMEM - Resource allocation error 1615 * ENOTSUP - geometry not applicable 1616 * 1617 * Context: Kernel thread only (can sleep). 1618 */ 1619 static int 1620 cmlb_validate_geometry(struct cmlb_lun *cl, boolean_t forcerevalid, int flags, 1621 void *tg_cookie) 1622 { 1623 int label_error = 0; 1624 diskaddr_t capacity; 1625 int count; 1626 1627 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 1628 ASSERT(VALID_BOOLEAN(forcerevalid)); 1629 1630 if ((cl->cl_f_geometry_is_valid) && (!forcerevalid)) { 1631 if (cl->cl_cur_labeltype == CMLB_LABEL_EFI) 1632 return (ENOTSUP); 1633 return (0); 1634 } 1635 1636 if (cmlb_check_update_blockcount(cl, tg_cookie) != 0) 1637 return (EIO); 1638 1639 capacity = cl->cl_blockcount; 1640 1641 /* 1642 * Set up the "whole disk" fdisk partition; this should always 1643 * exist, regardless of whether the disk contains an fdisk table 1644 * or vtoc. 1645 */ 1646 cl->cl_map[P0_RAW_DISK].dkl_cylno = 0; 1647 cl->cl_offset[P0_RAW_DISK] = 0; 1648 /* 1649 * note if capacity > int32_max(1TB) we are in 64bit environment 1650 * so no truncation happens 1651 */ 1652 cl->cl_map[P0_RAW_DISK].dkl_nblk = capacity; 1653 1654 /* 1655 * Refresh the logical and physical geometry caches. 1656 * (data from MODE SENSE format/rigid disk geometry pages, 1657 * and scsi_ifgetcap("geometry"). 1658 */ 1659 cmlb_resync_geom_caches(cl, capacity, tg_cookie); 1660 1661 cl->cl_label_from_media = CMLB_LABEL_UNDEF; 1662 label_error = cmlb_use_efi(cl, capacity, flags, tg_cookie); 1663 if (label_error == 0) { 1664 1665 /* found a valid EFI label */ 1666 cmlb_dbg(CMLB_TRACE, cl, 1667 "cmlb_validate_geometry: found EFI label\n"); 1668 /* 1669 * solaris_size and geometry_is_valid are set in 1670 * cmlb_use_efi 1671 */ 1672 return (ENOTSUP); 1673 } 1674 1675 /* NO EFI label found */ 1676 1677 if (capacity > CMLB_EXTVTOC_LIMIT) { 1678 if (label_error == ESRCH) { 1679 /* 1680 * they've configured a LUN over 2TB, but used 1681 * format.dat to restrict format's view of the 1682 * capacity to be under 2TB in some earlier Solaris 1683 * release. 1684 */ 1685 /* i.e > 2TB with a VTOC < 2TB */ 1686 if (!(flags & CMLB_SILENT) && 1687 (cl->cl_msglog_flag & CMLB_ALLOW_2TB_WARN)) { 1688 1689 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), 1690 CE_NOTE, "!Disk (%s%d) is limited to 2 TB " 1691 "due to VTOC label. To use the full " 1692 "capacity of the disk, use format(1M) to " 1693 "relabel the disk with EFI/GPT label.\n", 1694 CMLB_LABEL(cl), 1695 ddi_get_instance(CMLB_DEVINFO(cl))); 1696 1697 cl->cl_msglog_flag &= ~CMLB_ALLOW_2TB_WARN; 1698 } 1699 } else { 1700 return (ENOTSUP); 1701 } 1702 } 1703 1704 label_error = 0; 1705 1706 /* 1707 * at this point it is either labeled with a VTOC or it is 1708 * under 1TB (<= 1TB actually for off-by-1) 1709 */ 1710 1711 /* 1712 * Only DIRECT ACCESS devices will have Scl labels. 1713 * CD's supposedly have a Scl label, too 1714 */ 1715 if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) { 1716 struct dk_label *dkl; 1717 offset_t label_addr; 1718 int rval; 1719 size_t buffer_size; 1720 1721 /* 1722 * Note: This will set up cl->cl_solaris_size and 1723 * cl->cl_solaris_offset. 1724 */ 1725 rval = cmlb_read_fdisk(cl, capacity, tg_cookie); 1726 if ((rval != 0) && !ISCD(cl)) { 1727 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 1728 return (rval); 1729 } 1730 1731 if (cl->cl_solaris_size <= DK_LABEL_LOC) { 1732 /* 1733 * Found fdisk table but no Solaris partition entry, 1734 * so don't call cmlb_uselabel() and don't create 1735 * a default label. 1736 */ 1737 label_error = 0; 1738 cl->cl_f_geometry_is_valid = B_TRUE; 1739 goto no_solaris_partition; 1740 } 1741 1742 label_addr = (daddr_t)(cl->cl_solaris_offset + DK_LABEL_LOC); 1743 1744 buffer_size = cl->cl_sys_blocksize; 1745 1746 cmlb_dbg(CMLB_TRACE, cl, "cmlb_validate_geometry: " 1747 "label_addr: 0x%x allocation size: 0x%x\n", 1748 label_addr, buffer_size); 1749 1750 if ((dkl = kmem_zalloc(buffer_size, KM_NOSLEEP)) == NULL) 1751 return (ENOMEM); 1752 1753 mutex_exit(CMLB_MUTEX(cl)); 1754 rval = DK_TG_READ(cl, dkl, label_addr, buffer_size, tg_cookie); 1755 mutex_enter(CMLB_MUTEX(cl)); 1756 1757 switch (rval) { 1758 case 0: 1759 /* 1760 * cmlb_uselabel will establish that the geometry 1761 * is valid. 1762 */ 1763 if (cmlb_uselabel(cl, 1764 (struct dk_label *)(uintptr_t)dkl, flags) != 1765 CMLB_LABEL_IS_VALID) { 1766 label_error = EINVAL; 1767 } else 1768 cl->cl_label_from_media = CMLB_LABEL_VTOC; 1769 break; 1770 case EACCES: 1771 label_error = EACCES; 1772 break; 1773 default: 1774 label_error = EINVAL; 1775 break; 1776 } 1777 1778 kmem_free(dkl, buffer_size); 1779 } 1780 1781 /* 1782 * If a valid label was not found, AND if no reservation conflict 1783 * was detected, then go ahead and create a default label (4069506). 1784 * 1785 * Note: currently, for VTOC_8 devices, the default label is created 1786 * for removables and hotpluggables only. For VTOC_16 devices, the 1787 * default label will be created for all devices. 1788 * (see cmlb_build_default_label) 1789 */ 1790 #if defined(_SUNOS_VTOC_8) 1791 if ((ISREMOVABLE(cl) || ISHOTPLUGGABLE(cl)) && 1792 (label_error != EACCES)) { 1793 #elif defined(_SUNOS_VTOC_16) 1794 if (label_error != EACCES) { 1795 #endif 1796 if (!cl->cl_f_geometry_is_valid) { 1797 cmlb_build_default_label(cl, tg_cookie); 1798 } 1799 label_error = 0; 1800 } 1801 1802 no_solaris_partition: 1803 1804 #if defined(_SUNOS_VTOC_16) 1805 /* 1806 * If we have valid geometry, set up the remaining fdisk partitions. 1807 * Note that dkl_cylno is not used for the fdisk map entries, so 1808 * we set it to an entirely bogus value. 1809 */ 1810 for (count = 0; count < FDISK_PARTS; count++) { 1811 cl->cl_map[FDISK_P1 + count].dkl_cylno = UINT16_MAX; 1812 cl->cl_map[FDISK_P1 + count].dkl_nblk = 1813 cl->cl_fmap[count].fmap_nblk; 1814 1815 cl->cl_offset[FDISK_P1 + count] = 1816 cl->cl_fmap[count].fmap_start; 1817 } 1818 #endif 1819 1820 for (count = 0; count < NDKMAP; count++) { 1821 #if defined(_SUNOS_VTOC_8) 1822 struct dk_map *lp = &cl->cl_map[count]; 1823 cl->cl_offset[count] = 1824 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno; 1825 #elif defined(_SUNOS_VTOC_16) 1826 struct dkl_partition *vp = &cl->cl_vtoc.v_part[count]; 1827 1828 cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset; 1829 #else 1830 #error "No VTOC format defined." 1831 #endif 1832 } 1833 1834 return (label_error); 1835 } 1836 1837 #if defined(_SUNOS_VTOC_16) 1838 /* 1839 * Function: cmlb_convert_geometry 1840 * 1841 * Description: Convert physical geometry into a dk_geom structure. In 1842 * other words, make sure we don't wrap 16-bit values. 1843 * e.g. converting from geom_cache to dk_geom 1844 * 1845 * Context: Kernel thread only 1846 */ 1847 static void 1848 cmlb_convert_geometry(struct cmlb_lun *cl, diskaddr_t capacity, 1849 struct dk_geom *cl_g, void *tg_cookie) 1850 { 1851 1852 ASSERT(cl != NULL); 1853 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 1854 1855 /* Unlabeled SCSI floppy device */ 1856 if (capacity < 160) { 1857 /* Less than 80K */ 1858 cl_g->dkg_nhead = 1; 1859 cl_g->dkg_ncyl = capacity; 1860 cl_g->dkg_nsect = 1; 1861 return; 1862 } else if (capacity <= 0x1000) { 1863 cl_g->dkg_nhead = 2; 1864 cl_g->dkg_ncyl = 80; 1865 cl_g->dkg_nsect = capacity / (cl_g->dkg_nhead * cl_g->dkg_ncyl); 1866 return; 1867 } 1868 1869 /* 1870 * For all devices we calculate cylinders using the heads and sectors 1871 * we assign based on capacity of the device. The algorithm is 1872 * designed to be compatible with the way other operating systems 1873 * lay out fdisk tables for X86 and to insure that the cylinders never 1874 * exceed 65535 to prevent problems with X86 ioctls that report 1875 * geometry. 1876 * For some smaller disk sizes we report geometry that matches those 1877 * used by X86 BIOS usage. For larger disks, we use SPT that are 1878 * multiples of 63, since other OSes that are not limited to 16-bits 1879 * for cylinders stop at 63 SPT we make do by using multiples of 63 SPT. 1880 * 1881 * The following table (in order) illustrates some end result 1882 * calculations: 1883 * 1884 * Maximum number of blocks nhead nsect 1885 * 1886 * 2097152 (1GB) 64 32 1887 * 16777216 (8GB) 128 32 1888 * 1052819775 (502.02GB) 255 63 1889 * 2105639550 (0.98TB) 255 126 1890 * 3158459325 (1.47TB) 255 189 1891 * 4211279100 (1.96TB) 255 252 1892 * 5264098875 (2.45TB) 255 315 1893 * ... 1894 * 1895 * For Solid State Drive(SSD), it uses 4K page size inside and may be 1896 * double with every new generation. If the I/O is not aligned with 1897 * page size on SSDs, SSDs perform a lot slower. 1898 * By default, Solaris partition starts from cylinder 1. It will be 1899 * misaligned even with 4K if using heads(255) and SPT(63). To 1900 * workaround the problem, if the device is SSD, we use heads(224) and 1901 * SPT multiple of 56. Thus the default Solaris partition starts from 1902 * a position that aligns with 128K on a 512 bytes sector size SSD. 1903 */ 1904 1905 if (capacity <= 0x200000) { 1906 cl_g->dkg_nhead = 64; 1907 cl_g->dkg_nsect = 32; 1908 } else if (capacity <= 0x01000000) { 1909 cl_g->dkg_nhead = 128; 1910 cl_g->dkg_nsect = 32; 1911 } else { 1912 tg_attribute_t tgattribute; 1913 int is_solid_state; 1914 unsigned short nhead; 1915 unsigned short nsect; 1916 1917 bzero(&tgattribute, sizeof (tg_attribute_t)); 1918 1919 mutex_exit(CMLB_MUTEX(cl)); 1920 is_solid_state = 1921 (DK_TG_GETATTRIBUTE(cl, &tgattribute, tg_cookie) == 0) ? 1922 tgattribute.media_is_solid_state : FALSE; 1923 mutex_enter(CMLB_MUTEX(cl)); 1924 1925 if (is_solid_state) { 1926 nhead = 224; 1927 nsect = 56; 1928 } else { 1929 nhead = 255; 1930 nsect = 63; 1931 } 1932 1933 cl_g->dkg_nhead = nhead; 1934 1935 /* make dkg_nsect be smallest multiple of nsect */ 1936 cl_g->dkg_nsect = ((capacity + 1937 (UINT16_MAX * nhead * nsect) - 1) / 1938 (UINT16_MAX * nhead * nsect)) * nsect; 1939 1940 if (cl_g->dkg_nsect == 0) 1941 cl_g->dkg_nsect = (UINT16_MAX / nsect) * nsect; 1942 } 1943 1944 } 1945 #endif 1946 1947 /* 1948 * Function: cmlb_resync_geom_caches 1949 * 1950 * Description: (Re)initialize both geometry caches: the virtual geometry 1951 * information is extracted from the HBA (the "geometry" 1952 * capability), and the physical geometry cache data is 1953 * generated by issuing MODE SENSE commands. 1954 * 1955 * Arguments: 1956 * cl driver soft state (unit) structure 1957 * capacity disk capacity in #blocks 1958 * tg_cookie cookie from target driver to be passed back to target 1959 * driver when we call back to it through tg_ops. 1960 * 1961 * Context: Kernel thread only (can sleep). 1962 */ 1963 static void 1964 cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity, 1965 void *tg_cookie) 1966 { 1967 struct cmlb_geom pgeom; 1968 struct cmlb_geom lgeom; 1969 struct cmlb_geom *pgeomp = &pgeom; 1970 unsigned short nhead; 1971 unsigned short nsect; 1972 int spc; 1973 int ret; 1974 1975 ASSERT(cl != NULL); 1976 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 1977 1978 /* 1979 * Ask the controller for its logical geometry. 1980 * Note: if the HBA does not support scsi_ifgetcap("geometry"), 1981 * then the lgeom cache will be invalid. 1982 */ 1983 mutex_exit(CMLB_MUTEX(cl)); 1984 bzero(&lgeom, sizeof (struct cmlb_geom)); 1985 ret = DK_TG_GETVIRTGEOM(cl, &lgeom, tg_cookie); 1986 mutex_enter(CMLB_MUTEX(cl)); 1987 1988 bcopy(&lgeom, &cl->cl_lgeom, sizeof (cl->cl_lgeom)); 1989 1990 /* 1991 * Initialize the pgeom cache from lgeom, so that if MODE SENSE 1992 * doesn't work, DKIOCG_PHYSGEOM can return reasonable values. 1993 */ 1994 if (ret != 0 || cl->cl_lgeom.g_nsect == 0 || 1995 cl->cl_lgeom.g_nhead == 0) { 1996 /* 1997 * Note: Perhaps this needs to be more adaptive? The rationale 1998 * is that, if there's no HBA geometry from the HBA driver, any 1999 * guess is good, since this is the physical geometry. If MODE 2000 * SENSE fails this gives a max cylinder size for non-LBA access 2001 */ 2002 nhead = 255; 2003 nsect = 63; 2004 } else { 2005 nhead = cl->cl_lgeom.g_nhead; 2006 nsect = cl->cl_lgeom.g_nsect; 2007 } 2008 2009 if (ISCD(cl)) { 2010 pgeomp->g_nhead = 1; 2011 pgeomp->g_nsect = nsect * nhead; 2012 } else { 2013 pgeomp->g_nhead = nhead; 2014 pgeomp->g_nsect = nsect; 2015 } 2016 2017 spc = pgeomp->g_nhead * pgeomp->g_nsect; 2018 pgeomp->g_capacity = capacity; 2019 if (spc == 0) 2020 pgeomp->g_ncyl = 0; 2021 else 2022 pgeomp->g_ncyl = pgeomp->g_capacity / spc; 2023 pgeomp->g_acyl = 0; 2024 2025 /* 2026 * Retrieve fresh geometry data from the hardware, stash it 2027 * here temporarily before we rebuild the incore label. 2028 * 2029 * We want to use the MODE SENSE commands to derive the 2030 * physical geometry of the device, but if either command 2031 * fails, the logical geometry is used as the fallback for 2032 * disk label geometry. 2033 */ 2034 2035 mutex_exit(CMLB_MUTEX(cl)); 2036 (void) DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie); 2037 mutex_enter(CMLB_MUTEX(cl)); 2038 2039 /* 2040 * Now update the real copy while holding the mutex. This 2041 * way the global copy is never in an inconsistent state. 2042 */ 2043 bcopy(pgeomp, &cl->cl_pgeom, sizeof (cl->cl_pgeom)); 2044 2045 cmlb_dbg(CMLB_INFO, cl, "cmlb_resync_geom_caches: " 2046 "(cached from lgeom)\n"); 2047 cmlb_dbg(CMLB_INFO, cl, 2048 " ncyl: %ld; acyl: %d; nhead: %d; nsect: %d\n", 2049 cl->cl_pgeom.g_ncyl, cl->cl_pgeom.g_acyl, 2050 cl->cl_pgeom.g_nhead, cl->cl_pgeom.g_nsect); 2051 cmlb_dbg(CMLB_INFO, cl, " lbasize: %d; capacity: %ld; " 2052 "intrlv: %d; rpm: %d\n", cl->cl_pgeom.g_secsize, 2053 cl->cl_pgeom.g_capacity, cl->cl_pgeom.g_intrlv, 2054 cl->cl_pgeom.g_rpm); 2055 } 2056 2057 2058 #if defined(__i386) || defined(__amd64) 2059 /* 2060 * Function: cmlb_update_ext_minor_nodes 2061 * 2062 * Description: Routine to add/remove extended partition device nodes 2063 * 2064 * Arguments: 2065 * cl driver soft state (unit) structure 2066 * num_parts Number of logical drives found on the LUN 2067 * 2068 * Should be called with the mutex held 2069 * 2070 * Return Code: 0 for success 2071 * 2072 * Context: User and Kernel thread 2073 * 2074 */ 2075 static int 2076 cmlb_update_ext_minor_nodes(struct cmlb_lun *cl, int num_parts) 2077 { 2078 int i, count, shift; 2079 char name[48]; 2080 int instance; 2081 struct driver_minor_data *demdp, *demdpr; 2082 char *devnm; 2083 dev_info_t *pdip; 2084 boolean_t internal; 2085 2086 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 2087 ASSERT(cl->cl_update_ext_minor_nodes == 1); 2088 2089 internal = VOID2BOOLEAN( 2090 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0); 2091 instance = ddi_get_instance(CMLB_DEVINFO(cl)); 2092 demdp = dk_ext_minor_data; 2093 demdpr = &dk_ext_minor_data[MAX_EXT_PARTS]; 2094 2095 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) 2096 shift = CMLBUNIT_FORCE_P0_SHIFT; 2097 else 2098 shift = CMLBUNIT_SHIFT; 2099 2100 if (cl->cl_logical_drive_count) { 2101 for (i = 0; i < cl->cl_logical_drive_count; i++) { 2102 (void) sprintf(name, "%s", demdp->name); 2103 ddi_remove_minor_node(CMLB_DEVINFO(cl), name); 2104 (void) sprintf(name, "%s", demdpr->name); 2105 ddi_remove_minor_node(CMLB_DEVINFO(cl), name); 2106 demdp++; 2107 demdpr++; 2108 } 2109 /* There are existing device nodes. Remove them */ 2110 devnm = kmem_alloc(MAXNAMELEN + 1, KM_SLEEP); 2111 (void) ddi_deviname(cl->cl_devi, devnm); 2112 pdip = ddi_get_parent(cl->cl_devi); 2113 (void) devfs_clean(pdip, devnm + 1, DV_CLEAN_FORCE); 2114 kmem_free(devnm, MAXNAMELEN + 1); 2115 } 2116 2117 demdp = dk_ext_minor_data; 2118 demdpr = &dk_ext_minor_data[MAX_EXT_PARTS]; 2119 2120 for (i = 0; i < num_parts; i++) { 2121 (void) sprintf(name, "%s", demdp->name); 2122 if (cmlb_create_minor(CMLB_DEVINFO(cl), name, 2123 demdp->type, 2124 (instance << shift) | demdp->minor, 2125 cl->cl_node_type, 0, internal) == DDI_FAILURE) { 2126 /* 2127 * Clean up any nodes that may have been 2128 * created, in case this fails in the middle 2129 * of the loop. 2130 */ 2131 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL); 2132 cl->cl_logical_drive_count = 0; 2133 return (ENXIO); 2134 } 2135 (void) sprintf(name, "%s", demdpr->name); 2136 if (ddi_create_minor_node(CMLB_DEVINFO(cl), name, 2137 demdpr->type, 2138 (instance << shift) | demdpr->minor, 2139 cl->cl_node_type, 0) == DDI_FAILURE) { 2140 /* 2141 * Clean up any nodes that may have been 2142 * created, in case this fails in the middle 2143 * of the loop. 2144 */ 2145 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL); 2146 cl->cl_logical_drive_count = 0; 2147 return (ENXIO); 2148 } 2149 demdp++; 2150 demdpr++; 2151 } 2152 2153 /* Update the cl_map array for logical drives */ 2154 for (count = 0; count < MAX_EXT_PARTS; count++) { 2155 cl->cl_map[FDISK_P4 + 1 + count].dkl_cylno = UINT32_MAX; 2156 cl->cl_map[FDISK_P4 + 1 + count].dkl_nblk = 2157 cl->cl_fmap[FD_NUMPART + count].fmap_nblk; 2158 cl->cl_offset[FDISK_P4 + 1 + count] = 2159 cl->cl_fmap[FD_NUMPART + count].fmap_start; 2160 } 2161 2162 cl->cl_logical_drive_count = i; 2163 cl->cl_update_ext_minor_nodes = 0; 2164 return (0); 2165 } 2166 /* 2167 * Function: cmlb_validate_ext_part 2168 * 2169 * Description: utility routine to validate an extended partition's 2170 * metadata as found on disk 2171 * 2172 * Arguments: 2173 * cl driver soft state (unit) structure 2174 * part partition number of the extended partition 2175 * epart partition number of the logical drive 2176 * start absolute sector number of the start of the logical 2177 * drive being validated 2178 * size size of logical drive being validated 2179 * 2180 * Return Code: 0 for success 2181 * 2182 * Context: User and Kernel thread 2183 * 2184 * Algorithm : 2185 * Error cases are : 2186 * 1. If start block is lesser than or equal to the end block 2187 * 2. If either start block or end block is beyond the bounadry 2188 * of the extended partition. 2189 * 3. start or end block overlap with existing partitions. 2190 * To check this, first make sure that the start block doesnt 2191 * overlap with existing partitions. Then, calculate the 2192 * possible end block for the given start block that doesnt 2193 * overlap with existing partitions. This can be calculated by 2194 * first setting the possible end block to the end of the 2195 * extended partition (optimistic) and then, checking if there 2196 * is any other partition that lies after the start of the 2197 * partition being validated. If so, set the possible end to 2198 * one block less than the beginning of the next nearest partition 2199 * If the actual end block is greater than the calculated end 2200 * block, we have an overlap. 2201 * 2202 */ 2203 static int 2204 cmlb_validate_ext_part(struct cmlb_lun *cl, int part, int epart, uint32_t start, 2205 uint32_t size) 2206 { 2207 int i; 2208 uint32_t end = start + size - 1; 2209 uint32_t ext_start = cl->cl_fmap[part].fmap_start; 2210 uint32_t ext_end = ext_start + cl->cl_fmap[part].fmap_nblk - 1; 2211 uint32_t ts, te; 2212 uint32_t poss_end = ext_end; 2213 2214 if (end <= start) { 2215 return (1); 2216 } 2217 2218 /* 2219 * Check if the logical drive boundaries are within that of the 2220 * extended partition. 2221 */ 2222 if (start <= ext_start || start > ext_end || end <= ext_start || 2223 end > ext_end) { 2224 return (1); 2225 } 2226 2227 /* 2228 * epart will be equal to FD_NUMPART if it is the first logical drive. 2229 * There is no need to check for overlaps with other logical drives, 2230 * since it is the only logical drive that we have come across so far. 2231 */ 2232 if (epart == FD_NUMPART) { 2233 return (0); 2234 } 2235 2236 /* Check for overlaps with existing logical drives */ 2237 i = FD_NUMPART; 2238 ts = cl->cl_fmap[FD_NUMPART].fmap_start; 2239 te = ts + cl->cl_fmap[FD_NUMPART].fmap_nblk - 1; 2240 2241 while ((i < epart) && ts && te) { 2242 if (start >= ts && start <= te) { 2243 return (1); 2244 } 2245 2246 if ((ts < poss_end) && (ts > start)) { 2247 poss_end = ts - 1; 2248 } 2249 2250 i++; 2251 ts = cl->cl_fmap[i].fmap_start; 2252 te = ts + cl->cl_fmap[i].fmap_nblk - 1; 2253 } 2254 2255 if (end > poss_end) { 2256 return (1); 2257 } 2258 2259 return (0); 2260 } 2261 2262 2263 /* 2264 * Function: cmlb_is_linux_swap 2265 * 2266 * Description: utility routine to verify if a partition is a linux swap 2267 * partition or not. 2268 * 2269 * Arguments: 2270 * cl driver soft state (unit) structure 2271 * part_start absolute sector number of the start of the partition 2272 * being verified 2273 * tg_cookie cookie from target driver to be passed back to target 2274 * driver when we call back to it through tg_ops. 2275 * 2276 * Return Code: 0 for success 2277 * 2278 * Context: User and Kernel thread 2279 * 2280 * Notes: 2281 * The linux swap magic "SWAP-SPACE" or "SWAPSPACE2" is found as the 2282 * last 10 bytes of a disk block whose size is that of the linux page 2283 * size. This disk block is found at the beginning of the swap partition. 2284 */ 2285 static int 2286 cmlb_is_linux_swap(struct cmlb_lun *cl, uint32_t part_start, void *tg_cookie) 2287 { 2288 int i; 2289 int rval = -1; 2290 uint32_t seek_offset; 2291 uint32_t linux_pg_size; 2292 char *buf, *linux_swap_magic; 2293 int sec_sz = cl->cl_sys_blocksize; 2294 /* Known linux kernel page sizes */ 2295 uint32_t linux_pg_size_arr[] = {4096, }; 2296 2297 ASSERT(cl != NULL); 2298 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 2299 2300 if ((buf = kmem_zalloc(sec_sz, KM_NOSLEEP)) == NULL) { 2301 return (ENOMEM); 2302 } 2303 2304 /* 2305 * Check if there is a sane Solaris VTOC 2306 * If there is a valid vtoc, no need to lookup 2307 * for the linux swap signature. 2308 */ 2309 mutex_exit(CMLB_MUTEX(cl)); 2310 rval = DK_TG_READ(cl, buf, part_start + DK_LABEL_LOC, 2311 sec_sz, tg_cookie); 2312 mutex_enter(CMLB_MUTEX(cl)); 2313 if (rval != 0) { 2314 cmlb_dbg(CMLB_ERROR, cl, 2315 "cmlb_is_linux_swap: disk vtoc read err\n"); 2316 rval = EIO; 2317 goto done; 2318 } 2319 2320 if ((((struct dk_label *)buf)->dkl_magic == DKL_MAGIC) && 2321 (((struct dk_label *)buf)->dkl_vtoc.v_sanity == VTOC_SANE)) { 2322 rval = -1; 2323 goto done; 2324 } 2325 2326 2327 /* No valid vtoc, so check for linux swap signature */ 2328 linux_swap_magic = buf + sec_sz - 10; 2329 2330 for (i = 0; i < sizeof (linux_pg_size_arr)/sizeof (uint32_t); i++) { 2331 linux_pg_size = linux_pg_size_arr[i]; 2332 seek_offset = linux_pg_size/sec_sz - 1; 2333 seek_offset += part_start; 2334 2335 mutex_exit(CMLB_MUTEX(cl)); 2336 rval = DK_TG_READ(cl, buf, seek_offset, sec_sz, tg_cookie); 2337 mutex_enter(CMLB_MUTEX(cl)); 2338 2339 if (rval != 0) { 2340 cmlb_dbg(CMLB_ERROR, cl, 2341 "cmlb_is_linux_swap: disk read err\n"); 2342 rval = EIO; 2343 break; 2344 } 2345 2346 rval = -1; 2347 2348 if ((strncmp(linux_swap_magic, "SWAP-SPACE", 10) == 0) || 2349 (strncmp(linux_swap_magic, "SWAPSPACE2", 10) == 0)) { 2350 /* Found a linux swap */ 2351 rval = 0; 2352 break; 2353 } 2354 } 2355 2356 done: 2357 kmem_free(buf, sec_sz); 2358 return (rval); 2359 } 2360 #endif 2361 2362 /* 2363 * Function: cmlb_read_fdisk 2364 * 2365 * Description: utility routine to read the fdisk table. 2366 * 2367 * Arguments: 2368 * cl driver soft state (unit) structure 2369 * capacity disk capacity in #blocks 2370 * tg_cookie cookie from target driver to be passed back to target 2371 * driver when we call back to it through tg_ops. 2372 * 2373 * Return Code: 0 for success (includes not reading for no_fdisk_present case 2374 * errnos from tg_rw if failed to read the first block. 2375 * 2376 * Context: Kernel thread only (can sleep). 2377 */ 2378 /*ARGSUSED*/ 2379 static int 2380 cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity, void *tg_cookie) 2381 { 2382 #if defined(_NO_FDISK_PRESENT) 2383 2384 cl->cl_solaris_offset = 0; 2385 cl->cl_solaris_size = capacity; 2386 bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART); 2387 return (0); 2388 2389 #elif defined(_FIRMWARE_NEEDS_FDISK) 2390 2391 struct ipart *fdp; 2392 struct mboot *mbp; 2393 struct ipart fdisk[FD_NUMPART]; 2394 int i, k; 2395 char sigbuf[2]; 2396 caddr_t bufp; 2397 int uidx; 2398 int rval; 2399 int lba = 0; 2400 uint_t solaris_offset; /* offset to solaris part. */ 2401 daddr_t solaris_size; /* size of solaris partition */ 2402 uint32_t blocksize; 2403 #if defined(__i386) || defined(__amd64) 2404 struct ipart eparts[2]; 2405 struct ipart *efdp1 = &eparts[0]; 2406 struct ipart *efdp2 = &eparts[1]; 2407 int ext_part_exists = 0; 2408 int ld_count = 0; 2409 #endif 2410 2411 ASSERT(cl != NULL); 2412 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 2413 2414 /* 2415 * Start off assuming no fdisk table 2416 */ 2417 solaris_offset = 0; 2418 solaris_size = capacity; 2419 2420 blocksize = cl->cl_tgt_blocksize; 2421 2422 bufp = kmem_zalloc(blocksize, KM_SLEEP); 2423 2424 mutex_exit(CMLB_MUTEX(cl)); 2425 rval = DK_TG_READ(cl, bufp, 0, blocksize, tg_cookie); 2426 mutex_enter(CMLB_MUTEX(cl)); 2427 2428 if (rval != 0) { 2429 cmlb_dbg(CMLB_ERROR, cl, 2430 "cmlb_read_fdisk: fdisk read err\n"); 2431 bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART); 2432 goto done; 2433 } 2434 2435 mbp = (struct mboot *)bufp; 2436 2437 /* 2438 * The fdisk table does not begin on a 4-byte boundary within the 2439 * master boot record, so we copy it to an aligned structure to avoid 2440 * alignment exceptions on some processors. 2441 */ 2442 bcopy(&mbp->parts[0], fdisk, sizeof (fdisk)); 2443 2444 /* 2445 * Check for lba support before verifying sig; sig might not be 2446 * there, say on a blank disk, but the max_chs mark may still 2447 * be present. 2448 * 2449 * Note: LBA support and BEFs are an x86-only concept but this 2450 * code should work OK on SPARC as well. 2451 */ 2452 2453 /* 2454 * First, check for lba-access-ok on root node (or prom root node) 2455 * if present there, don't need to search fdisk table. 2456 */ 2457 if (ddi_getprop(DDI_DEV_T_ANY, ddi_root_node(), 0, 2458 "lba-access-ok", 0) != 0) { 2459 /* All drives do LBA; don't search fdisk table */ 2460 lba = 1; 2461 } else { 2462 /* Okay, look for mark in fdisk table */ 2463 for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) { 2464 /* accumulate "lba" value from all partitions */ 2465 lba = (lba || cmlb_has_max_chs_vals(fdp)); 2466 } 2467 } 2468 2469 if (lba != 0) { 2470 dev_t dev = cmlb_make_device(cl); 2471 2472 if (ddi_getprop(dev, CMLB_DEVINFO(cl), DDI_PROP_DONTPASS, 2473 "lba-access-ok", 0) == 0) { 2474 /* not found; create it */ 2475 if (ddi_prop_create(dev, CMLB_DEVINFO(cl), 0, 2476 "lba-access-ok", (caddr_t)NULL, 0) != 2477 DDI_PROP_SUCCESS) { 2478 cmlb_dbg(CMLB_ERROR, cl, 2479 "cmlb_read_fdisk: Can't create lba " 2480 "property for instance %d\n", 2481 ddi_get_instance(CMLB_DEVINFO(cl))); 2482 } 2483 } 2484 } 2485 2486 bcopy(&mbp->signature, sigbuf, sizeof (sigbuf)); 2487 2488 /* 2489 * Endian-independent signature check 2490 */ 2491 if (((sigbuf[1] & 0xFF) != ((MBB_MAGIC >> 8) & 0xFF)) || 2492 (sigbuf[0] != (MBB_MAGIC & 0xFF))) { 2493 cmlb_dbg(CMLB_ERROR, cl, 2494 "cmlb_read_fdisk: no fdisk\n"); 2495 bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART); 2496 goto done; 2497 } 2498 2499 #ifdef CMLBDEBUG 2500 if (cmlb_level_mask & CMLB_LOGMASK_INFO) { 2501 fdp = fdisk; 2502 cmlb_dbg(CMLB_INFO, cl, "cmlb_read_fdisk:\n"); 2503 cmlb_dbg(CMLB_INFO, cl, " relsect " 2504 "numsect sysid bootid\n"); 2505 for (i = 0; i < FD_NUMPART; i++, fdp++) { 2506 cmlb_dbg(CMLB_INFO, cl, 2507 " %d: %8d %8d 0x%08x 0x%08x\n", 2508 i, fdp->relsect, fdp->numsect, 2509 fdp->systid, fdp->bootid); 2510 } 2511 } 2512 #endif 2513 2514 /* 2515 * Try to find the unix partition 2516 */ 2517 uidx = -1; 2518 solaris_offset = 0; 2519 solaris_size = 0; 2520 2521 for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) { 2522 uint32_t relsect; 2523 uint32_t numsect; 2524 uchar_t systid; 2525 #if defined(__i386) || defined(__amd64) 2526 /* 2527 * Stores relative block offset from the beginning of the 2528 * Extended Partition. 2529 */ 2530 int ext_relsect = 0; 2531 #endif 2532 2533 if (fdp->numsect == 0) { 2534 cl->cl_fmap[i].fmap_start = 0; 2535 cl->cl_fmap[i].fmap_nblk = 0; 2536 continue; 2537 } 2538 2539 /* 2540 * Data in the fdisk table is little-endian. 2541 */ 2542 relsect = LE_32(fdp->relsect); 2543 numsect = LE_32(fdp->numsect); 2544 2545 cl->cl_fmap[i].fmap_start = relsect; 2546 cl->cl_fmap[i].fmap_nblk = numsect; 2547 cl->cl_fmap[i].fmap_systid = LE_8(fdp->systid); 2548 2549 #if defined(__i386) || defined(__amd64) 2550 /* Support only one extended partition per LUN */ 2551 if ((fdp->systid == EXTDOS || fdp->systid == FDISK_EXTLBA) && 2552 (ext_part_exists == 0)) { 2553 int j; 2554 uint32_t logdrive_offset; 2555 uint32_t ext_numsect; 2556 uint32_t abs_secnum; 2557 2558 ext_part_exists = 1; 2559 2560 for (j = FD_NUMPART; j < FDISK_PARTS; j++) { 2561 mutex_exit(CMLB_MUTEX(cl)); 2562 rval = DK_TG_READ(cl, bufp, 2563 (relsect + ext_relsect), blocksize, 2564 tg_cookie); 2565 mutex_enter(CMLB_MUTEX(cl)); 2566 2567 if (rval != 0) { 2568 cmlb_dbg(CMLB_ERROR, cl, 2569 "cmlb_read_fdisk: Extended " 2570 "partition read err\n"); 2571 goto done; 2572 } 2573 /* 2574 * The first ipart entry provides the offset 2575 * at which the logical drive starts off from 2576 * the beginning of the container partition 2577 * and the size of the logical drive. 2578 * The second ipart entry provides the offset 2579 * of the next container partition from the 2580 * beginning of the extended partition. 2581 */ 2582 bcopy(&bufp[FDISK_PART_TABLE_START], eparts, 2583 sizeof (eparts)); 2584 logdrive_offset = LE_32(efdp1->relsect); 2585 ext_numsect = LE_32(efdp1->numsect); 2586 systid = LE_8(efdp1->systid); 2587 if (logdrive_offset <= 0 || ext_numsect <= 0) 2588 break; 2589 abs_secnum = relsect + ext_relsect + 2590 logdrive_offset; 2591 2592 /* Boundary condition and overlap checking */ 2593 if (cmlb_validate_ext_part(cl, i, j, abs_secnum, 2594 ext_numsect)) { 2595 break; 2596 } 2597 2598 if ((cl->cl_fmap[j].fmap_start != abs_secnum) || 2599 (cl->cl_fmap[j].fmap_nblk != ext_numsect) || 2600 (cl->cl_fmap[j].fmap_systid != systid)) { 2601 /* 2602 * Indicates change from previous 2603 * partinfo. Need to recreate 2604 * logical device nodes. 2605 */ 2606 cl->cl_update_ext_minor_nodes = 1; 2607 } 2608 cl->cl_fmap[j].fmap_start = abs_secnum; 2609 cl->cl_fmap[j].fmap_nblk = ext_numsect; 2610 cl->cl_fmap[j].fmap_systid = systid; 2611 ld_count++; 2612 2613 if ((efdp1->systid == SUNIXOS && 2614 (cmlb_is_linux_swap(cl, abs_secnum, 2615 tg_cookie) != 0)) || 2616 efdp1->systid == SUNIXOS2) { 2617 if (uidx == -1) { 2618 uidx = 0; 2619 solaris_offset = abs_secnum; 2620 solaris_size = ext_numsect; 2621 } 2622 } 2623 2624 if ((ext_relsect = LE_32(efdp2->relsect)) == 0) 2625 break; 2626 } 2627 } 2628 2629 #endif 2630 2631 if (fdp->systid != SUNIXOS && 2632 fdp->systid != SUNIXOS2 && 2633 fdp->systid != EFI_PMBR) { 2634 continue; 2635 } 2636 2637 /* 2638 * use the last active solaris partition id found 2639 * (there should only be 1 active partition id) 2640 * 2641 * if there are no active solaris partition id 2642 * then use the first inactive solaris partition id 2643 */ 2644 if ((uidx == -1) || (fdp->bootid == ACTIVE)) { 2645 #if defined(__i386) || defined(__amd64) 2646 if (fdp->systid != SUNIXOS || 2647 (fdp->systid == SUNIXOS && 2648 (cmlb_is_linux_swap(cl, relsect, 2649 tg_cookie) != 0))) { 2650 #endif 2651 uidx = i; 2652 solaris_offset = relsect; 2653 solaris_size = numsect; 2654 #if defined(__i386) || defined(__amd64) 2655 } 2656 #endif 2657 } 2658 } 2659 #if defined(__i386) || defined(__amd64) 2660 if (ld_count < cl->cl_logical_drive_count) { 2661 /* 2662 * Some/all logical drives were deleted. Clear out 2663 * the fmap entries correspoding to those deleted drives. 2664 */ 2665 for (k = ld_count + FD_NUMPART; 2666 k < cl->cl_logical_drive_count + FD_NUMPART; k++) { 2667 cl->cl_fmap[k].fmap_start = 0; 2668 cl->cl_fmap[k].fmap_nblk = 0; 2669 cl->cl_fmap[k].fmap_systid = 0; 2670 } 2671 cl->cl_update_ext_minor_nodes = 1; 2672 } 2673 if (cl->cl_update_ext_minor_nodes) { 2674 rval = cmlb_update_ext_minor_nodes(cl, ld_count); 2675 if (rval != 0) { 2676 goto done; 2677 } 2678 } 2679 #endif 2680 cmlb_dbg(CMLB_INFO, cl, "fdisk 0x%x 0x%lx", 2681 cl->cl_solaris_offset, cl->cl_solaris_size); 2682 done: 2683 2684 /* 2685 * Clear the VTOC info, only if the Solaris partition entry 2686 * has moved, changed size, been deleted, or if the size of 2687 * the partition is too small to even fit the label sector. 2688 */ 2689 if ((cl->cl_solaris_offset != solaris_offset) || 2690 (cl->cl_solaris_size != solaris_size) || 2691 solaris_size <= DK_LABEL_LOC) { 2692 cmlb_dbg(CMLB_INFO, cl, "fdisk moved 0x%x 0x%lx", 2693 solaris_offset, solaris_size); 2694 bzero(&cl->cl_g, sizeof (struct dk_geom)); 2695 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc)); 2696 bzero(&cl->cl_map, NDKMAP * (sizeof (struct dk_map))); 2697 cl->cl_f_geometry_is_valid = B_FALSE; 2698 } 2699 cl->cl_solaris_offset = solaris_offset; 2700 cl->cl_solaris_size = solaris_size; 2701 kmem_free(bufp, blocksize); 2702 return (rval); 2703 2704 #else /* #elif defined(_FIRMWARE_NEEDS_FDISK) */ 2705 #error "fdisk table presence undetermined for this platform." 2706 #endif /* #if defined(_NO_FDISK_PRESENT) */ 2707 } 2708 2709 static void 2710 cmlb_swap_efi_gpt(efi_gpt_t *e) 2711 { 2712 _NOTE(ASSUMING_PROTECTED(*e)) 2713 e->efi_gpt_Signature = LE_64(e->efi_gpt_Signature); 2714 e->efi_gpt_Revision = LE_32(e->efi_gpt_Revision); 2715 e->efi_gpt_HeaderSize = LE_32(e->efi_gpt_HeaderSize); 2716 e->efi_gpt_HeaderCRC32 = LE_32(e->efi_gpt_HeaderCRC32); 2717 e->efi_gpt_MyLBA = LE_64(e->efi_gpt_MyLBA); 2718 e->efi_gpt_AlternateLBA = LE_64(e->efi_gpt_AlternateLBA); 2719 e->efi_gpt_FirstUsableLBA = LE_64(e->efi_gpt_FirstUsableLBA); 2720 e->efi_gpt_LastUsableLBA = LE_64(e->efi_gpt_LastUsableLBA); 2721 UUID_LE_CONVERT(e->efi_gpt_DiskGUID, e->efi_gpt_DiskGUID); 2722 e->efi_gpt_PartitionEntryLBA = LE_64(e->efi_gpt_PartitionEntryLBA); 2723 e->efi_gpt_NumberOfPartitionEntries = 2724 LE_32(e->efi_gpt_NumberOfPartitionEntries); 2725 e->efi_gpt_SizeOfPartitionEntry = 2726 LE_32(e->efi_gpt_SizeOfPartitionEntry); 2727 e->efi_gpt_PartitionEntryArrayCRC32 = 2728 LE_32(e->efi_gpt_PartitionEntryArrayCRC32); 2729 } 2730 2731 static void 2732 cmlb_swap_efi_gpe(int nparts, efi_gpe_t *p) 2733 { 2734 int i; 2735 2736 _NOTE(ASSUMING_PROTECTED(*p)) 2737 for (i = 0; i < nparts; i++) { 2738 UUID_LE_CONVERT(p[i].efi_gpe_PartitionTypeGUID, 2739 p[i].efi_gpe_PartitionTypeGUID); 2740 p[i].efi_gpe_StartingLBA = LE_64(p[i].efi_gpe_StartingLBA); 2741 p[i].efi_gpe_EndingLBA = LE_64(p[i].efi_gpe_EndingLBA); 2742 /* PartitionAttrs */ 2743 } 2744 } 2745 2746 static int 2747 cmlb_validate_efi(efi_gpt_t *labp) 2748 { 2749 if (labp->efi_gpt_Signature != EFI_SIGNATURE) 2750 return (EINVAL); 2751 /* at least 92 bytes in this version of the spec. */ 2752 if (sizeof (efi_gpt_t) - sizeof (labp->efi_gpt_Reserved2) > 2753 labp->efi_gpt_HeaderSize) 2754 return (EINVAL); 2755 /* this should be 128 bytes */ 2756 if (labp->efi_gpt_SizeOfPartitionEntry != sizeof (efi_gpe_t)) 2757 return (EINVAL); 2758 return (0); 2759 } 2760 2761 /* 2762 * This function returns B_FALSE if there is a valid MBR signature and no 2763 * partition table entries of type EFI_PMBR (0xEE). Otherwise it returns B_TRUE. 2764 * 2765 * The EFI spec (1.10 and later) requires having a Protective MBR (PMBR) to 2766 * recognize the disk as GPT partitioned. However, some other OS creates an MBR 2767 * where a PMBR entry is not the only one. Also, if the first block has been 2768 * corrupted, currently best attempt to allow data access would be to try to 2769 * check for GPT headers. Hence in case of more than one partition entry, but 2770 * at least one EFI_PMBR partition type or no valid magic number, the function 2771 * returns B_TRUE to continue with looking for GPT header. 2772 */ 2773 2774 static boolean_t 2775 cmlb_check_efi_mbr(uchar_t *buf, boolean_t *is_mbr) 2776 { 2777 struct ipart *fdp; 2778 struct mboot *mbp = (struct mboot *)buf; 2779 struct ipart fdisk[FD_NUMPART]; 2780 int i; 2781 2782 if (is_mbr != NULL) 2783 *is_mbr = B_TRUE; 2784 2785 if (LE_16(mbp->signature) != MBB_MAGIC) { 2786 if (is_mbr != NULL) 2787 *is_mbr = B_FALSE; 2788 return (B_TRUE); 2789 } 2790 2791 bcopy(&mbp->parts[0], fdisk, sizeof (fdisk)); 2792 2793 for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) { 2794 if (fdp->systid == EFI_PMBR) 2795 return (B_TRUE); 2796 } 2797 2798 return (B_FALSE); 2799 } 2800 2801 static int 2802 cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags, 2803 void *tg_cookie) 2804 { 2805 int i; 2806 int rval = 0; 2807 efi_gpe_t *partitions; 2808 uchar_t *buf; 2809 uint_t lbasize; /* is really how much to read */ 2810 diskaddr_t cap = 0; 2811 uint_t nparts; 2812 diskaddr_t gpe_lba; 2813 diskaddr_t alternate_lba; 2814 int iofailed = 0; 2815 struct uuid uuid_type_reserved = EFI_RESERVED; 2816 #if defined(_FIRMWARE_NEEDS_FDISK) 2817 boolean_t is_mbr; 2818 #endif 2819 2820 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 2821 2822 lbasize = cl->cl_sys_blocksize; 2823 2824 cl->cl_reserved = -1; 2825 mutex_exit(CMLB_MUTEX(cl)); 2826 2827 buf = kmem_zalloc(EFI_MIN_ARRAY_SIZE, KM_SLEEP); 2828 2829 rval = DK_TG_READ(cl, buf, 0, lbasize, tg_cookie); 2830 if (rval) { 2831 iofailed = 1; 2832 goto done_err; 2833 } 2834 if (((struct dk_label *)buf)->dkl_magic == DKL_MAGIC) { 2835 /* not ours */ 2836 rval = ESRCH; 2837 goto done_err; 2838 } 2839 2840 #if defined(_FIRMWARE_NEEDS_FDISK) 2841 if (!cmlb_check_efi_mbr(buf, &is_mbr)) { 2842 if (is_mbr) 2843 rval = ESRCH; 2844 else 2845 rval = EINVAL; 2846 goto done_err; 2847 } 2848 #else 2849 if (!cmlb_check_efi_mbr(buf, NULL)) { 2850 rval = EINVAL; 2851 goto done_err; 2852 } 2853 2854 #endif 2855 2856 rval = DK_TG_READ(cl, buf, 1, lbasize, tg_cookie); 2857 if (rval) { 2858 iofailed = 1; 2859 goto done_err; 2860 } 2861 cmlb_swap_efi_gpt((efi_gpt_t *)buf); 2862 2863 if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0) { 2864 /* 2865 * Couldn't read the primary, try the backup. Our 2866 * capacity at this point could be based on CHS, so 2867 * check what the device reports. 2868 */ 2869 rval = DK_TG_GETCAP(cl, &cap, tg_cookie); 2870 if (rval) { 2871 iofailed = 1; 2872 goto done_err; 2873 } 2874 2875 /* 2876 * CMLB_OFF_BY_ONE case, we check the next to last block first 2877 * for backup GPT header, otherwise check the last block. 2878 */ 2879 2880 if ((rval = DK_TG_READ(cl, buf, 2881 cap - ((cl->cl_alter_behavior & CMLB_OFF_BY_ONE) ? 2 : 1), 2882 lbasize, tg_cookie)) 2883 != 0) { 2884 iofailed = 1; 2885 goto done_err; 2886 } 2887 cmlb_swap_efi_gpt((efi_gpt_t *)buf); 2888 2889 if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0) { 2890 2891 if (!(cl->cl_alter_behavior & CMLB_OFF_BY_ONE)) 2892 goto done_err; 2893 if ((rval = DK_TG_READ(cl, buf, cap - 1, lbasize, 2894 tg_cookie)) != 0) 2895 goto done_err; 2896 cmlb_swap_efi_gpt((efi_gpt_t *)buf); 2897 if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0) 2898 goto done_err; 2899 } 2900 if (!(flags & CMLB_SILENT)) 2901 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN, 2902 "primary label corrupt; using backup\n"); 2903 } 2904 2905 nparts = ((efi_gpt_t *)buf)->efi_gpt_NumberOfPartitionEntries; 2906 gpe_lba = ((efi_gpt_t *)buf)->efi_gpt_PartitionEntryLBA; 2907 alternate_lba = ((efi_gpt_t *)buf)->efi_gpt_AlternateLBA; 2908 2909 rval = DK_TG_READ(cl, buf, gpe_lba, EFI_MIN_ARRAY_SIZE, tg_cookie); 2910 if (rval) { 2911 iofailed = 1; 2912 goto done_err; 2913 } 2914 partitions = (efi_gpe_t *)buf; 2915 2916 if (nparts > MAXPART) { 2917 nparts = MAXPART; 2918 } 2919 cmlb_swap_efi_gpe(nparts, partitions); 2920 2921 mutex_enter(CMLB_MUTEX(cl)); 2922 2923 /* Fill in partition table. */ 2924 for (i = 0; i < nparts; i++) { 2925 if (partitions->efi_gpe_StartingLBA != 0 || 2926 partitions->efi_gpe_EndingLBA != 0) { 2927 cl->cl_map[i].dkl_cylno = 2928 partitions->efi_gpe_StartingLBA; 2929 cl->cl_map[i].dkl_nblk = 2930 partitions->efi_gpe_EndingLBA - 2931 partitions->efi_gpe_StartingLBA + 1; 2932 cl->cl_offset[i] = 2933 partitions->efi_gpe_StartingLBA; 2934 } 2935 2936 if (cl->cl_reserved == -1) { 2937 if (bcmp(&partitions->efi_gpe_PartitionTypeGUID, 2938 &uuid_type_reserved, sizeof (struct uuid)) == 0) { 2939 cl->cl_reserved = i; 2940 } 2941 } 2942 if (i == WD_NODE) { 2943 /* 2944 * minor number 7 corresponds to the whole disk 2945 * if the disk capacity is expanded after disk is 2946 * labeled, minor number 7 represents the capacity 2947 * indicated by the disk label. 2948 */ 2949 cl->cl_map[i].dkl_cylno = 0; 2950 if (alternate_lba == 1) { 2951 /* 2952 * We are using backup label. Since we can 2953 * find a valid label at the end of disk, 2954 * the disk capacity is not expanded. 2955 */ 2956 cl->cl_map[i].dkl_nblk = capacity; 2957 } else { 2958 cl->cl_map[i].dkl_nblk = alternate_lba + 1; 2959 } 2960 cl->cl_offset[i] = 0; 2961 } 2962 partitions++; 2963 } 2964 cl->cl_solaris_offset = 0; 2965 cl->cl_solaris_size = capacity; 2966 cl->cl_label_from_media = CMLB_LABEL_EFI; 2967 cl->cl_f_geometry_is_valid = B_TRUE; 2968 2969 /* clear the vtoc label */ 2970 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc)); 2971 2972 kmem_free(buf, EFI_MIN_ARRAY_SIZE); 2973 return (0); 2974 2975 done_err: 2976 kmem_free(buf, EFI_MIN_ARRAY_SIZE); 2977 mutex_enter(CMLB_MUTEX(cl)); 2978 done_err1: 2979 /* 2980 * if we didn't find something that could look like a VTOC 2981 * and the disk is over 1TB, we know there isn't a valid label. 2982 * Otherwise let cmlb_uselabel decide what to do. We only 2983 * want to invalidate this if we're certain the label isn't 2984 * valid because cmlb_prop_op will now fail, which in turn 2985 * causes things like opens and stats on the partition to fail. 2986 */ 2987 if ((capacity > CMLB_EXTVTOC_LIMIT) && (rval != ESRCH) && !iofailed) { 2988 cl->cl_f_geometry_is_valid = B_FALSE; 2989 } 2990 return (rval); 2991 } 2992 2993 2994 /* 2995 * Function: cmlb_uselabel 2996 * 2997 * Description: Validate the disk label and update the relevant data (geometry, 2998 * partition, vtoc, and capacity data) in the cmlb_lun struct. 2999 * Marks the geometry of the unit as being valid. 3000 * 3001 * Arguments: cl: unit struct. 3002 * dk_label: disk label 3003 * 3004 * Return Code: CMLB_LABEL_IS_VALID: Label read from disk is OK; geometry, 3005 * partition, vtoc, and capacity data are good. 3006 * 3007 * CMLB_LABEL_IS_INVALID: Magic number or checksum error in the 3008 * label; or computed capacity does not jibe with capacity 3009 * reported from the READ CAPACITY command. 3010 * 3011 * Context: Kernel thread only (can sleep). 3012 */ 3013 static int 3014 cmlb_uselabel(struct cmlb_lun *cl, struct dk_label *labp, int flags) 3015 { 3016 short *sp; 3017 short sum; 3018 short count; 3019 int label_error = CMLB_LABEL_IS_VALID; 3020 int i; 3021 diskaddr_t label_capacity; 3022 uint32_t part_end; 3023 diskaddr_t track_capacity; 3024 #if defined(_SUNOS_VTOC_16) 3025 struct dkl_partition *vpartp; 3026 #endif 3027 ASSERT(cl != NULL); 3028 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 3029 3030 /* Validate the magic number of the label. */ 3031 if (labp->dkl_magic != DKL_MAGIC) { 3032 #if defined(__sparc) 3033 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) { 3034 if (!(flags & CMLB_SILENT)) 3035 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), 3036 CE_WARN, 3037 "Corrupt label; wrong magic number\n"); 3038 } 3039 #endif 3040 return (CMLB_LABEL_IS_INVALID); 3041 } 3042 3043 /* Validate the checksum of the label. */ 3044 sp = (short *)labp; 3045 sum = 0; 3046 count = sizeof (struct dk_label) / sizeof (short); 3047 while (count--) { 3048 sum ^= *sp++; 3049 } 3050 3051 if (sum != 0) { 3052 #if defined(_SUNOS_VTOC_16) 3053 if (!ISCD(cl)) { 3054 #elif defined(_SUNOS_VTOC_8) 3055 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) { 3056 #endif 3057 if (!(flags & CMLB_SILENT)) 3058 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), 3059 CE_WARN, 3060 "Corrupt label - label checksum failed\n"); 3061 } 3062 return (CMLB_LABEL_IS_INVALID); 3063 } 3064 3065 3066 /* 3067 * Fill in geometry structure with data from label. 3068 */ 3069 bzero(&cl->cl_g, sizeof (struct dk_geom)); 3070 cl->cl_g.dkg_ncyl = labp->dkl_ncyl; 3071 cl->cl_g.dkg_acyl = labp->dkl_acyl; 3072 cl->cl_g.dkg_bcyl = 0; 3073 cl->cl_g.dkg_nhead = labp->dkl_nhead; 3074 cl->cl_g.dkg_nsect = labp->dkl_nsect; 3075 cl->cl_g.dkg_intrlv = labp->dkl_intrlv; 3076 3077 #if defined(_SUNOS_VTOC_8) 3078 cl->cl_g.dkg_gap1 = labp->dkl_gap1; 3079 cl->cl_g.dkg_gap2 = labp->dkl_gap2; 3080 cl->cl_g.dkg_bhead = labp->dkl_bhead; 3081 #endif 3082 #if defined(_SUNOS_VTOC_16) 3083 cl->cl_dkg_skew = labp->dkl_skew; 3084 #endif 3085 3086 #if defined(__i386) || defined(__amd64) 3087 cl->cl_g.dkg_apc = labp->dkl_apc; 3088 #endif 3089 3090 /* 3091 * Currently we rely on the values in the label being accurate. If 3092 * dkl_rpm or dkl_pcly are zero in the label, use a default value. 3093 * 3094 * Note: In the future a MODE SENSE may be used to retrieve this data, 3095 * although this command is optional in SCSI-2. 3096 */ 3097 cl->cl_g.dkg_rpm = (labp->dkl_rpm != 0) ? labp->dkl_rpm : 3600; 3098 cl->cl_g.dkg_pcyl = (labp->dkl_pcyl != 0) ? labp->dkl_pcyl : 3099 (cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl); 3100 3101 /* 3102 * The Read and Write reinstruct values may not be valid 3103 * for older disks. 3104 */ 3105 cl->cl_g.dkg_read_reinstruct = labp->dkl_read_reinstruct; 3106 cl->cl_g.dkg_write_reinstruct = labp->dkl_write_reinstruct; 3107 3108 /* Fill in partition table. */ 3109 #if defined(_SUNOS_VTOC_8) 3110 for (i = 0; i < NDKMAP; i++) { 3111 cl->cl_map[i].dkl_cylno = labp->dkl_map[i].dkl_cylno; 3112 cl->cl_map[i].dkl_nblk = labp->dkl_map[i].dkl_nblk; 3113 } 3114 #endif 3115 #if defined(_SUNOS_VTOC_16) 3116 vpartp = labp->dkl_vtoc.v_part; 3117 track_capacity = labp->dkl_nhead * labp->dkl_nsect; 3118 3119 /* Prevent divide by zero */ 3120 if (track_capacity == 0) { 3121 if (!(flags & CMLB_SILENT)) 3122 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN, 3123 "Corrupt label - zero nhead or nsect value\n"); 3124 3125 return (CMLB_LABEL_IS_INVALID); 3126 } 3127 3128 for (i = 0; i < NDKMAP; i++, vpartp++) { 3129 cl->cl_map[i].dkl_cylno = vpartp->p_start / track_capacity; 3130 cl->cl_map[i].dkl_nblk = vpartp->p_size; 3131 } 3132 #endif 3133 3134 /* Fill in VTOC Structure. */ 3135 bcopy(&labp->dkl_vtoc, &cl->cl_vtoc, sizeof (struct dk_vtoc)); 3136 #if defined(_SUNOS_VTOC_8) 3137 /* 3138 * The 8-slice vtoc does not include the ascii label; save it into 3139 * the device's soft state structure here. 3140 */ 3141 bcopy(labp->dkl_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII); 3142 #endif 3143 3144 /* Now look for a valid capacity. */ 3145 track_capacity = (cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect); 3146 label_capacity = (cl->cl_g.dkg_ncyl * track_capacity); 3147 3148 if (cl->cl_g.dkg_acyl) { 3149 #if defined(__i386) || defined(__amd64) 3150 /* we may have > 1 alts cylinder */ 3151 label_capacity += (track_capacity * cl->cl_g.dkg_acyl); 3152 #else 3153 label_capacity += track_capacity; 3154 #endif 3155 } 3156 3157 /* 3158 * Force check here to ensure the computed capacity is valid. 3159 * If capacity is zero, it indicates an invalid label and 3160 * we should abort updating the relevant data then. 3161 */ 3162 if (label_capacity == 0) { 3163 if (!(flags & CMLB_SILENT)) 3164 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN, 3165 "Corrupt label - no valid capacity could be " 3166 "retrieved\n"); 3167 3168 return (CMLB_LABEL_IS_INVALID); 3169 } 3170 3171 /* Mark the geometry as valid. */ 3172 cl->cl_f_geometry_is_valid = B_TRUE; 3173 3174 /* 3175 * if we got invalidated when mutex exit and entered again, 3176 * if blockcount different than when we came in, need to 3177 * retry from beginning of cmlb_validate_geometry. 3178 * revisit this on next phase of utilizing this for 3179 * sd. 3180 */ 3181 3182 if (label_capacity <= cl->cl_blockcount) { 3183 #if defined(_SUNOS_VTOC_8) 3184 /* 3185 * We can't let this happen on drives that are subdivided 3186 * into logical disks (i.e., that have an fdisk table). 3187 * The cl_blockcount field should always hold the full media 3188 * size in sectors, period. This code would overwrite 3189 * cl_blockcount with the size of the Solaris fdisk partition. 3190 */ 3191 cmlb_dbg(CMLB_ERROR, cl, 3192 "cmlb_uselabel: Label %d blocks; Drive %d blocks\n", 3193 label_capacity, cl->cl_blockcount); 3194 cl->cl_solaris_size = label_capacity; 3195 3196 #endif /* defined(_SUNOS_VTOC_8) */ 3197 goto done; 3198 } 3199 3200 if (ISCD(cl)) { 3201 /* For CDROMs, we trust that the data in the label is OK. */ 3202 #if defined(_SUNOS_VTOC_8) 3203 for (i = 0; i < NDKMAP; i++) { 3204 part_end = labp->dkl_nhead * labp->dkl_nsect * 3205 labp->dkl_map[i].dkl_cylno + 3206 labp->dkl_map[i].dkl_nblk - 1; 3207 3208 if ((labp->dkl_map[i].dkl_nblk) && 3209 (part_end > cl->cl_blockcount)) { 3210 cl->cl_f_geometry_is_valid = B_FALSE; 3211 break; 3212 } 3213 } 3214 #endif 3215 #if defined(_SUNOS_VTOC_16) 3216 vpartp = &(labp->dkl_vtoc.v_part[0]); 3217 for (i = 0; i < NDKMAP; i++, vpartp++) { 3218 part_end = vpartp->p_start + vpartp->p_size; 3219 if ((vpartp->p_size > 0) && 3220 (part_end > cl->cl_blockcount)) { 3221 cl->cl_f_geometry_is_valid = B_FALSE; 3222 break; 3223 } 3224 } 3225 #endif 3226 } else { 3227 /* label_capacity > cl->cl_blockcount */ 3228 if (!(flags & CMLB_SILENT)) { 3229 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN, 3230 "Corrupt label - bad geometry\n"); 3231 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_CONT, 3232 "Label says %llu blocks; Drive says %llu blocks\n", 3233 label_capacity, cl->cl_blockcount); 3234 } 3235 cl->cl_f_geometry_is_valid = B_FALSE; 3236 label_error = CMLB_LABEL_IS_INVALID; 3237 } 3238 3239 done: 3240 3241 cmlb_dbg(CMLB_INFO, cl, "cmlb_uselabel: (label geometry)\n"); 3242 cmlb_dbg(CMLB_INFO, cl, 3243 " ncyl: %d; acyl: %d; nhead: %d; nsect: %d\n", 3244 cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl, 3245 cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect); 3246 3247 cmlb_dbg(CMLB_INFO, cl, 3248 " label_capacity: %d; intrlv: %d; rpm: %d\n", 3249 cl->cl_blockcount, cl->cl_g.dkg_intrlv, cl->cl_g.dkg_rpm); 3250 cmlb_dbg(CMLB_INFO, cl, " wrt_reinstr: %d; rd_reinstr: %d\n", 3251 cl->cl_g.dkg_write_reinstruct, cl->cl_g.dkg_read_reinstruct); 3252 3253 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 3254 3255 return (label_error); 3256 } 3257 3258 3259 /* 3260 * Function: cmlb_build_default_label 3261 * 3262 * Description: Generate a default label for those devices that do not have 3263 * one, e.g., new media, removable cartridges, etc.. 3264 * 3265 * Context: Kernel thread only 3266 */ 3267 /*ARGSUSED*/ 3268 static void 3269 cmlb_build_default_label(struct cmlb_lun *cl, void *tg_cookie) 3270 { 3271 #if defined(_SUNOS_VTOC_16) 3272 uint_t phys_spc; 3273 uint_t disksize; 3274 struct dk_geom cl_g; 3275 diskaddr_t capacity; 3276 #endif 3277 3278 ASSERT(cl != NULL); 3279 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 3280 3281 #if defined(_SUNOS_VTOC_8) 3282 /* 3283 * Note: This is a legacy check for non-removable devices on VTOC_8 3284 * only. This may be a valid check for VTOC_16 as well. 3285 * Once we understand why there is this difference between SPARC and 3286 * x86 platform, we could remove this legacy check. 3287 */ 3288 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) { 3289 return; 3290 } 3291 #endif 3292 3293 bzero(&cl->cl_g, sizeof (struct dk_geom)); 3294 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc)); 3295 bzero(&cl->cl_map, NDKMAP * (sizeof (struct dk_map))); 3296 3297 #if defined(_SUNOS_VTOC_8) 3298 3299 /* 3300 * It's a REMOVABLE media, therefore no label (on sparc, anyway). 3301 * But it is still necessary to set up various geometry information, 3302 * and we are doing this here. 3303 */ 3304 3305 /* 3306 * For the rpm, we use the minimum for the disk. For the head, cyl, 3307 * and number of sector per track, if the capacity <= 1GB, head = 64, 3308 * sect = 32. else head = 255, sect 63 Note: the capacity should be 3309 * equal to C*H*S values. This will cause some truncation of size due 3310 * to round off errors. For CD-ROMs, this truncation can have adverse 3311 * side effects, so returning ncyl and nhead as 1. The nsect will 3312 * overflow for most of CD-ROMs as nsect is of type ushort. (4190569) 3313 */ 3314 cl->cl_solaris_size = cl->cl_blockcount; 3315 if (ISCD(cl)) { 3316 tg_attribute_t tgattribute; 3317 int is_writable; 3318 /* 3319 * Preserve the old behavior for non-writable 3320 * medias. Since dkg_nsect is a ushort, it 3321 * will lose bits as cdroms have more than 3322 * 65536 sectors. So if we recalculate 3323 * capacity, it will become much shorter. 3324 * But the dkg_* information is not 3325 * used for CDROMs so it is OK. But for 3326 * Writable CDs we need this information 3327 * to be valid (for newfs say). So we 3328 * make nsect and nhead > 1 that way 3329 * nsect can still stay within ushort limit 3330 * without losing any bits. 3331 */ 3332 3333 bzero(&tgattribute, sizeof (tg_attribute_t)); 3334 3335 mutex_exit(CMLB_MUTEX(cl)); 3336 is_writable = 3337 (DK_TG_GETATTRIBUTE(cl, &tgattribute, tg_cookie) == 0) ? 3338 tgattribute.media_is_writable : 1; 3339 mutex_enter(CMLB_MUTEX(cl)); 3340 3341 if (is_writable) { 3342 cl->cl_g.dkg_nhead = 64; 3343 cl->cl_g.dkg_nsect = 32; 3344 cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32); 3345 cl->cl_solaris_size = (diskaddr_t)cl->cl_g.dkg_ncyl * 3346 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect; 3347 } else { 3348 cl->cl_g.dkg_ncyl = 1; 3349 cl->cl_g.dkg_nhead = 1; 3350 cl->cl_g.dkg_nsect = cl->cl_blockcount; 3351 } 3352 } else { 3353 if (cl->cl_blockcount < 160) { 3354 /* Less than 80K */ 3355 cl->cl_g.dkg_nhead = 1; 3356 cl->cl_g.dkg_ncyl = cl->cl_blockcount; 3357 cl->cl_g.dkg_nsect = 1; 3358 } else if (cl->cl_blockcount <= 0x1000) { 3359 /* unlabeled SCSI floppy device */ 3360 cl->cl_g.dkg_nhead = 2; 3361 cl->cl_g.dkg_ncyl = 80; 3362 cl->cl_g.dkg_nsect = cl->cl_blockcount / (2 * 80); 3363 } else if (cl->cl_blockcount <= 0x200000) { 3364 cl->cl_g.dkg_nhead = 64; 3365 cl->cl_g.dkg_nsect = 32; 3366 cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32); 3367 } else { 3368 cl->cl_g.dkg_nhead = 255; 3369 3370 cl->cl_g.dkg_nsect = ((cl->cl_blockcount + 3371 (UINT16_MAX * 255 * 63) - 1) / 3372 (UINT16_MAX * 255 * 63)) * 63; 3373 3374 if (cl->cl_g.dkg_nsect == 0) 3375 cl->cl_g.dkg_nsect = (UINT16_MAX / 63) * 63; 3376 3377 cl->cl_g.dkg_ncyl = cl->cl_blockcount / 3378 (255 * cl->cl_g.dkg_nsect); 3379 } 3380 3381 cl->cl_solaris_size = 3382 (diskaddr_t)cl->cl_g.dkg_ncyl * cl->cl_g.dkg_nhead * 3383 cl->cl_g.dkg_nsect; 3384 3385 } 3386 3387 cl->cl_g.dkg_acyl = 0; 3388 cl->cl_g.dkg_bcyl = 0; 3389 cl->cl_g.dkg_rpm = 200; 3390 cl->cl_asciilabel[0] = '\0'; 3391 cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl; 3392 3393 cl->cl_map[0].dkl_cylno = 0; 3394 cl->cl_map[0].dkl_nblk = cl->cl_solaris_size; 3395 3396 cl->cl_map[2].dkl_cylno = 0; 3397 cl->cl_map[2].dkl_nblk = cl->cl_solaris_size; 3398 3399 #elif defined(_SUNOS_VTOC_16) 3400 3401 if (cl->cl_solaris_size == 0) { 3402 /* 3403 * Got fdisk table but no solaris entry therefore 3404 * don't create a default label 3405 */ 3406 cl->cl_f_geometry_is_valid = B_TRUE; 3407 return; 3408 } 3409 3410 /* 3411 * For CDs we continue to use the physical geometry to calculate 3412 * number of cylinders. All other devices must convert the 3413 * physical geometry (cmlb_geom) to values that will fit 3414 * in a dk_geom structure. 3415 */ 3416 if (ISCD(cl)) { 3417 phys_spc = cl->cl_pgeom.g_nhead * cl->cl_pgeom.g_nsect; 3418 } else { 3419 /* Convert physical geometry to disk geometry */ 3420 bzero(&cl_g, sizeof (struct dk_geom)); 3421 3422 /* 3423 * Refer to comments related to off-by-1 at the 3424 * header of this file. 3425 * Before calculating geometry, capacity should be 3426 * decreased by 1. 3427 */ 3428 3429 if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE) 3430 capacity = cl->cl_blockcount - 1; 3431 else 3432 capacity = cl->cl_blockcount; 3433 3434 3435 cmlb_convert_geometry(cl, capacity, &cl_g, tg_cookie); 3436 bcopy(&cl_g, &cl->cl_g, sizeof (cl->cl_g)); 3437 phys_spc = cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect; 3438 } 3439 3440 if (phys_spc == 0) 3441 return; 3442 cl->cl_g.dkg_pcyl = cl->cl_solaris_size / phys_spc; 3443 if (cl->cl_alter_behavior & CMLB_FAKE_LABEL_ONE_PARTITION) { 3444 /* disable devid */ 3445 cl->cl_g.dkg_ncyl = cl->cl_g.dkg_pcyl; 3446 disksize = cl->cl_solaris_size; 3447 } else { 3448 cl->cl_g.dkg_acyl = DK_ACYL; 3449 cl->cl_g.dkg_ncyl = cl->cl_g.dkg_pcyl - DK_ACYL; 3450 disksize = cl->cl_g.dkg_ncyl * phys_spc; 3451 } 3452 3453 if (ISCD(cl)) { 3454 /* 3455 * CD's don't use the "heads * sectors * cyls"-type of 3456 * geometry, but instead use the entire capacity of the media. 3457 */ 3458 disksize = cl->cl_solaris_size; 3459 cl->cl_g.dkg_nhead = 1; 3460 cl->cl_g.dkg_nsect = 1; 3461 cl->cl_g.dkg_rpm = 3462 (cl->cl_pgeom.g_rpm == 0) ? 200 : cl->cl_pgeom.g_rpm; 3463 3464 cl->cl_vtoc.v_part[0].p_start = 0; 3465 cl->cl_vtoc.v_part[0].p_size = disksize; 3466 cl->cl_vtoc.v_part[0].p_tag = V_BACKUP; 3467 cl->cl_vtoc.v_part[0].p_flag = V_UNMNT; 3468 3469 cl->cl_map[0].dkl_cylno = 0; 3470 cl->cl_map[0].dkl_nblk = disksize; 3471 cl->cl_offset[0] = 0; 3472 3473 } else { 3474 /* 3475 * Hard disks and removable media cartridges 3476 */ 3477 cl->cl_g.dkg_rpm = 3478 (cl->cl_pgeom.g_rpm == 0) ? 3600: cl->cl_pgeom.g_rpm; 3479 cl->cl_vtoc.v_sectorsz = cl->cl_sys_blocksize; 3480 3481 /* Add boot slice */ 3482 cl->cl_vtoc.v_part[8].p_start = 0; 3483 cl->cl_vtoc.v_part[8].p_size = phys_spc; 3484 cl->cl_vtoc.v_part[8].p_tag = V_BOOT; 3485 cl->cl_vtoc.v_part[8].p_flag = V_UNMNT; 3486 3487 cl->cl_map[8].dkl_cylno = 0; 3488 cl->cl_map[8].dkl_nblk = phys_spc; 3489 cl->cl_offset[8] = 0; 3490 3491 if ((cl->cl_alter_behavior & 3492 CMLB_CREATE_ALTSLICE_VTOC_16_DTYPE_DIRECT) && 3493 cl->cl_device_type == DTYPE_DIRECT) { 3494 cl->cl_vtoc.v_part[9].p_start = phys_spc; 3495 cl->cl_vtoc.v_part[9].p_size = 2 * phys_spc; 3496 cl->cl_vtoc.v_part[9].p_tag = V_ALTSCTR; 3497 cl->cl_vtoc.v_part[9].p_flag = 0; 3498 3499 cl->cl_map[9].dkl_cylno = 1; 3500 cl->cl_map[9].dkl_nblk = 2 * phys_spc; 3501 cl->cl_offset[9] = phys_spc; 3502 } 3503 } 3504 3505 cl->cl_g.dkg_apc = 0; 3506 3507 /* Add backup slice */ 3508 cl->cl_vtoc.v_part[2].p_start = 0; 3509 cl->cl_vtoc.v_part[2].p_size = disksize; 3510 cl->cl_vtoc.v_part[2].p_tag = V_BACKUP; 3511 cl->cl_vtoc.v_part[2].p_flag = V_UNMNT; 3512 3513 cl->cl_map[2].dkl_cylno = 0; 3514 cl->cl_map[2].dkl_nblk = disksize; 3515 cl->cl_offset[2] = 0; 3516 3517 /* 3518 * single slice (s0) covering the entire disk 3519 */ 3520 if (cl->cl_alter_behavior & CMLB_FAKE_LABEL_ONE_PARTITION) { 3521 cl->cl_vtoc.v_part[0].p_start = 0; 3522 cl->cl_vtoc.v_part[0].p_tag = V_UNASSIGNED; 3523 cl->cl_vtoc.v_part[0].p_flag = 0; 3524 cl->cl_vtoc.v_part[0].p_size = disksize; 3525 cl->cl_map[0].dkl_cylno = 0; 3526 cl->cl_map[0].dkl_nblk = disksize; 3527 cl->cl_offset[0] = 0; 3528 } 3529 3530 (void) sprintf(cl->cl_vtoc.v_asciilabel, "DEFAULT cyl %d alt %d" 3531 " hd %d sec %d", cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl, 3532 cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect); 3533 3534 #else 3535 #error "No VTOC format defined." 3536 #endif 3537 3538 cl->cl_g.dkg_read_reinstruct = 0; 3539 cl->cl_g.dkg_write_reinstruct = 0; 3540 3541 cl->cl_g.dkg_intrlv = 1; 3542 3543 cl->cl_vtoc.v_sanity = VTOC_SANE; 3544 cl->cl_vtoc.v_nparts = V_NUMPAR; 3545 cl->cl_vtoc.v_version = V_VERSION; 3546 3547 cl->cl_f_geometry_is_valid = B_TRUE; 3548 cl->cl_label_from_media = CMLB_LABEL_UNDEF; 3549 3550 cmlb_dbg(CMLB_INFO, cl, 3551 "cmlb_build_default_label: Default label created: " 3552 "cyl: %d\tacyl: %d\tnhead: %d\tnsect: %d\tcap: %d\n", 3553 cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl, cl->cl_g.dkg_nhead, 3554 cl->cl_g.dkg_nsect, cl->cl_blockcount); 3555 } 3556 3557 3558 #if defined(_FIRMWARE_NEEDS_FDISK) 3559 /* 3560 * Max CHS values, as they are encoded into bytes, for 1022/254/63 3561 */ 3562 #define LBA_MAX_SECT (63 | ((1022 & 0x300) >> 2)) 3563 #define LBA_MAX_CYL (1022 & 0xFF) 3564 #define LBA_MAX_HEAD (254) 3565 3566 3567 /* 3568 * Function: cmlb_has_max_chs_vals 3569 * 3570 * Description: Return B_TRUE if Cylinder-Head-Sector values are all at maximum. 3571 * 3572 * Arguments: fdp - ptr to CHS info 3573 * 3574 * Return Code: True or false 3575 * 3576 * Context: Any. 3577 */ 3578 static boolean_t 3579 cmlb_has_max_chs_vals(struct ipart *fdp) 3580 { 3581 return ((fdp->begcyl == LBA_MAX_CYL) && 3582 (fdp->beghead == LBA_MAX_HEAD) && 3583 (fdp->begsect == LBA_MAX_SECT) && 3584 (fdp->endcyl == LBA_MAX_CYL) && 3585 (fdp->endhead == LBA_MAX_HEAD) && 3586 (fdp->endsect == LBA_MAX_SECT)); 3587 } 3588 #endif 3589 3590 /* 3591 * Function: cmlb_dkio_get_geometry 3592 * 3593 * Description: This routine is the driver entry point for handling user 3594 * requests to get the device geometry (DKIOCGGEOM). 3595 * 3596 * Arguments: 3597 * arg pointer to user provided dk_geom structure specifying 3598 * the controller's notion of the current geometry. 3599 * 3600 * flag this argument is a pass through to ddi_copyxxx() 3601 * directly from the mode argument of ioctl(). 3602 * 3603 * tg_cookie cookie from target driver to be passed back to target 3604 * driver when we call back to it through tg_ops. 3605 * 3606 * Return Code: 0 3607 * EFAULT 3608 * ENXIO 3609 * EIO 3610 */ 3611 static int 3612 cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag, 3613 void *tg_cookie) 3614 { 3615 struct dk_geom *tmp_geom = NULL; 3616 int rval = 0; 3617 3618 /* 3619 * cmlb_validate_geometry does not spin a disk up 3620 * if it was spcl down. We need to make sure it 3621 * is ready. 3622 */ 3623 mutex_enter(CMLB_MUTEX(cl)); 3624 rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie); 3625 #if defined(_SUNOS_VTOC_8) 3626 if (rval == EINVAL && 3627 cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) { 3628 /* 3629 * This is to return a default label geometry even when we 3630 * do not really assume a default label for the device. 3631 * dad driver utilizes this. 3632 */ 3633 if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) { 3634 cmlb_setup_default_geometry(cl, tg_cookie); 3635 rval = 0; 3636 } 3637 } 3638 #endif 3639 if (rval) { 3640 mutex_exit(CMLB_MUTEX(cl)); 3641 return (rval); 3642 } 3643 3644 #if defined(__i386) || defined(__amd64) 3645 if (cl->cl_solaris_size == 0) { 3646 mutex_exit(CMLB_MUTEX(cl)); 3647 return (EIO); 3648 } 3649 #endif 3650 3651 /* 3652 * Make a local copy of the soft state geometry to avoid some potential 3653 * race conditions associated with holding the mutex and updating the 3654 * write_reinstruct value 3655 */ 3656 tmp_geom = kmem_zalloc(sizeof (struct dk_geom), KM_SLEEP); 3657 bcopy(&cl->cl_g, tmp_geom, sizeof (struct dk_geom)); 3658 3659 if (tmp_geom->dkg_write_reinstruct == 0) { 3660 tmp_geom->dkg_write_reinstruct = 3661 (int)((int)(tmp_geom->dkg_nsect * tmp_geom->dkg_rpm * 3662 cmlb_rot_delay) / (int)60000); 3663 } 3664 mutex_exit(CMLB_MUTEX(cl)); 3665 3666 rval = ddi_copyout(tmp_geom, (void *)arg, sizeof (struct dk_geom), 3667 flag); 3668 if (rval != 0) { 3669 rval = EFAULT; 3670 } 3671 3672 kmem_free(tmp_geom, sizeof (struct dk_geom)); 3673 return (rval); 3674 3675 } 3676 3677 3678 /* 3679 * Function: cmlb_dkio_set_geometry 3680 * 3681 * Description: This routine is the driver entry point for handling user 3682 * requests to set the device geometry (DKIOCSGEOM). The actual 3683 * device geometry is not updated, just the driver "notion" of it. 3684 * 3685 * Arguments: 3686 * arg pointer to user provided dk_geom structure used to set 3687 * the controller's notion of the current geometry. 3688 * 3689 * flag this argument is a pass through to ddi_copyxxx() 3690 * directly from the mode argument of ioctl(). 3691 * 3692 * tg_cookie cookie from target driver to be passed back to target 3693 * driver when we call back to it through tg_ops. 3694 * 3695 * Return Code: 0 3696 * EFAULT 3697 * ENXIO 3698 * EIO 3699 */ 3700 static int 3701 cmlb_dkio_set_geometry(struct cmlb_lun *cl, caddr_t arg, int flag) 3702 { 3703 struct dk_geom *tmp_geom; 3704 struct dk_map *lp; 3705 int rval = 0; 3706 int i; 3707 3708 3709 #if defined(__i386) || defined(__amd64) 3710 if (cl->cl_solaris_size == 0) { 3711 return (EIO); 3712 } 3713 #endif 3714 /* 3715 * We need to copy the user specified geometry into local 3716 * storage and then update the softstate. We don't want to hold 3717 * the mutex and copyin directly from the user to the soft state 3718 */ 3719 tmp_geom = (struct dk_geom *) 3720 kmem_zalloc(sizeof (struct dk_geom), KM_SLEEP); 3721 rval = ddi_copyin(arg, tmp_geom, sizeof (struct dk_geom), flag); 3722 if (rval != 0) { 3723 kmem_free(tmp_geom, sizeof (struct dk_geom)); 3724 return (EFAULT); 3725 } 3726 3727 mutex_enter(CMLB_MUTEX(cl)); 3728 bcopy(tmp_geom, &cl->cl_g, sizeof (struct dk_geom)); 3729 for (i = 0; i < NDKMAP; i++) { 3730 lp = &cl->cl_map[i]; 3731 cl->cl_offset[i] = 3732 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno; 3733 #if defined(__i386) || defined(__amd64) 3734 cl->cl_offset[i] += cl->cl_solaris_offset; 3735 #endif 3736 } 3737 cl->cl_f_geometry_is_valid = B_FALSE; 3738 mutex_exit(CMLB_MUTEX(cl)); 3739 kmem_free(tmp_geom, sizeof (struct dk_geom)); 3740 3741 return (rval); 3742 } 3743 3744 /* 3745 * Function: cmlb_dkio_get_partition 3746 * 3747 * Description: This routine is the driver entry point for handling user 3748 * requests to get the partition table (DKIOCGAPART). 3749 * 3750 * Arguments: 3751 * arg pointer to user provided dk_allmap structure specifying 3752 * the controller's notion of the current partition table. 3753 * 3754 * flag this argument is a pass through to ddi_copyxxx() 3755 * directly from the mode argument of ioctl(). 3756 * 3757 * tg_cookie cookie from target driver to be passed back to target 3758 * driver when we call back to it through tg_ops. 3759 * 3760 * Return Code: 0 3761 * EFAULT 3762 * ENXIO 3763 * EIO 3764 */ 3765 static int 3766 cmlb_dkio_get_partition(struct cmlb_lun *cl, caddr_t arg, int flag, 3767 void *tg_cookie) 3768 { 3769 int rval = 0; 3770 int size; 3771 3772 /* 3773 * Make sure the geometry is valid before getting the partition 3774 * information. 3775 */ 3776 mutex_enter(CMLB_MUTEX(cl)); 3777 if ((rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie)) != 0) { 3778 mutex_exit(CMLB_MUTEX(cl)); 3779 return (rval); 3780 } 3781 mutex_exit(CMLB_MUTEX(cl)); 3782 3783 #if defined(__i386) || defined(__amd64) 3784 if (cl->cl_solaris_size == 0) { 3785 return (EIO); 3786 } 3787 #endif 3788 3789 #ifdef _MULTI_DATAMODEL 3790 switch (ddi_model_convert_from(flag & FMODELS)) { 3791 case DDI_MODEL_ILP32: { 3792 struct dk_map32 dk_map32[NDKMAP]; 3793 int i; 3794 3795 for (i = 0; i < NDKMAP; i++) { 3796 dk_map32[i].dkl_cylno = cl->cl_map[i].dkl_cylno; 3797 dk_map32[i].dkl_nblk = cl->cl_map[i].dkl_nblk; 3798 } 3799 size = NDKMAP * sizeof (struct dk_map32); 3800 rval = ddi_copyout(dk_map32, (void *)arg, size, flag); 3801 if (rval != 0) { 3802 rval = EFAULT; 3803 } 3804 break; 3805 } 3806 case DDI_MODEL_NONE: 3807 size = NDKMAP * sizeof (struct dk_map); 3808 rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag); 3809 if (rval != 0) { 3810 rval = EFAULT; 3811 } 3812 break; 3813 } 3814 #else /* ! _MULTI_DATAMODEL */ 3815 size = NDKMAP * sizeof (struct dk_map); 3816 rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag); 3817 if (rval != 0) { 3818 rval = EFAULT; 3819 } 3820 #endif /* _MULTI_DATAMODEL */ 3821 return (rval); 3822 } 3823 3824 /* 3825 * Function: cmlb_dkio_set_partition 3826 * 3827 * Description: This routine is the driver entry point for handling user 3828 * requests to set the partition table (DKIOCSAPART). The actual 3829 * device partition is not updated. 3830 * 3831 * Arguments: 3832 * arg - pointer to user provided dk_allmap structure used to set 3833 * the controller's notion of the partition table. 3834 * flag - this argument is a pass through to ddi_copyxxx() 3835 * directly from the mode argument of ioctl(). 3836 * 3837 * Return Code: 0 3838 * EINVAL 3839 * EFAULT 3840 * ENXIO 3841 * EIO 3842 */ 3843 static int 3844 cmlb_dkio_set_partition(struct cmlb_lun *cl, caddr_t arg, int flag) 3845 { 3846 struct dk_map dk_map[NDKMAP]; 3847 struct dk_map *lp; 3848 int rval = 0; 3849 int size; 3850 int i; 3851 #if defined(_SUNOS_VTOC_16) 3852 struct dkl_partition *vp; 3853 #endif 3854 3855 /* 3856 * Set the map for all logical partitions. We lock 3857 * the priority just to make sure an interrupt doesn't 3858 * come in while the map is half updated. 3859 */ 3860 _NOTE(DATA_READABLE_WITHOUT_LOCK(cmlb_lun::cl_solaris_size)) 3861 mutex_enter(CMLB_MUTEX(cl)); 3862 3863 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) { 3864 mutex_exit(CMLB_MUTEX(cl)); 3865 return (ENOTSUP); 3866 } 3867 mutex_exit(CMLB_MUTEX(cl)); 3868 if (cl->cl_solaris_size == 0) { 3869 return (EIO); 3870 } 3871 3872 #ifdef _MULTI_DATAMODEL 3873 switch (ddi_model_convert_from(flag & FMODELS)) { 3874 case DDI_MODEL_ILP32: { 3875 struct dk_map32 dk_map32[NDKMAP]; 3876 3877 size = NDKMAP * sizeof (struct dk_map32); 3878 rval = ddi_copyin((void *)arg, dk_map32, size, flag); 3879 if (rval != 0) { 3880 return (EFAULT); 3881 } 3882 for (i = 0; i < NDKMAP; i++) { 3883 dk_map[i].dkl_cylno = dk_map32[i].dkl_cylno; 3884 dk_map[i].dkl_nblk = dk_map32[i].dkl_nblk; 3885 } 3886 break; 3887 } 3888 case DDI_MODEL_NONE: 3889 size = NDKMAP * sizeof (struct dk_map); 3890 rval = ddi_copyin((void *)arg, dk_map, size, flag); 3891 if (rval != 0) { 3892 return (EFAULT); 3893 } 3894 break; 3895 } 3896 #else /* ! _MULTI_DATAMODEL */ 3897 size = NDKMAP * sizeof (struct dk_map); 3898 rval = ddi_copyin((void *)arg, dk_map, size, flag); 3899 if (rval != 0) { 3900 return (EFAULT); 3901 } 3902 #endif /* _MULTI_DATAMODEL */ 3903 3904 mutex_enter(CMLB_MUTEX(cl)); 3905 /* Note: The size used in this bcopy is set based upon the data model */ 3906 bcopy(dk_map, cl->cl_map, size); 3907 #if defined(_SUNOS_VTOC_16) 3908 vp = (struct dkl_partition *)&(cl->cl_vtoc); 3909 #endif /* defined(_SUNOS_VTOC_16) */ 3910 for (i = 0; i < NDKMAP; i++) { 3911 lp = &cl->cl_map[i]; 3912 cl->cl_offset[i] = 3913 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno; 3914 #if defined(_SUNOS_VTOC_16) 3915 vp->p_start = cl->cl_offset[i]; 3916 vp->p_size = lp->dkl_nblk; 3917 vp++; 3918 #endif /* defined(_SUNOS_VTOC_16) */ 3919 #if defined(__i386) || defined(__amd64) 3920 cl->cl_offset[i] += cl->cl_solaris_offset; 3921 #endif 3922 } 3923 mutex_exit(CMLB_MUTEX(cl)); 3924 return (rval); 3925 } 3926 3927 3928 /* 3929 * Function: cmlb_dkio_get_vtoc 3930 * 3931 * Description: This routine is the driver entry point for handling user 3932 * requests to get the current volume table of contents 3933 * (DKIOCGVTOC). 3934 * 3935 * Arguments: 3936 * arg pointer to user provided vtoc structure specifying 3937 * the current vtoc. 3938 * 3939 * flag this argument is a pass through to ddi_copyxxx() 3940 * directly from the mode argument of ioctl(). 3941 * 3942 * tg_cookie cookie from target driver to be passed back to target 3943 * driver when we call back to it through tg_ops. 3944 * 3945 * Return Code: 0 3946 * EFAULT 3947 * ENXIO 3948 * EIO 3949 */ 3950 static int 3951 cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie) 3952 { 3953 #if defined(_SUNOS_VTOC_8) 3954 struct vtoc user_vtoc; 3955 #endif /* defined(_SUNOS_VTOC_8) */ 3956 int rval = 0; 3957 3958 mutex_enter(CMLB_MUTEX(cl)); 3959 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) { 3960 mutex_exit(CMLB_MUTEX(cl)); 3961 return (EOVERFLOW); 3962 } 3963 3964 rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie); 3965 3966 #if defined(_SUNOS_VTOC_8) 3967 if (rval == EINVAL && 3968 (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8)) { 3969 /* 3970 * This is to return a default label even when we do not 3971 * really assume a default label for the device. 3972 * dad driver utilizes this. 3973 */ 3974 if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) { 3975 cmlb_setup_default_geometry(cl, tg_cookie); 3976 rval = 0; 3977 } 3978 } 3979 #endif 3980 if (rval) { 3981 mutex_exit(CMLB_MUTEX(cl)); 3982 return (rval); 3983 } 3984 3985 #if defined(_SUNOS_VTOC_8) 3986 cmlb_build_user_vtoc(cl, &user_vtoc); 3987 mutex_exit(CMLB_MUTEX(cl)); 3988 3989 #ifdef _MULTI_DATAMODEL 3990 switch (ddi_model_convert_from(flag & FMODELS)) { 3991 case DDI_MODEL_ILP32: { 3992 struct vtoc32 user_vtoc32; 3993 3994 vtoctovtoc32(user_vtoc, user_vtoc32); 3995 if (ddi_copyout(&user_vtoc32, (void *)arg, 3996 sizeof (struct vtoc32), flag)) { 3997 return (EFAULT); 3998 } 3999 break; 4000 } 4001 4002 case DDI_MODEL_NONE: 4003 if (ddi_copyout(&user_vtoc, (void *)arg, 4004 sizeof (struct vtoc), flag)) { 4005 return (EFAULT); 4006 } 4007 break; 4008 } 4009 #else /* ! _MULTI_DATAMODEL */ 4010 if (ddi_copyout(&user_vtoc, (void *)arg, sizeof (struct vtoc), flag)) { 4011 return (EFAULT); 4012 } 4013 #endif /* _MULTI_DATAMODEL */ 4014 4015 #elif defined(_SUNOS_VTOC_16) 4016 mutex_exit(CMLB_MUTEX(cl)); 4017 4018 #ifdef _MULTI_DATAMODEL 4019 /* 4020 * The cl_vtoc structure is a "struct dk_vtoc" which is always 4021 * 32-bit to maintain compatibility with existing on-disk 4022 * structures. Thus, we need to convert the structure when copying 4023 * it out to a datamodel-dependent "struct vtoc" in a 64-bit 4024 * program. If the target is a 32-bit program, then no conversion 4025 * is necessary. 4026 */ 4027 /* LINTED: logical expression always true: op "||" */ 4028 ASSERT(sizeof (cl->cl_vtoc) == sizeof (struct vtoc32)); 4029 switch (ddi_model_convert_from(flag & FMODELS)) { 4030 case DDI_MODEL_ILP32: 4031 if (ddi_copyout(&(cl->cl_vtoc), (void *)arg, 4032 sizeof (cl->cl_vtoc), flag)) { 4033 return (EFAULT); 4034 } 4035 break; 4036 4037 case DDI_MODEL_NONE: { 4038 struct vtoc user_vtoc; 4039 4040 vtoc32tovtoc(cl->cl_vtoc, user_vtoc); 4041 if (ddi_copyout(&user_vtoc, (void *)arg, 4042 sizeof (struct vtoc), flag)) { 4043 return (EFAULT); 4044 } 4045 break; 4046 } 4047 } 4048 #else /* ! _MULTI_DATAMODEL */ 4049 if (ddi_copyout(&(cl->cl_vtoc), (void *)arg, sizeof (cl->cl_vtoc), 4050 flag)) { 4051 return (EFAULT); 4052 } 4053 #endif /* _MULTI_DATAMODEL */ 4054 #else 4055 #error "No VTOC format defined." 4056 #endif 4057 4058 return (rval); 4059 } 4060 4061 4062 /* 4063 * Function: cmlb_dkio_get_extvtoc 4064 */ 4065 static int 4066 cmlb_dkio_get_extvtoc(struct cmlb_lun *cl, caddr_t arg, int flag, 4067 void *tg_cookie) 4068 { 4069 struct extvtoc ext_vtoc; 4070 #if defined(_SUNOS_VTOC_8) 4071 struct vtoc user_vtoc; 4072 #endif /* defined(_SUNOS_VTOC_8) */ 4073 int rval = 0; 4074 4075 bzero(&ext_vtoc, sizeof (struct extvtoc)); 4076 mutex_enter(CMLB_MUTEX(cl)); 4077 rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie); 4078 4079 #if defined(_SUNOS_VTOC_8) 4080 if (rval == EINVAL && 4081 (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8)) { 4082 /* 4083 * This is to return a default label even when we do not 4084 * really assume a default label for the device. 4085 * dad driver utilizes this. 4086 */ 4087 if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) { 4088 cmlb_setup_default_geometry(cl, tg_cookie); 4089 rval = 0; 4090 } 4091 } 4092 #endif 4093 if (rval) { 4094 mutex_exit(CMLB_MUTEX(cl)); 4095 return (rval); 4096 } 4097 4098 #if defined(_SUNOS_VTOC_8) 4099 cmlb_build_user_vtoc(cl, &user_vtoc); 4100 mutex_exit(CMLB_MUTEX(cl)); 4101 4102 /* 4103 * Checking callers data model does not make much sense here 4104 * since extvtoc will always be equivalent to 64bit vtoc. 4105 * What is important is whether the kernel is in 32 or 64 bit 4106 */ 4107 4108 #ifdef _LP64 4109 if (ddi_copyout(&user_vtoc, (void *)arg, 4110 sizeof (struct extvtoc), flag)) { 4111 return (EFAULT); 4112 } 4113 #else 4114 vtoc32tovtoc(user_vtoc, ext_vtoc); 4115 if (ddi_copyout(&ext_vtoc, (void *)arg, 4116 sizeof (struct extvtoc), flag)) { 4117 return (EFAULT); 4118 } 4119 #endif 4120 4121 #elif defined(_SUNOS_VTOC_16) 4122 /* 4123 * The cl_vtoc structure is a "struct dk_vtoc" which is always 4124 * 32-bit to maintain compatibility with existing on-disk 4125 * structures. Thus, we need to convert the structure when copying 4126 * it out to extvtoc 4127 */ 4128 vtoc32tovtoc(cl->cl_vtoc, ext_vtoc); 4129 mutex_exit(CMLB_MUTEX(cl)); 4130 4131 if (ddi_copyout(&ext_vtoc, (void *)arg, sizeof (struct extvtoc), flag)) 4132 return (EFAULT); 4133 #else 4134 #error "No VTOC format defined." 4135 #endif 4136 4137 return (rval); 4138 } 4139 4140 /* 4141 * This routine implements the DKIOCGETEFI ioctl. This ioctl is currently 4142 * used to read the GPT Partition Table Header (primary/backup), the GUID 4143 * partition Entry Array (primary/backup), and the MBR. 4144 */ 4145 static int 4146 cmlb_dkio_get_efi(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie) 4147 { 4148 dk_efi_t user_efi; 4149 int rval = 0; 4150 void *buffer; 4151 diskaddr_t tgt_lba; 4152 4153 if (ddi_copyin(arg, &user_efi, sizeof (dk_efi_t), flag)) 4154 return (EFAULT); 4155 4156 user_efi.dki_data = (void *)(uintptr_t)user_efi.dki_data_64; 4157 4158 if (user_efi.dki_length == 0 || 4159 user_efi.dki_length > cmlb_tg_max_efi_xfer) 4160 return (EINVAL); 4161 4162 tgt_lba = user_efi.dki_lba; 4163 4164 mutex_enter(CMLB_MUTEX(cl)); 4165 if ((cmlb_check_update_blockcount(cl, tg_cookie) != 0) || 4166 (cl->cl_tgt_blocksize == 0) || 4167 (user_efi.dki_length % cl->cl_sys_blocksize)) { 4168 mutex_exit(CMLB_MUTEX(cl)); 4169 return (EINVAL); 4170 } 4171 if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) 4172 tgt_lba = tgt_lba * cl->cl_tgt_blocksize / 4173 cl->cl_sys_blocksize; 4174 mutex_exit(CMLB_MUTEX(cl)); 4175 4176 buffer = kmem_alloc(user_efi.dki_length, KM_SLEEP); 4177 rval = DK_TG_READ(cl, buffer, tgt_lba, user_efi.dki_length, tg_cookie); 4178 if (rval == 0 && ddi_copyout(buffer, user_efi.dki_data, 4179 user_efi.dki_length, flag) != 0) 4180 rval = EFAULT; 4181 4182 kmem_free(buffer, user_efi.dki_length); 4183 return (rval); 4184 } 4185 4186 #if defined(_SUNOS_VTOC_8) 4187 /* 4188 * Function: cmlb_build_user_vtoc 4189 * 4190 * Description: This routine populates a pass by reference variable with the 4191 * current volume table of contents. 4192 * 4193 * Arguments: cl - driver soft state (unit) structure 4194 * user_vtoc - pointer to vtoc structure to be populated 4195 */ 4196 static void 4197 cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc) 4198 { 4199 struct dk_map2 *lpart; 4200 struct dk_map *lmap; 4201 struct partition *vpart; 4202 uint32_t nblks; 4203 int i; 4204 4205 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 4206 4207 /* 4208 * Return vtoc structure fields in the provided VTOC area, addressed 4209 * by *vtoc. 4210 */ 4211 bzero(user_vtoc, sizeof (struct vtoc)); 4212 user_vtoc->v_bootinfo[0] = cl->cl_vtoc.v_bootinfo[0]; 4213 user_vtoc->v_bootinfo[1] = cl->cl_vtoc.v_bootinfo[1]; 4214 user_vtoc->v_bootinfo[2] = cl->cl_vtoc.v_bootinfo[2]; 4215 user_vtoc->v_sanity = VTOC_SANE; 4216 user_vtoc->v_version = cl->cl_vtoc.v_version; 4217 bcopy(cl->cl_vtoc.v_volume, user_vtoc->v_volume, LEN_DKL_VVOL); 4218 user_vtoc->v_sectorsz = cl->cl_sys_blocksize; 4219 user_vtoc->v_nparts = cl->cl_vtoc.v_nparts; 4220 4221 for (i = 0; i < 10; i++) 4222 user_vtoc->v_reserved[i] = cl->cl_vtoc.v_reserved[i]; 4223 4224 /* 4225 * Convert partitioning information. 4226 * 4227 * Note the conversion from starting cylinder number 4228 * to starting sector number. 4229 */ 4230 lmap = cl->cl_map; 4231 lpart = (struct dk_map2 *)cl->cl_vtoc.v_part; 4232 vpart = user_vtoc->v_part; 4233 4234 nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead; 4235 4236 for (i = 0; i < V_NUMPAR; i++) { 4237 vpart->p_tag = lpart->p_tag; 4238 vpart->p_flag = lpart->p_flag; 4239 vpart->p_start = lmap->dkl_cylno * nblks; 4240 vpart->p_size = lmap->dkl_nblk; 4241 lmap++; 4242 lpart++; 4243 vpart++; 4244 4245 /* (4364927) */ 4246 user_vtoc->timestamp[i] = (time_t)cl->cl_vtoc.v_timestamp[i]; 4247 } 4248 4249 bcopy(cl->cl_asciilabel, user_vtoc->v_asciilabel, LEN_DKL_ASCII); 4250 } 4251 #endif 4252 4253 static int 4254 cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag, 4255 void *tg_cookie) 4256 { 4257 struct partition64 p64; 4258 int rval = 0; 4259 uint_t nparts; 4260 efi_gpe_t *partitions; 4261 efi_gpt_t *buffer; 4262 diskaddr_t gpe_lba; 4263 int n_gpe_per_blk = 0; 4264 4265 if (ddi_copyin((const void *)arg, &p64, 4266 sizeof (struct partition64), flag)) { 4267 return (EFAULT); 4268 } 4269 4270 buffer = kmem_alloc(cl->cl_sys_blocksize, KM_SLEEP); 4271 rval = DK_TG_READ(cl, buffer, 1, cl->cl_sys_blocksize, tg_cookie); 4272 if (rval != 0) 4273 goto done_error; 4274 4275 cmlb_swap_efi_gpt(buffer); 4276 4277 if ((rval = cmlb_validate_efi(buffer)) != 0) 4278 goto done_error; 4279 4280 nparts = buffer->efi_gpt_NumberOfPartitionEntries; 4281 gpe_lba = buffer->efi_gpt_PartitionEntryLBA; 4282 if (p64.p_partno >= nparts) { 4283 /* couldn't find it */ 4284 rval = ESRCH; 4285 goto done_error; 4286 } 4287 /* 4288 * Read the block that contains the requested GPE. 4289 */ 4290 n_gpe_per_blk = cl->cl_sys_blocksize / sizeof (efi_gpe_t); 4291 gpe_lba += p64.p_partno / n_gpe_per_blk; 4292 rval = DK_TG_READ(cl, buffer, gpe_lba, cl->cl_sys_blocksize, tg_cookie); 4293 4294 if (rval) { 4295 goto done_error; 4296 } 4297 partitions = (efi_gpe_t *)buffer; 4298 partitions += p64.p_partno % n_gpe_per_blk; 4299 4300 /* Byte swap only the requested GPE */ 4301 cmlb_swap_efi_gpe(1, partitions); 4302 4303 bcopy(&partitions->efi_gpe_PartitionTypeGUID, &p64.p_type, 4304 sizeof (struct uuid)); 4305 p64.p_start = partitions->efi_gpe_StartingLBA; 4306 p64.p_size = partitions->efi_gpe_EndingLBA - 4307 p64.p_start + 1; 4308 4309 if (ddi_copyout(&p64, (void *)arg, sizeof (struct partition64), flag)) 4310 rval = EFAULT; 4311 4312 done_error: 4313 kmem_free(buffer, cl->cl_sys_blocksize); 4314 return (rval); 4315 } 4316 4317 4318 /* 4319 * Function: cmlb_dkio_set_vtoc 4320 * 4321 * Description: This routine is the driver entry point for handling user 4322 * requests to set the current volume table of contents 4323 * (DKIOCSVTOC). 4324 * 4325 * Arguments: 4326 * dev the device number 4327 * arg pointer to user provided vtoc structure used to set the 4328 * current vtoc. 4329 * 4330 * flag this argument is a pass through to ddi_copyxxx() 4331 * directly from the mode argument of ioctl(). 4332 * 4333 * tg_cookie cookie from target driver to be passed back to target 4334 * driver when we call back to it through tg_ops. 4335 * 4336 * Return Code: 0 4337 * EFAULT 4338 * ENXIO 4339 * EINVAL 4340 * ENOTSUP 4341 */ 4342 static int 4343 cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag, 4344 void *tg_cookie) 4345 { 4346 struct vtoc user_vtoc; 4347 int shift, rval = 0; 4348 boolean_t internal; 4349 4350 internal = VOID2BOOLEAN( 4351 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0); 4352 4353 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) 4354 shift = CMLBUNIT_FORCE_P0_SHIFT; 4355 else 4356 shift = CMLBUNIT_SHIFT; 4357 4358 #ifdef _MULTI_DATAMODEL 4359 switch (ddi_model_convert_from(flag & FMODELS)) { 4360 case DDI_MODEL_ILP32: { 4361 struct vtoc32 user_vtoc32; 4362 4363 if (ddi_copyin((const void *)arg, &user_vtoc32, 4364 sizeof (struct vtoc32), flag)) { 4365 return (EFAULT); 4366 } 4367 vtoc32tovtoc(user_vtoc32, user_vtoc); 4368 break; 4369 } 4370 4371 case DDI_MODEL_NONE: 4372 if (ddi_copyin((const void *)arg, &user_vtoc, 4373 sizeof (struct vtoc), flag)) { 4374 return (EFAULT); 4375 } 4376 break; 4377 } 4378 #else /* ! _MULTI_DATAMODEL */ 4379 if (ddi_copyin((const void *)arg, &user_vtoc, 4380 sizeof (struct vtoc), flag)) { 4381 return (EFAULT); 4382 } 4383 #endif /* _MULTI_DATAMODEL */ 4384 4385 mutex_enter(CMLB_MUTEX(cl)); 4386 4387 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) { 4388 mutex_exit(CMLB_MUTEX(cl)); 4389 return (EOVERFLOW); 4390 } 4391 4392 #if defined(__i386) || defined(__amd64) 4393 if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) { 4394 mutex_exit(CMLB_MUTEX(cl)); 4395 return (EINVAL); 4396 } 4397 #endif 4398 4399 if (cl->cl_g.dkg_ncyl == 0) { 4400 mutex_exit(CMLB_MUTEX(cl)); 4401 return (EINVAL); 4402 } 4403 4404 mutex_exit(CMLB_MUTEX(cl)); 4405 cmlb_clear_efi(cl, tg_cookie); 4406 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd"); 4407 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw"); 4408 4409 /* 4410 * cmlb_dkio_set_vtoc creates duplicate minor nodes when 4411 * relabeling an SMI disk. To avoid that we remove them 4412 * before creating. 4413 * It should be OK to remove a non-existed minor node. 4414 */ 4415 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h"); 4416 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw"); 4417 4418 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h", 4419 S_IFBLK, (CMLBUNIT(dev, shift) << shift) | WD_NODE, 4420 cl->cl_node_type, 0, internal); 4421 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw", 4422 S_IFCHR, (CMLBUNIT(dev, shift) << shift) | WD_NODE, 4423 cl->cl_node_type, 0, internal); 4424 mutex_enter(CMLB_MUTEX(cl)); 4425 4426 if ((rval = cmlb_build_label_vtoc(cl, &user_vtoc)) == 0) { 4427 if ((rval = cmlb_write_label(cl, tg_cookie)) == 0) { 4428 if (cmlb_validate_geometry(cl, 4429 B_TRUE, 0, tg_cookie) != 0) { 4430 cmlb_dbg(CMLB_ERROR, cl, 4431 "cmlb_dkio_set_vtoc: " 4432 "Failed validate geometry\n"); 4433 } 4434 cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN; 4435 } 4436 } 4437 mutex_exit(CMLB_MUTEX(cl)); 4438 return (rval); 4439 } 4440 4441 /* 4442 * Function: cmlb_dkio_set_extvtoc 4443 */ 4444 static int 4445 cmlb_dkio_set_extvtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag, 4446 void *tg_cookie) 4447 { 4448 int shift, rval = 0; 4449 struct vtoc user_vtoc; 4450 boolean_t internal; 4451 4452 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) 4453 shift = CMLBUNIT_FORCE_P0_SHIFT; 4454 else 4455 shift = CMLBUNIT_SHIFT; 4456 4457 /* 4458 * Checking callers data model does not make much sense here 4459 * since extvtoc will always be equivalent to 64bit vtoc. 4460 * What is important is whether the kernel is in 32 or 64 bit 4461 */ 4462 4463 #ifdef _LP64 4464 if (ddi_copyin((const void *)arg, &user_vtoc, 4465 sizeof (struct extvtoc), flag)) { 4466 return (EFAULT); 4467 } 4468 #else 4469 struct extvtoc user_extvtoc; 4470 if (ddi_copyin((const void *)arg, &user_extvtoc, 4471 sizeof (struct extvtoc), flag)) { 4472 return (EFAULT); 4473 } 4474 4475 vtoctovtoc32(user_extvtoc, user_vtoc); 4476 #endif 4477 4478 internal = VOID2BOOLEAN( 4479 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0); 4480 mutex_enter(CMLB_MUTEX(cl)); 4481 #if defined(__i386) || defined(__amd64) 4482 if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) { 4483 mutex_exit(CMLB_MUTEX(cl)); 4484 return (EINVAL); 4485 } 4486 #endif 4487 4488 if (cl->cl_g.dkg_ncyl == 0) { 4489 mutex_exit(CMLB_MUTEX(cl)); 4490 return (EINVAL); 4491 } 4492 4493 mutex_exit(CMLB_MUTEX(cl)); 4494 cmlb_clear_efi(cl, tg_cookie); 4495 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd"); 4496 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw"); 4497 /* 4498 * cmlb_dkio_set_extvtoc creates duplicate minor nodes when 4499 * relabeling an SMI disk. To avoid that we remove them 4500 * before creating. 4501 * It should be OK to remove a non-existed minor node. 4502 */ 4503 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h"); 4504 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw"); 4505 4506 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h", 4507 S_IFBLK, (CMLBUNIT(dev, shift) << shift) | WD_NODE, 4508 cl->cl_node_type, 0, internal); 4509 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw", 4510 S_IFCHR, (CMLBUNIT(dev, shift) << shift) | WD_NODE, 4511 cl->cl_node_type, 0, internal); 4512 4513 mutex_enter(CMLB_MUTEX(cl)); 4514 4515 if ((rval = cmlb_build_label_vtoc(cl, &user_vtoc)) == 0) { 4516 if ((rval = cmlb_write_label(cl, tg_cookie)) == 0) { 4517 if (cmlb_validate_geometry(cl, 4518 B_TRUE, 0, tg_cookie) != 0) { 4519 cmlb_dbg(CMLB_ERROR, cl, 4520 "cmlb_dkio_set_vtoc: " 4521 "Failed validate geometry\n"); 4522 } 4523 } 4524 } 4525 mutex_exit(CMLB_MUTEX(cl)); 4526 return (rval); 4527 } 4528 4529 /* 4530 * Function: cmlb_build_label_vtoc 4531 * 4532 * Description: This routine updates the driver soft state current volume table 4533 * of contents based on a user specified vtoc. 4534 * 4535 * Arguments: cl - driver soft state (unit) structure 4536 * user_vtoc - pointer to vtoc structure specifying vtoc to be used 4537 * to update the driver soft state. 4538 * 4539 * Return Code: 0 4540 * EINVAL 4541 */ 4542 static int 4543 cmlb_build_label_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc) 4544 { 4545 struct dk_map *lmap; 4546 struct partition *vpart; 4547 uint_t nblks; 4548 #if defined(_SUNOS_VTOC_8) 4549 int ncyl; 4550 struct dk_map2 *lpart; 4551 #endif /* defined(_SUNOS_VTOC_8) */ 4552 int i; 4553 4554 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 4555 4556 /* Sanity-check the vtoc */ 4557 if (user_vtoc->v_sanity != VTOC_SANE || 4558 user_vtoc->v_sectorsz != cl->cl_sys_blocksize || 4559 user_vtoc->v_nparts != V_NUMPAR) { 4560 cmlb_dbg(CMLB_INFO, cl, 4561 "cmlb_build_label_vtoc: vtoc not valid\n"); 4562 return (EINVAL); 4563 } 4564 4565 nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead; 4566 if (nblks == 0) { 4567 cmlb_dbg(CMLB_INFO, cl, 4568 "cmlb_build_label_vtoc: geom nblks is 0\n"); 4569 return (EINVAL); 4570 } 4571 4572 #if defined(_SUNOS_VTOC_8) 4573 vpart = user_vtoc->v_part; 4574 for (i = 0; i < V_NUMPAR; i++) { 4575 if (((unsigned)vpart->p_start % nblks) != 0) { 4576 cmlb_dbg(CMLB_INFO, cl, 4577 "cmlb_build_label_vtoc: p_start not multiply of" 4578 "nblks part %d p_start %d nblks %d\n", i, 4579 vpart->p_start, nblks); 4580 return (EINVAL); 4581 } 4582 ncyl = (unsigned)vpart->p_start / nblks; 4583 ncyl += (unsigned)vpart->p_size / nblks; 4584 if (((unsigned)vpart->p_size % nblks) != 0) { 4585 ncyl++; 4586 } 4587 if (ncyl > (int)cl->cl_g.dkg_ncyl) { 4588 cmlb_dbg(CMLB_INFO, cl, 4589 "cmlb_build_label_vtoc: ncyl %d > dkg_ncyl %d" 4590 "p_size %ld p_start %ld nblks %d part number %d" 4591 "tag %d\n", 4592 ncyl, cl->cl_g.dkg_ncyl, vpart->p_size, 4593 vpart->p_start, nblks, 4594 i, vpart->p_tag); 4595 4596 return (EINVAL); 4597 } 4598 vpart++; 4599 } 4600 #endif /* defined(_SUNOS_VTOC_8) */ 4601 4602 /* Put appropriate vtoc structure fields into the disk label */ 4603 #if defined(_SUNOS_VTOC_16) 4604 /* 4605 * The vtoc is always a 32bit data structure to maintain the 4606 * on-disk format. Convert "in place" instead of doing bcopy. 4607 */ 4608 vtoctovtoc32((*user_vtoc), (*((struct vtoc32 *)&(cl->cl_vtoc)))); 4609 4610 /* 4611 * in the 16-slice vtoc, starting sectors are expressed in 4612 * numbers *relative* to the start of the Solaris fdisk partition. 4613 */ 4614 lmap = cl->cl_map; 4615 vpart = user_vtoc->v_part; 4616 4617 for (i = 0; i < (int)user_vtoc->v_nparts; i++, lmap++, vpart++) { 4618 lmap->dkl_cylno = (unsigned)vpart->p_start / nblks; 4619 lmap->dkl_nblk = (unsigned)vpart->p_size; 4620 } 4621 4622 #elif defined(_SUNOS_VTOC_8) 4623 4624 cl->cl_vtoc.v_bootinfo[0] = (uint32_t)user_vtoc->v_bootinfo[0]; 4625 cl->cl_vtoc.v_bootinfo[1] = (uint32_t)user_vtoc->v_bootinfo[1]; 4626 cl->cl_vtoc.v_bootinfo[2] = (uint32_t)user_vtoc->v_bootinfo[2]; 4627 4628 cl->cl_vtoc.v_sanity = (uint32_t)user_vtoc->v_sanity; 4629 cl->cl_vtoc.v_version = (uint32_t)user_vtoc->v_version; 4630 4631 bcopy(user_vtoc->v_volume, cl->cl_vtoc.v_volume, LEN_DKL_VVOL); 4632 4633 cl->cl_vtoc.v_nparts = user_vtoc->v_nparts; 4634 4635 for (i = 0; i < 10; i++) 4636 cl->cl_vtoc.v_reserved[i] = user_vtoc->v_reserved[i]; 4637 4638 /* 4639 * Note the conversion from starting sector number 4640 * to starting cylinder number. 4641 * Return error if division results in a remainder. 4642 */ 4643 lmap = cl->cl_map; 4644 lpart = cl->cl_vtoc.v_part; 4645 vpart = user_vtoc->v_part; 4646 4647 for (i = 0; i < (int)user_vtoc->v_nparts; i++) { 4648 lpart->p_tag = vpart->p_tag; 4649 lpart->p_flag = vpart->p_flag; 4650 lmap->dkl_cylno = (unsigned)vpart->p_start / nblks; 4651 lmap->dkl_nblk = (unsigned)vpart->p_size; 4652 4653 lmap++; 4654 lpart++; 4655 vpart++; 4656 4657 /* (4387723) */ 4658 #ifdef _LP64 4659 if (user_vtoc->timestamp[i] > TIME32_MAX) { 4660 cl->cl_vtoc.v_timestamp[i] = TIME32_MAX; 4661 } else { 4662 cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i]; 4663 } 4664 #else 4665 cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i]; 4666 #endif 4667 } 4668 4669 bcopy(user_vtoc->v_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII); 4670 #else 4671 #error "No VTOC format defined." 4672 #endif 4673 return (0); 4674 } 4675 4676 /* 4677 * Function: cmlb_clear_efi 4678 * 4679 * Description: This routine clears all EFI labels. 4680 * 4681 * Arguments: 4682 * cl driver soft state (unit) structure 4683 * 4684 * tg_cookie cookie from target driver to be passed back to target 4685 * driver when we call back to it through tg_ops. 4686 * Return Code: void 4687 */ 4688 static void 4689 cmlb_clear_efi(struct cmlb_lun *cl, void *tg_cookie) 4690 { 4691 efi_gpt_t *gpt; 4692 diskaddr_t cap; 4693 int rval; 4694 4695 ASSERT(!mutex_owned(CMLB_MUTEX(cl))); 4696 4697 mutex_enter(CMLB_MUTEX(cl)); 4698 cl->cl_reserved = -1; 4699 mutex_exit(CMLB_MUTEX(cl)); 4700 4701 gpt = kmem_alloc(cl->cl_sys_blocksize, KM_SLEEP); 4702 4703 if (DK_TG_READ(cl, gpt, 1, cl->cl_sys_blocksize, tg_cookie) != 0) { 4704 goto done; 4705 } 4706 4707 cmlb_swap_efi_gpt(gpt); 4708 rval = cmlb_validate_efi(gpt); 4709 if (rval == 0) { 4710 /* clear primary */ 4711 bzero(gpt, sizeof (efi_gpt_t)); 4712 if (rval = DK_TG_WRITE(cl, gpt, 1, cl->cl_sys_blocksize, 4713 tg_cookie)) { 4714 cmlb_dbg(CMLB_INFO, cl, 4715 "cmlb_clear_efi: clear primary label failed\n"); 4716 } 4717 } 4718 /* the backup */ 4719 rval = DK_TG_GETCAP(cl, &cap, tg_cookie); 4720 if (rval) { 4721 goto done; 4722 } 4723 4724 if ((rval = DK_TG_READ(cl, gpt, cap - 1, cl->cl_sys_blocksize, 4725 tg_cookie)) != 0) { 4726 goto done; 4727 } 4728 cmlb_swap_efi_gpt(gpt); 4729 rval = cmlb_validate_efi(gpt); 4730 if (rval == 0) { 4731 /* clear backup */ 4732 cmlb_dbg(CMLB_TRACE, cl, 4733 "cmlb_clear_efi clear backup@%lu\n", cap - 1); 4734 bzero(gpt, sizeof (efi_gpt_t)); 4735 if ((rval = DK_TG_WRITE(cl, gpt, cap - 1, cl->cl_sys_blocksize, 4736 tg_cookie))) { 4737 cmlb_dbg(CMLB_INFO, cl, 4738 "cmlb_clear_efi: clear backup label failed\n"); 4739 } 4740 } else { 4741 /* 4742 * Refer to comments related to off-by-1 at the 4743 * header of this file 4744 */ 4745 if ((rval = DK_TG_READ(cl, gpt, cap - 2, 4746 cl->cl_sys_blocksize, tg_cookie)) != 0) { 4747 goto done; 4748 } 4749 cmlb_swap_efi_gpt(gpt); 4750 rval = cmlb_validate_efi(gpt); 4751 if (rval == 0) { 4752 /* clear legacy backup EFI label */ 4753 cmlb_dbg(CMLB_TRACE, cl, 4754 "cmlb_clear_efi clear legacy backup@%lu\n", 4755 cap - 2); 4756 bzero(gpt, sizeof (efi_gpt_t)); 4757 if ((rval = DK_TG_WRITE(cl, gpt, cap - 2, 4758 cl->cl_sys_blocksize, tg_cookie))) { 4759 cmlb_dbg(CMLB_INFO, cl, 4760 "cmlb_clear_efi: clear legacy backup label " 4761 "failed\n"); 4762 } 4763 } 4764 } 4765 4766 done: 4767 kmem_free(gpt, cl->cl_sys_blocksize); 4768 } 4769 4770 /* 4771 * Function: cmlb_set_vtoc 4772 * 4773 * Description: This routine writes data to the appropriate positions 4774 * 4775 * Arguments: 4776 * cl driver soft state (unit) structure 4777 * 4778 * dkl the data to be written 4779 * 4780 * tg_cookie cookie from target driver to be passed back to target 4781 * driver when we call back to it through tg_ops. 4782 * 4783 * Return: void 4784 */ 4785 static int 4786 cmlb_set_vtoc(struct cmlb_lun *cl, struct dk_label *dkl, void *tg_cookie) 4787 { 4788 uint_t label_addr; 4789 int sec; 4790 diskaddr_t blk; 4791 int head; 4792 int cyl; 4793 int rval; 4794 4795 #if defined(__i386) || defined(__amd64) 4796 label_addr = cl->cl_solaris_offset + DK_LABEL_LOC; 4797 #else 4798 /* Write the primary label at block 0 of the solaris partition. */ 4799 label_addr = 0; 4800 #endif 4801 4802 rval = DK_TG_WRITE(cl, dkl, label_addr, cl->cl_sys_blocksize, 4803 tg_cookie); 4804 4805 if (rval != 0) { 4806 return (rval); 4807 } 4808 4809 /* 4810 * Calculate where the backup labels go. They are always on 4811 * the last alternate cylinder, but some older drives put them 4812 * on head 2 instead of the last head. They are always on the 4813 * first 5 odd sectors of the appropriate track. 4814 * 4815 * We have no choice at this point, but to believe that the 4816 * disk label is valid. Use the geometry of the disk 4817 * as described in the label. 4818 */ 4819 cyl = dkl->dkl_ncyl + dkl->dkl_acyl - 1; 4820 head = dkl->dkl_nhead - 1; 4821 4822 /* 4823 * Write and verify the backup labels. Make sure we don't try to 4824 * write past the last cylinder. 4825 */ 4826 for (sec = 1; ((sec < 5 * 2 + 1) && (sec < dkl->dkl_nsect)); sec += 2) { 4827 blk = (diskaddr_t)( 4828 (cyl * ((dkl->dkl_nhead * dkl->dkl_nsect) - dkl->dkl_apc)) + 4829 (head * dkl->dkl_nsect) + sec); 4830 #if defined(__i386) || defined(__amd64) 4831 blk += cl->cl_solaris_offset; 4832 #endif 4833 rval = DK_TG_WRITE(cl, dkl, blk, cl->cl_sys_blocksize, 4834 tg_cookie); 4835 cmlb_dbg(CMLB_INFO, cl, 4836 "cmlb_set_vtoc: wrote backup label %llx\n", blk); 4837 if (rval != 0) { 4838 goto exit; 4839 } 4840 } 4841 exit: 4842 return (rval); 4843 } 4844 4845 /* 4846 * Function: cmlb_clear_vtoc 4847 * 4848 * Description: This routine clears out the VTOC labels. 4849 * 4850 * Arguments: 4851 * cl driver soft state (unit) structure 4852 * 4853 * tg_cookie cookie from target driver to be passed back to target 4854 * driver when we call back to it through tg_ops. 4855 * 4856 * Return: void 4857 */ 4858 static void 4859 cmlb_clear_vtoc(struct cmlb_lun *cl, void *tg_cookie) 4860 { 4861 struct dk_label *dkl; 4862 4863 mutex_exit(CMLB_MUTEX(cl)); 4864 dkl = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP); 4865 mutex_enter(CMLB_MUTEX(cl)); 4866 /* 4867 * cmlb_set_vtoc uses these fields in order to figure out 4868 * where to overwrite the backup labels 4869 */ 4870 dkl->dkl_apc = cl->cl_g.dkg_apc; 4871 dkl->dkl_ncyl = cl->cl_g.dkg_ncyl; 4872 dkl->dkl_acyl = cl->cl_g.dkg_acyl; 4873 dkl->dkl_nhead = cl->cl_g.dkg_nhead; 4874 dkl->dkl_nsect = cl->cl_g.dkg_nsect; 4875 mutex_exit(CMLB_MUTEX(cl)); 4876 (void) cmlb_set_vtoc(cl, dkl, tg_cookie); 4877 kmem_free(dkl, cl->cl_sys_blocksize); 4878 4879 mutex_enter(CMLB_MUTEX(cl)); 4880 } 4881 4882 /* 4883 * Function: cmlb_write_label 4884 * 4885 * Description: This routine will validate and write the driver soft state vtoc 4886 * contents to the device. 4887 * 4888 * Arguments: 4889 * cl cmlb handle 4890 * 4891 * tg_cookie cookie from target driver to be passed back to target 4892 * driver when we call back to it through tg_ops. 4893 * 4894 * 4895 * Return Code: the code returned by cmlb_send_scsi_cmd() 4896 * 0 4897 * EINVAL 4898 * ENXIO 4899 * ENOMEM 4900 */ 4901 static int 4902 cmlb_write_label(struct cmlb_lun *cl, void *tg_cookie) 4903 { 4904 struct dk_label *dkl; 4905 short sum; 4906 short *sp; 4907 int i; 4908 int rval; 4909 4910 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 4911 mutex_exit(CMLB_MUTEX(cl)); 4912 dkl = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP); 4913 mutex_enter(CMLB_MUTEX(cl)); 4914 4915 bcopy(&cl->cl_vtoc, &dkl->dkl_vtoc, sizeof (struct dk_vtoc)); 4916 dkl->dkl_rpm = cl->cl_g.dkg_rpm; 4917 dkl->dkl_pcyl = cl->cl_g.dkg_pcyl; 4918 dkl->dkl_apc = cl->cl_g.dkg_apc; 4919 dkl->dkl_intrlv = cl->cl_g.dkg_intrlv; 4920 dkl->dkl_ncyl = cl->cl_g.dkg_ncyl; 4921 dkl->dkl_acyl = cl->cl_g.dkg_acyl; 4922 dkl->dkl_nhead = cl->cl_g.dkg_nhead; 4923 dkl->dkl_nsect = cl->cl_g.dkg_nsect; 4924 4925 #if defined(_SUNOS_VTOC_8) 4926 dkl->dkl_obs1 = cl->cl_g.dkg_obs1; 4927 dkl->dkl_obs2 = cl->cl_g.dkg_obs2; 4928 dkl->dkl_obs3 = cl->cl_g.dkg_obs3; 4929 for (i = 0; i < NDKMAP; i++) { 4930 dkl->dkl_map[i].dkl_cylno = cl->cl_map[i].dkl_cylno; 4931 dkl->dkl_map[i].dkl_nblk = cl->cl_map[i].dkl_nblk; 4932 } 4933 bcopy(cl->cl_asciilabel, dkl->dkl_asciilabel, LEN_DKL_ASCII); 4934 #elif defined(_SUNOS_VTOC_16) 4935 dkl->dkl_skew = cl->cl_dkg_skew; 4936 #else 4937 #error "No VTOC format defined." 4938 #endif 4939 4940 dkl->dkl_magic = DKL_MAGIC; 4941 dkl->dkl_write_reinstruct = cl->cl_g.dkg_write_reinstruct; 4942 dkl->dkl_read_reinstruct = cl->cl_g.dkg_read_reinstruct; 4943 4944 /* Construct checksum for the new disk label */ 4945 sum = 0; 4946 sp = (short *)dkl; 4947 i = sizeof (struct dk_label) / sizeof (short); 4948 while (i--) { 4949 sum ^= *sp++; 4950 } 4951 dkl->dkl_cksum = sum; 4952 4953 mutex_exit(CMLB_MUTEX(cl)); 4954 4955 rval = cmlb_set_vtoc(cl, dkl, tg_cookie); 4956 exit: 4957 kmem_free(dkl, cl->cl_sys_blocksize); 4958 mutex_enter(CMLB_MUTEX(cl)); 4959 return (rval); 4960 } 4961 4962 /* 4963 * This routine implements the DKIOCSETEFI ioctl. This ioctl is currently 4964 * used to write (or clear) the GPT Partition Table header (primary/backup) 4965 * and GUID partition Entry Array (primary/backup). It is also used to write 4966 * the Protective MBR. 4967 */ 4968 static int 4969 cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag, 4970 void *tg_cookie) 4971 { 4972 dk_efi_t user_efi; 4973 int shift, rval = 0; 4974 void *buffer; 4975 diskaddr_t tgt_lba; 4976 boolean_t internal; 4977 4978 if (ddi_copyin(arg, &user_efi, sizeof (dk_efi_t), flag)) 4979 return (EFAULT); 4980 4981 internal = VOID2BOOLEAN( 4982 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0); 4983 4984 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) 4985 shift = CMLBUNIT_FORCE_P0_SHIFT; 4986 else 4987 shift = CMLBUNIT_SHIFT; 4988 4989 user_efi.dki_data = (void *)(uintptr_t)user_efi.dki_data_64; 4990 4991 if (user_efi.dki_length == 0 || 4992 user_efi.dki_length > cmlb_tg_max_efi_xfer) 4993 return (EINVAL); 4994 4995 tgt_lba = user_efi.dki_lba; 4996 4997 mutex_enter(CMLB_MUTEX(cl)); 4998 if ((cmlb_check_update_blockcount(cl, tg_cookie) != 0) || 4999 (cl->cl_tgt_blocksize == 0) || 5000 (user_efi.dki_length % cl->cl_sys_blocksize)) { 5001 mutex_exit(CMLB_MUTEX(cl)); 5002 return (EINVAL); 5003 } 5004 if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) 5005 tgt_lba = tgt_lba * 5006 cl->cl_tgt_blocksize / cl->cl_sys_blocksize; 5007 mutex_exit(CMLB_MUTEX(cl)); 5008 5009 buffer = kmem_alloc(user_efi.dki_length, KM_SLEEP); 5010 if (ddi_copyin(user_efi.dki_data, buffer, user_efi.dki_length, flag)) { 5011 rval = EFAULT; 5012 } else { 5013 /* 5014 * let's clear the vtoc labels and clear the softstate 5015 * vtoc. 5016 */ 5017 mutex_enter(CMLB_MUTEX(cl)); 5018 if (cl->cl_vtoc.v_sanity == VTOC_SANE) { 5019 cmlb_dbg(CMLB_TRACE, cl, 5020 "cmlb_dkio_set_efi: CLEAR VTOC\n"); 5021 if (cl->cl_label_from_media == CMLB_LABEL_VTOC) 5022 cmlb_clear_vtoc(cl, tg_cookie); 5023 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc)); 5024 mutex_exit(CMLB_MUTEX(cl)); 5025 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h"); 5026 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw"); 5027 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd", 5028 S_IFBLK, 5029 (CMLBUNIT(dev, shift) << shift) | WD_NODE, 5030 cl->cl_node_type, 0, internal); 5031 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd,raw", 5032 S_IFCHR, 5033 (CMLBUNIT(dev, shift) << shift) | WD_NODE, 5034 cl->cl_node_type, 0, internal); 5035 } else 5036 mutex_exit(CMLB_MUTEX(cl)); 5037 5038 rval = DK_TG_WRITE(cl, buffer, tgt_lba, user_efi.dki_length, 5039 tg_cookie); 5040 5041 if (rval == 0) { 5042 mutex_enter(CMLB_MUTEX(cl)); 5043 cl->cl_f_geometry_is_valid = B_FALSE; 5044 mutex_exit(CMLB_MUTEX(cl)); 5045 } 5046 } 5047 kmem_free(buffer, user_efi.dki_length); 5048 return (rval); 5049 } 5050 5051 /* 5052 * Function: cmlb_dkio_get_mboot 5053 * 5054 * Description: This routine is the driver entry point for handling user 5055 * requests to get the current device mboot (DKIOCGMBOOT) 5056 * 5057 * Arguments: 5058 * arg pointer to user provided mboot structure specifying 5059 * the current mboot. 5060 * 5061 * flag this argument is a pass through to ddi_copyxxx() 5062 * directly from the mode argument of ioctl(). 5063 * 5064 * tg_cookie cookie from target driver to be passed back to target 5065 * driver when we call back to it through tg_ops. 5066 * 5067 * Return Code: 0 5068 * EINVAL 5069 * EFAULT 5070 * ENXIO 5071 */ 5072 static int 5073 cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie) 5074 { 5075 struct mboot *mboot; 5076 int rval; 5077 size_t buffer_size; 5078 5079 5080 #if defined(_SUNOS_VTOC_8) 5081 if ((!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) || (arg == NULL)) { 5082 #elif defined(_SUNOS_VTOC_16) 5083 if (arg == NULL) { 5084 #endif 5085 return (EINVAL); 5086 } 5087 5088 /* 5089 * Read the mboot block, located at absolute block 0 on the target. 5090 */ 5091 buffer_size = cl->cl_sys_blocksize; 5092 5093 cmlb_dbg(CMLB_TRACE, cl, 5094 "cmlb_dkio_get_mboot: allocation size: 0x%x\n", buffer_size); 5095 5096 mboot = kmem_zalloc(buffer_size, KM_SLEEP); 5097 if ((rval = DK_TG_READ(cl, mboot, 0, buffer_size, tg_cookie)) == 0) { 5098 if (ddi_copyout(mboot, (void *)arg, 5099 sizeof (struct mboot), flag) != 0) { 5100 rval = EFAULT; 5101 } 5102 } 5103 kmem_free(mboot, buffer_size); 5104 return (rval); 5105 } 5106 5107 5108 /* 5109 * Function: cmlb_dkio_set_mboot 5110 * 5111 * Description: This routine is the driver entry point for handling user 5112 * requests to validate and set the device master boot 5113 * (DKIOCSMBOOT). 5114 * 5115 * Arguments: 5116 * arg pointer to user provided mboot structure used to set the 5117 * master boot. 5118 * 5119 * flag this argument is a pass through to ddi_copyxxx() 5120 * directly from the mode argument of ioctl(). 5121 * 5122 * tg_cookie cookie from target driver to be passed back to target 5123 * driver when we call back to it through tg_ops. 5124 * 5125 * Return Code: 0 5126 * EINVAL 5127 * EFAULT 5128 * ENXIO 5129 */ 5130 static int 5131 cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie) 5132 { 5133 struct mboot *mboot = NULL; 5134 int rval; 5135 ushort_t magic; 5136 5137 5138 ASSERT(!mutex_owned(CMLB_MUTEX(cl))); 5139 5140 #if defined(_SUNOS_VTOC_8) 5141 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) { 5142 return (EINVAL); 5143 } 5144 #endif 5145 5146 if (arg == NULL) { 5147 return (EINVAL); 5148 } 5149 5150 mboot = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP); 5151 5152 if (ddi_copyin((const void *)arg, mboot, 5153 cl->cl_sys_blocksize, flag) != 0) { 5154 kmem_free(mboot, cl->cl_sys_blocksize); 5155 return (EFAULT); 5156 } 5157 5158 /* Is this really a master boot record? */ 5159 magic = LE_16(mboot->signature); 5160 if (magic != MBB_MAGIC) { 5161 kmem_free(mboot, cl->cl_sys_blocksize); 5162 return (EINVAL); 5163 } 5164 5165 rval = DK_TG_WRITE(cl, mboot, 0, cl->cl_sys_blocksize, tg_cookie); 5166 5167 mutex_enter(CMLB_MUTEX(cl)); 5168 #if defined(__i386) || defined(__amd64) 5169 if (rval == 0) { 5170 /* 5171 * mboot has been written successfully. 5172 * update the fdisk and vtoc tables in memory 5173 */ 5174 rval = cmlb_update_fdisk_and_vtoc(cl, tg_cookie); 5175 if ((!cl->cl_f_geometry_is_valid) || (rval != 0)) { 5176 mutex_exit(CMLB_MUTEX(cl)); 5177 kmem_free(mboot, cl->cl_sys_blocksize); 5178 return (rval); 5179 } 5180 } 5181 5182 #ifdef __lock_lint 5183 cmlb_setup_default_geometry(cl, tg_cookie); 5184 #endif 5185 5186 #else 5187 if (rval == 0) { 5188 /* 5189 * mboot has been written successfully. 5190 * set up the default geometry and VTOC 5191 */ 5192 if (cl->cl_blockcount <= CMLB_EXTVTOC_LIMIT) 5193 cmlb_setup_default_geometry(cl, tg_cookie); 5194 } 5195 #endif 5196 cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN; 5197 mutex_exit(CMLB_MUTEX(cl)); 5198 kmem_free(mboot, cl->cl_sys_blocksize); 5199 return (rval); 5200 } 5201 5202 5203 #if defined(__i386) || defined(__amd64) 5204 /*ARGSUSED*/ 5205 static int 5206 cmlb_dkio_set_ext_part(struct cmlb_lun *cl, caddr_t arg, int flag, 5207 void *tg_cookie) 5208 { 5209 int fdisk_rval; 5210 diskaddr_t capacity; 5211 5212 ASSERT(!mutex_owned(CMLB_MUTEX(cl))); 5213 5214 mutex_enter(CMLB_MUTEX(cl)); 5215 capacity = cl->cl_blockcount; 5216 fdisk_rval = cmlb_read_fdisk(cl, capacity, tg_cookie); 5217 if (fdisk_rval != 0) { 5218 mutex_exit(CMLB_MUTEX(cl)); 5219 return (fdisk_rval); 5220 } 5221 5222 mutex_exit(CMLB_MUTEX(cl)); 5223 return (fdisk_rval); 5224 } 5225 #endif 5226 5227 /* 5228 * Function: cmlb_setup_default_geometry 5229 * 5230 * Description: This local utility routine sets the default geometry as part of 5231 * setting the device mboot. 5232 * 5233 * Arguments: 5234 * cl driver soft state (unit) structure 5235 * 5236 * tg_cookie cookie from target driver to be passed back to target 5237 * driver when we call back to it through tg_ops. 5238 * 5239 * 5240 * Note: This may be redundant with cmlb_build_default_label. 5241 */ 5242 static void 5243 cmlb_setup_default_geometry(struct cmlb_lun *cl, void *tg_cookie) 5244 { 5245 struct cmlb_geom pgeom; 5246 struct cmlb_geom *pgeomp = &pgeom; 5247 int ret; 5248 int geom_base_cap = 1; 5249 5250 5251 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 5252 5253 /* zero out the soft state geometry and partition table. */ 5254 bzero(&cl->cl_g, sizeof (struct dk_geom)); 5255 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc)); 5256 bzero(cl->cl_map, NDKMAP * (sizeof (struct dk_map))); 5257 5258 /* 5259 * For the rpm, we use the minimum for the disk. 5260 * For the head, cyl and number of sector per track, 5261 * if the capacity <= 1GB, head = 64, sect = 32. 5262 * else head = 255, sect 63 5263 * Note: the capacity should be equal to C*H*S values. 5264 * This will cause some truncation of size due to 5265 * round off errors. For CD-ROMs, this truncation can 5266 * have adverse side effects, so returning ncyl and 5267 * nhead as 1. The nsect will overflow for most of 5268 * CD-ROMs as nsect is of type ushort. 5269 */ 5270 if (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) { 5271 /* 5272 * newfs currently can not handle 255 ntracks for SPARC 5273 * so get the geometry from target driver instead of coming up 5274 * with one based on capacity. 5275 */ 5276 mutex_exit(CMLB_MUTEX(cl)); 5277 ret = DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie); 5278 mutex_enter(CMLB_MUTEX(cl)); 5279 5280 if (ret == 0) { 5281 geom_base_cap = 0; 5282 } else { 5283 cmlb_dbg(CMLB_ERROR, cl, 5284 "cmlb_setup_default_geometry: " 5285 "tg_getphygeom failed %d\n", ret); 5286 5287 /* do default setting, geometry based on capacity */ 5288 } 5289 } 5290 5291 if (geom_base_cap) { 5292 if (ISCD(cl)) { 5293 cl->cl_g.dkg_ncyl = 1; 5294 cl->cl_g.dkg_nhead = 1; 5295 cl->cl_g.dkg_nsect = cl->cl_blockcount; 5296 } else if (cl->cl_blockcount < 160) { 5297 /* Less than 80K */ 5298 cl->cl_g.dkg_nhead = 1; 5299 cl->cl_g.dkg_ncyl = cl->cl_blockcount; 5300 cl->cl_g.dkg_nsect = 1; 5301 } else if (cl->cl_blockcount <= 0x1000) { 5302 /* Needed for unlabeled SCSI floppies. */ 5303 cl->cl_g.dkg_nhead = 2; 5304 cl->cl_g.dkg_ncyl = 80; 5305 cl->cl_g.dkg_pcyl = 80; 5306 cl->cl_g.dkg_nsect = cl->cl_blockcount / (2 * 80); 5307 } else if (cl->cl_blockcount <= 0x200000) { 5308 cl->cl_g.dkg_nhead = 64; 5309 cl->cl_g.dkg_nsect = 32; 5310 cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32); 5311 } else { 5312 cl->cl_g.dkg_nhead = 255; 5313 5314 cl->cl_g.dkg_nsect = ((cl->cl_blockcount + 5315 (UINT16_MAX * 255 * 63) - 1) / 5316 (UINT16_MAX * 255 * 63)) * 63; 5317 5318 if (cl->cl_g.dkg_nsect == 0) 5319 cl->cl_g.dkg_nsect = (UINT16_MAX / 63) * 63; 5320 5321 cl->cl_g.dkg_ncyl = cl->cl_blockcount / 5322 (255 * cl->cl_g.dkg_nsect); 5323 } 5324 5325 cl->cl_g.dkg_acyl = 0; 5326 cl->cl_g.dkg_bcyl = 0; 5327 cl->cl_g.dkg_intrlv = 1; 5328 cl->cl_g.dkg_rpm = 200; 5329 if (cl->cl_g.dkg_pcyl == 0) 5330 cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl + 5331 cl->cl_g.dkg_acyl; 5332 } else { 5333 cl->cl_g.dkg_ncyl = (short)pgeomp->g_ncyl; 5334 cl->cl_g.dkg_acyl = pgeomp->g_acyl; 5335 cl->cl_g.dkg_nhead = pgeomp->g_nhead; 5336 cl->cl_g.dkg_nsect = pgeomp->g_nsect; 5337 cl->cl_g.dkg_intrlv = pgeomp->g_intrlv; 5338 cl->cl_g.dkg_rpm = pgeomp->g_rpm; 5339 cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl; 5340 } 5341 5342 cl->cl_g.dkg_read_reinstruct = 0; 5343 cl->cl_g.dkg_write_reinstruct = 0; 5344 cl->cl_solaris_size = cl->cl_g.dkg_ncyl * 5345 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect; 5346 5347 cl->cl_map['a'-'a'].dkl_cylno = 0; 5348 cl->cl_map['a'-'a'].dkl_nblk = cl->cl_solaris_size; 5349 5350 cl->cl_map['c'-'a'].dkl_cylno = 0; 5351 cl->cl_map['c'-'a'].dkl_nblk = cl->cl_solaris_size; 5352 5353 cl->cl_vtoc.v_part[2].p_tag = V_BACKUP; 5354 cl->cl_vtoc.v_part[2].p_flag = V_UNMNT; 5355 cl->cl_vtoc.v_nparts = V_NUMPAR; 5356 cl->cl_vtoc.v_version = V_VERSION; 5357 (void) sprintf((char *)cl->cl_asciilabel, "DEFAULT cyl %d alt %d" 5358 " hd %d sec %d", cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl, 5359 cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect); 5360 5361 cl->cl_f_geometry_is_valid = B_FALSE; 5362 } 5363 5364 5365 #if defined(__i386) || defined(__amd64) 5366 /* 5367 * Function: cmlb_update_fdisk_and_vtoc 5368 * 5369 * Description: This local utility routine updates the device fdisk and vtoc 5370 * as part of setting the device mboot. 5371 * 5372 * Arguments: 5373 * cl driver soft state (unit) structure 5374 * 5375 * tg_cookie cookie from target driver to be passed back to target 5376 * driver when we call back to it through tg_ops. 5377 * 5378 * 5379 * Return Code: 0 for success or errno-type return code. 5380 * 5381 * Note:x86: This looks like a duplicate of cmlb_validate_geometry(), but 5382 * these did exist separately in x86 sd.c. 5383 */ 5384 static int 5385 cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie) 5386 { 5387 int count; 5388 int label_rc = 0; 5389 int fdisk_rval; 5390 diskaddr_t capacity; 5391 5392 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 5393 5394 if (cmlb_check_update_blockcount(cl, tg_cookie) != 0) 5395 return (EINVAL); 5396 5397 /* 5398 * Set up the "whole disk" fdisk partition; this should always 5399 * exist, regardless of whether the disk contains an fdisk table 5400 * or vtoc. 5401 */ 5402 cl->cl_map[P0_RAW_DISK].dkl_cylno = 0; 5403 cl->cl_map[P0_RAW_DISK].dkl_nblk = cl->cl_blockcount; 5404 5405 /* 5406 * copy the lbasize and capacity so that if they're 5407 * reset while we're not holding the CMLB_MUTEX(cl), we will 5408 * continue to use valid values after the CMLB_MUTEX(cl) is 5409 * reacquired. 5410 */ 5411 capacity = cl->cl_blockcount; 5412 5413 /* 5414 * refresh the logical and physical geometry caches. 5415 * (data from mode sense format/rigid disk geometry pages, 5416 * and scsi_ifgetcap("geometry"). 5417 */ 5418 cmlb_resync_geom_caches(cl, capacity, tg_cookie); 5419 5420 /* 5421 * Only DIRECT ACCESS devices will have Scl labels. 5422 * CD's supposedly have a Scl label, too 5423 */ 5424 if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) { 5425 fdisk_rval = cmlb_read_fdisk(cl, capacity, tg_cookie); 5426 if (fdisk_rval != 0) { 5427 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 5428 return (fdisk_rval); 5429 } 5430 5431 if (cl->cl_solaris_size <= DK_LABEL_LOC) { 5432 /* 5433 * Found fdisk table but no Solaris partition entry, 5434 * so don't call cmlb_uselabel() and don't create 5435 * a default label. 5436 */ 5437 label_rc = 0; 5438 cl->cl_f_geometry_is_valid = B_TRUE; 5439 goto no_solaris_partition; 5440 } 5441 } else if (capacity < 0) { 5442 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 5443 return (EINVAL); 5444 } 5445 5446 /* 5447 * For Removable media We reach here if we have found a 5448 * SOLARIS PARTITION. 5449 * If cl_f_geometry_is_valid is B_FALSE it indicates that the SOLARIS 5450 * PARTITION has changed from the previous one, hence we will setup a 5451 * default VTOC in this case. 5452 */ 5453 if (!cl->cl_f_geometry_is_valid) { 5454 /* if we get here it is writable */ 5455 /* we are called from SMBOOT, and after a write of fdisk */ 5456 cmlb_build_default_label(cl, tg_cookie); 5457 label_rc = 0; 5458 } 5459 5460 no_solaris_partition: 5461 5462 #if defined(_SUNOS_VTOC_16) 5463 /* 5464 * If we have valid geometry, set up the remaining fdisk partitions. 5465 * Note that dkl_cylno is not used for the fdisk map entries, so 5466 * we set it to an entirely bogus value. 5467 */ 5468 for (count = 0; count < FDISK_PARTS; count++) { 5469 cl->cl_map[FDISK_P1 + count].dkl_cylno = UINT32_MAX; 5470 cl->cl_map[FDISK_P1 + count].dkl_nblk = 5471 cl->cl_fmap[count].fmap_nblk; 5472 cl->cl_offset[FDISK_P1 + count] = 5473 cl->cl_fmap[count].fmap_start; 5474 } 5475 #endif 5476 5477 for (count = 0; count < NDKMAP; count++) { 5478 #if defined(_SUNOS_VTOC_8) 5479 struct dk_map *lp = &cl->cl_map[count]; 5480 cl->cl_offset[count] = 5481 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno; 5482 #elif defined(_SUNOS_VTOC_16) 5483 struct dkl_partition *vp = &cl->cl_vtoc.v_part[count]; 5484 cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset; 5485 #else 5486 #error "No VTOC format defined." 5487 #endif 5488 } 5489 5490 ASSERT(mutex_owned(CMLB_MUTEX(cl))); 5491 return (label_rc); 5492 } 5493 #endif 5494 5495 #if defined(__i386) || defined(__amd64) 5496 static int 5497 cmlb_dkio_get_virtgeom(struct cmlb_lun *cl, caddr_t arg, int flag) 5498 { 5499 int err = 0; 5500 5501 /* Return the driver's notion of the media's logical geometry */ 5502 struct dk_geom disk_geom; 5503 struct dk_geom *dkgp = &disk_geom; 5504 5505 mutex_enter(CMLB_MUTEX(cl)); 5506 /* 5507 * If there is no HBA geometry available, or 5508 * if the HBA returned us something that doesn't 5509 * really fit into an Int 13/function 8 geometry 5510 * result, just fail the ioctl. See PSARC 1998/313. 5511 */ 5512 if (cl->cl_lgeom.g_nhead == 0 || 5513 cl->cl_lgeom.g_nsect == 0 || 5514 cl->cl_lgeom.g_ncyl > 1024) { 5515 mutex_exit(CMLB_MUTEX(cl)); 5516 err = EINVAL; 5517 } else { 5518 dkgp->dkg_ncyl = cl->cl_lgeom.g_ncyl; 5519 dkgp->dkg_acyl = cl->cl_lgeom.g_acyl; 5520 dkgp->dkg_pcyl = dkgp->dkg_ncyl + dkgp->dkg_acyl; 5521 dkgp->dkg_nhead = cl->cl_lgeom.g_nhead; 5522 dkgp->dkg_nsect = cl->cl_lgeom.g_nsect; 5523 5524 mutex_exit(CMLB_MUTEX(cl)); 5525 if (ddi_copyout(dkgp, (void *)arg, 5526 sizeof (struct dk_geom), flag)) { 5527 err = EFAULT; 5528 } else { 5529 err = 0; 5530 } 5531 } 5532 return (err); 5533 } 5534 #endif 5535 5536 #if defined(__i386) || defined(__amd64) 5537 static int 5538 cmlb_dkio_get_phygeom(struct cmlb_lun *cl, caddr_t arg, int flag, 5539 void *tg_cookie) 5540 { 5541 int err = 0; 5542 diskaddr_t capacity; 5543 5544 5545 /* Return the driver's notion of the media physical geometry */ 5546 struct dk_geom disk_geom; 5547 struct dk_geom *dkgp = &disk_geom; 5548 5549 mutex_enter(CMLB_MUTEX(cl)); 5550 5551 if (cl->cl_g.dkg_nhead != 0 && 5552 cl->cl_g.dkg_nsect != 0) { 5553 /* 5554 * We succeeded in getting a geometry, but 5555 * right now it is being reported as just the 5556 * Solaris fdisk partition, just like for 5557 * DKIOCGGEOM. We need to change that to be 5558 * correct for the entire disk now. 5559 */ 5560 bcopy(&cl->cl_g, dkgp, sizeof (*dkgp)); 5561 dkgp->dkg_acyl = 0; 5562 dkgp->dkg_ncyl = cl->cl_blockcount / 5563 (dkgp->dkg_nhead * dkgp->dkg_nsect); 5564 } else { 5565 bzero(dkgp, sizeof (struct dk_geom)); 5566 /* 5567 * This disk does not have a Solaris VTOC 5568 * so we must present a physical geometry 5569 * that will remain consistent regardless 5570 * of how the disk is used. This will ensure 5571 * that the geometry does not change regardless 5572 * of the fdisk partition type (ie. EFI, FAT32, 5573 * Solaris, etc). 5574 */ 5575 if (ISCD(cl)) { 5576 dkgp->dkg_nhead = cl->cl_pgeom.g_nhead; 5577 dkgp->dkg_nsect = cl->cl_pgeom.g_nsect; 5578 dkgp->dkg_ncyl = cl->cl_pgeom.g_ncyl; 5579 dkgp->dkg_acyl = cl->cl_pgeom.g_acyl; 5580 } else { 5581 /* 5582 * Invalid cl_blockcount can generate invalid 5583 * dk_geom and may result in division by zero 5584 * system failure. Should make sure blockcount 5585 * is valid before using it here. 5586 */ 5587 if (cl->cl_blockcount == 0) { 5588 mutex_exit(CMLB_MUTEX(cl)); 5589 err = EIO; 5590 return (err); 5591 } 5592 /* 5593 * Refer to comments related to off-by-1 at the 5594 * header of this file 5595 */ 5596 if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE) 5597 capacity = cl->cl_blockcount - 1; 5598 else 5599 capacity = cl->cl_blockcount; 5600 5601 cmlb_convert_geometry(cl, capacity, dkgp, tg_cookie); 5602 dkgp->dkg_acyl = 0; 5603 dkgp->dkg_ncyl = capacity / 5604 (dkgp->dkg_nhead * dkgp->dkg_nsect); 5605 } 5606 } 5607 dkgp->dkg_pcyl = dkgp->dkg_ncyl + dkgp->dkg_acyl; 5608 5609 mutex_exit(CMLB_MUTEX(cl)); 5610 if (ddi_copyout(dkgp, (void *)arg, sizeof (struct dk_geom), flag)) 5611 err = EFAULT; 5612 5613 return (err); 5614 } 5615 #endif 5616 5617 #if defined(__i386) || defined(__amd64) 5618 static int 5619 cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag) 5620 { 5621 int err = 0; 5622 5623 /* 5624 * Return parameters describing the selected disk slice. 5625 * Note: this ioctl is for the intel platform only 5626 */ 5627 int part; 5628 5629 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) 5630 part = getminor(dev) & ((1 << CMLBUNIT_FORCE_P0_SHIFT) - 1); 5631 else 5632 part = CMLBPART(dev); 5633 5634 mutex_enter(CMLB_MUTEX(cl)); 5635 /* don't check cl_solaris_size for pN */ 5636 if (part < P0_RAW_DISK && cl->cl_solaris_size == 0) { 5637 err = EIO; 5638 mutex_exit(CMLB_MUTEX(cl)); 5639 } else { 5640 struct part_info p; 5641 5642 p.p_start = (daddr_t)cl->cl_offset[part]; 5643 p.p_length = (int)cl->cl_map[part].dkl_nblk; 5644 mutex_exit(CMLB_MUTEX(cl)); 5645 #ifdef _MULTI_DATAMODEL 5646 switch (ddi_model_convert_from(flag & FMODELS)) { 5647 case DDI_MODEL_ILP32: 5648 { 5649 struct part_info32 p32; 5650 5651 p32.p_start = (daddr32_t)p.p_start; 5652 p32.p_length = p.p_length; 5653 if (ddi_copyout(&p32, (void *)arg, 5654 sizeof (p32), flag)) 5655 err = EFAULT; 5656 break; 5657 } 5658 5659 case DDI_MODEL_NONE: 5660 { 5661 if (ddi_copyout(&p, (void *)arg, sizeof (p), 5662 flag)) 5663 err = EFAULT; 5664 break; 5665 } 5666 } 5667 #else /* ! _MULTI_DATAMODEL */ 5668 if (ddi_copyout(&p, (void *)arg, sizeof (p), flag)) 5669 err = EFAULT; 5670 #endif /* _MULTI_DATAMODEL */ 5671 } 5672 return (err); 5673 } 5674 static int 5675 cmlb_dkio_extpartinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag) 5676 { 5677 int err = 0; 5678 5679 /* 5680 * Return parameters describing the selected disk slice. 5681 * Note: this ioctl is for the intel platform only 5682 */ 5683 int part; 5684 5685 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) 5686 part = getminor(dev) & ((1 << CMLBUNIT_FORCE_P0_SHIFT) - 1); 5687 else 5688 part = CMLBPART(dev); 5689 5690 mutex_enter(CMLB_MUTEX(cl)); 5691 /* don't check cl_solaris_size for pN */ 5692 if (part < P0_RAW_DISK && cl->cl_solaris_size == 0) { 5693 err = EIO; 5694 mutex_exit(CMLB_MUTEX(cl)); 5695 } else { 5696 struct extpart_info p; 5697 5698 p.p_start = (diskaddr_t)cl->cl_offset[part]; 5699 p.p_length = (diskaddr_t)cl->cl_map[part].dkl_nblk; 5700 mutex_exit(CMLB_MUTEX(cl)); 5701 if (ddi_copyout(&p, (void *)arg, sizeof (p), flag)) 5702 err = EFAULT; 5703 } 5704 return (err); 5705 } 5706 #endif 5707 5708 int 5709 cmlb_prop_op(cmlb_handle_t cmlbhandle, 5710 dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags, 5711 char *name, caddr_t valuep, int *lengthp, int part, void *tg_cookie) 5712 { 5713 struct cmlb_lun *cl; 5714 diskaddr_t capacity; 5715 uint32_t lbasize; 5716 enum dp { DP_NBLOCKS, DP_BLKSIZE, DP_SSD, DP_ROT } dp; 5717 int callers_length; 5718 caddr_t buffer; 5719 uint64_t nblocks64; 5720 uint_t dblk; 5721 tg_attribute_t tgattr; 5722 5723 /* Always fallback to ddi_prop_op... */ 5724 cl = (struct cmlb_lun *)cmlbhandle; 5725 if (cl == NULL) { 5726 fallback: return (ddi_prop_op(dev, dip, prop_op, mod_flags, 5727 name, valuep, lengthp)); 5728 } 5729 5730 /* Pick up capacity and blocksize information. */ 5731 capacity = cl->cl_blockcount; 5732 if (capacity == 0) 5733 goto fallback; 5734 lbasize = cl->cl_tgt_blocksize; 5735 if (lbasize == 0) 5736 lbasize = DEV_BSIZE; /* 0 -> DEV_BSIZE units */ 5737 5738 /* Check for dynamic property of whole device. */ 5739 if (dev == DDI_DEV_T_ANY) { 5740 /* Fallback to ddi_prop_op if we don't understand. */ 5741 if (strcmp(name, "device-nblocks") == 0) 5742 dp = DP_NBLOCKS; 5743 else if (strcmp(name, "device-blksize") == 0) 5744 dp = DP_BLKSIZE; 5745 else if (strcmp(name, "device-solid-state") == 0) 5746 dp = DP_SSD; 5747 else if (strcmp(name, "device-rotational") == 0) 5748 dp = DP_ROT; 5749 else 5750 goto fallback; 5751 5752 /* get callers length, establish length of our dynamic prop */ 5753 callers_length = *lengthp; 5754 if (dp == DP_NBLOCKS) 5755 *lengthp = sizeof (uint64_t); 5756 else if ((dp == DP_BLKSIZE) || (dp == DP_SSD)) 5757 *lengthp = sizeof (uint32_t); 5758 5759 /* service request for the length of the property */ 5760 if (prop_op == PROP_LEN) 5761 return (DDI_PROP_SUCCESS); 5762 5763 switch (prop_op) { 5764 case PROP_LEN_AND_VAL_ALLOC: 5765 if ((buffer = kmem_alloc(*lengthp, 5766 (mod_flags & DDI_PROP_CANSLEEP) ? 5767 KM_SLEEP : KM_NOSLEEP)) == NULL) 5768 return (DDI_PROP_NO_MEMORY); 5769 *(caddr_t *)valuep = buffer; /* set callers buf */ 5770 break; 5771 5772 case PROP_LEN_AND_VAL_BUF: 5773 /* the length of the prop and the request must match */ 5774 if (callers_length != *lengthp) 5775 return (DDI_PROP_INVAL_ARG); 5776 buffer = valuep; /* get callers buf */ 5777 break; 5778 5779 default: 5780 return (DDI_PROP_INVAL_ARG); 5781 } 5782 5783 /* transfer the value into the buffer */ 5784 switch (dp) { 5785 case DP_NBLOCKS: 5786 *((uint64_t *)buffer) = capacity; 5787 break; 5788 case DP_BLKSIZE: 5789 *((uint32_t *)buffer) = lbasize; 5790 break; 5791 case DP_SSD: 5792 if (DK_TG_GETATTRIBUTE(cl, &tgattr, tg_cookie) != 0) 5793 tgattr.media_is_solid_state = B_FALSE; 5794 *((uint32_t *)buffer) = 5795 tgattr.media_is_solid_state ? 1 : 0; 5796 break; 5797 case DP_ROT: 5798 if (DK_TG_GETATTRIBUTE(cl, &tgattr, tg_cookie) != 0) 5799 tgattr.media_is_rotational = B_TRUE; 5800 *((uint32_t *)buffer) = 5801 tgattr.media_is_rotational ? 1 : 0; 5802 break; 5803 } 5804 return (DDI_PROP_SUCCESS); 5805 } 5806 5807 /* 5808 * Support dynamic size oriented properties of partition. Requests 5809 * issued under conditions where size is valid are passed to 5810 * ddi_prop_op_nblocks with the size information, otherwise the 5811 * request is passed to ddi_prop_op. Size depends on valid geometry. 5812 */ 5813 if (!cmlb_is_valid(cmlbhandle)) 5814 goto fallback; 5815 5816 /* Get partition nblocks value. */ 5817 (void) cmlb_partinfo(cmlbhandle, part, 5818 (diskaddr_t *)&nblocks64, NULL, NULL, NULL, tg_cookie); 5819 5820 /* 5821 * Assume partition information is in sys_blocksize units, compute 5822 * divisor for size(9P) property representation. 5823 */ 5824 dblk = lbasize / cl->cl_sys_blocksize; 5825 5826 /* Now let ddi_prop_op_nblocks_blksize() handle the request. */ 5827 return (ddi_prop_op_nblocks_blksize(dev, dip, prop_op, mod_flags, 5828 name, valuep, lengthp, nblocks64 / dblk, lbasize)); 5829 } 5830