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