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 }