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