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 (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25 
  26 /*
  27  * Virtual disk server
  28  */
  29 
  30 
  31 #include <sys/types.h>
  32 #include <sys/conf.h>
  33 #include <sys/crc32.h>
  34 #include <sys/ddi.h>
  35 #include <sys/dkio.h>
  36 #include <sys/file.h>
  37 #include <sys/fs/hsfs_isospec.h>
  38 #include <sys/mdeg.h>
  39 #include <sys/mhd.h>
  40 #include <sys/modhash.h>
  41 #include <sys/note.h>
  42 #include <sys/pathname.h>
  43 #include <sys/sdt.h>
  44 #include <sys/sunddi.h>
  45 #include <sys/sunldi.h>
  46 #include <sys/sysmacros.h>
  47 #include <sys/vio_common.h>
  48 #include <sys/vio_util.h>
  49 #include <sys/vdsk_mailbox.h>
  50 #include <sys/vdsk_common.h>
  51 #include <sys/vtoc.h>
  52 #include <sys/vfs.h>
  53 #include <sys/stat.h>
  54 #include <sys/scsi/impl/uscsi.h>
  55 #include <sys/ontrap.h>
  56 #include <vm/seg_map.h>
  57 
  58 #define ONE_MEGABYTE    (1ULL << 20)
  59 #define ONE_GIGABYTE    (1ULL << 30)
  60 #define ONE_TERABYTE    (1ULL << 40)
  61 
  62 /* Virtual disk server initialization flags */
  63 #define VDS_LDI                 0x01
  64 #define VDS_MDEG                0x02
  65 
  66 /* Virtual disk server tunable parameters */
  67 #define VDS_RETRIES             5
  68 #define VDS_LDC_DELAY           1000 /* 1 msecs */
  69 #define VDS_DEV_DELAY           10000000 /* 10 secs */
  70 #define VDS_NCHAINS             32
  71 
  72 /* Identification parameters for MD, synthetic dkio(7i) structures, etc. */
  73 #define VDS_NAME                "virtual-disk-server"
  74 
  75 #define VD_NAME                 "vd"
  76 #define VD_VOLUME_NAME          "vdisk"
  77 #define VD_ASCIILABEL           "Virtual Disk"
  78 
  79 #define VD_CHANNEL_ENDPOINT     "channel-endpoint"
  80 #define VD_ID_PROP              "id"
  81 #define VD_BLOCK_DEVICE_PROP    "vds-block-device"
  82 #define VD_BLOCK_DEVICE_OPTS    "vds-block-device-opts"
  83 #define VD_REG_PROP             "reg"
  84 
  85 /* Virtual disk initialization flags */
  86 #define VD_DISK_READY           0x01
  87 #define VD_LOCKING              0x02
  88 #define VD_LDC                  0x04
  89 #define VD_DRING                0x08
  90 #define VD_SID                  0x10
  91 #define VD_SEQ_NUM              0x20
  92 #define VD_SETUP_ERROR          0x40
  93 
  94 /* Number of backup labels */
  95 #define VD_DSKIMG_NUM_BACKUP    5
  96 
  97 /* Timeout for SCSI I/O */
  98 #define VD_SCSI_RDWR_TIMEOUT    30      /* 30 secs */
  99 
 100 /*
 101  * Default number of threads for the I/O queue. In many cases, we will not
 102  * receive more than 8 I/O requests at the same time. However there are
 103  * cases (for example during the OS installation) where we can have a lot
 104  * more (up to the limit of the DRing size).
 105  */
 106 #define VD_IOQ_NTHREADS         8
 107 
 108 /* Maximum number of logical partitions */
 109 #define VD_MAXPART      (NDKMAP + 1)
 110 
 111 /*
 112  * By Solaris convention, slice/partition 2 represents the entire disk;
 113  * unfortunately, this convention does not appear to be codified.
 114  */
 115 #define VD_ENTIRE_DISK_SLICE    2
 116 
 117 /* Logical block address for EFI */
 118 #define VD_EFI_LBA_GPT          1       /* LBA of the GPT */
 119 #define VD_EFI_LBA_GPE          2       /* LBA of the GPE */
 120 
 121 #define VD_EFI_DEV_SET(dev, vdsk, ioctl)        \
 122         VDSK_EFI_DEV_SET(dev, vdsk, ioctl,      \
 123             (vdsk)->vdisk_bsize, (vdsk)->vdisk_size)
 124 
 125 /*
 126  * Flags defining the behavior for flushing asynchronous writes used to
 127  * performed some write I/O requests.
 128  *
 129  * The VD_AWFLUSH_IMMEDIATE enables immediate flushing of asynchronous
 130  * writes. This ensures that data are committed to the backend when the I/O
 131  * request reply is sent to the guest domain so this prevents any data to
 132  * be lost in case a service domain unexpectedly crashes.
 133  *
 134  * The flag VD_AWFLUSH_DEFER indicates that flushing is deferred to another
 135  * thread while the request is immediatly marked as completed. In that case,
 136  * a guest domain can a receive a reply that its write request is completed
 137  * while data haven't been flushed to disk yet.
 138  *
 139  * Flags VD_AWFLUSH_IMMEDIATE and VD_AWFLUSH_DEFER are mutually exclusive.
 140  */
 141 #define VD_AWFLUSH_IMMEDIATE    0x01    /* immediate flushing */
 142 #define VD_AWFLUSH_DEFER        0x02    /* defer flushing */
 143 #define VD_AWFLUSH_GROUP        0x04    /* group requests before flushing */
 144 
 145 /* Driver types */
 146 typedef enum vd_driver {
 147         VD_DRIVER_UNKNOWN = 0,  /* driver type unknown  */
 148         VD_DRIVER_DISK,         /* disk driver */
 149         VD_DRIVER_VOLUME        /* volume driver */
 150 } vd_driver_t;
 151 
 152 #define VD_DRIVER_NAME_LEN      64
 153 
 154 #define VDS_NUM_DRIVERS (sizeof (vds_driver_types) / sizeof (vd_driver_type_t))
 155 
 156 typedef struct vd_driver_type {
 157         char name[VD_DRIVER_NAME_LEN];  /* driver name */
 158         vd_driver_t type;               /* driver type (disk or volume) */
 159 } vd_driver_type_t;
 160 
 161 /*
 162  * There is no reliable way to determine if a device is representing a disk
 163  * or a volume, especially with pseudo devices. So we maintain a list of well
 164  * known drivers and the type of device they represent (either a disk or a
 165  * volume).
 166  *
 167  * The list can be extended by adding a "driver-type-list" entry in vds.conf
 168  * with the following syntax:
 169  *
 170  *      driver-type-list="<driver>:<type>", ... ,"<driver>:<type>";
 171  *
 172  * Where:
 173  *      <driver> is the name of a driver (limited to 64 characters)
 174  *      <type> is either the string "disk" or "volume"
 175  *
 176  * Invalid entries in "driver-type-list" will be ignored.
 177  *
 178  * For example, the following line in vds.conf:
 179  *
 180  *      driver-type-list="foo:disk","bar:volume";
 181  *
 182  * defines that "foo" is a disk driver, and driver "bar" is a volume driver.
 183  *
 184  * When a list is defined in vds.conf, it is checked before the built-in list
 185  * (vds_driver_types[]) so that any definition from this list can be overriden
 186  * using vds.conf.
 187  */
 188 vd_driver_type_t vds_driver_types[] = {
 189         { "dad",        VD_DRIVER_DISK },       /* Solaris */
 190         { "did",        VD_DRIVER_DISK },       /* Sun Cluster */
 191         { "dlmfdrv",    VD_DRIVER_DISK },       /* Hitachi HDLM */
 192         { "emcp",       VD_DRIVER_DISK },       /* EMC Powerpath */
 193         { "lofi",       VD_DRIVER_VOLUME },     /* Solaris */
 194         { "md",         VD_DRIVER_VOLUME },     /* Solaris - SVM */
 195         { "sd",         VD_DRIVER_DISK },       /* Solaris */
 196         { "ssd",        VD_DRIVER_DISK },       /* Solaris */
 197         { "vdc",        VD_DRIVER_DISK },       /* Solaris */
 198         { "vxdmp",      VD_DRIVER_DISK },       /* Veritas */
 199         { "vxio",       VD_DRIVER_VOLUME },     /* Veritas - VxVM */
 200         { "zfs",        VD_DRIVER_VOLUME }      /* Solaris */
 201 };
 202 
 203 /* Return a cpp token as a string */
 204 #define STRINGIZE(token)        #token
 205 
 206 /*
 207  * Print a message prefixed with the current function name to the message log
 208  * (and optionally to the console for verbose boots); these macros use cpp's
 209  * concatenation of string literals and C99 variable-length-argument-list
 210  * macros
 211  */
 212 #define PRN(...)        _PRN("?%s():  "__VA_ARGS__, "")
 213 #define _PRN(format, ...)                                       \
 214         cmn_err(CE_CONT, format"%s", __func__, __VA_ARGS__)
 215 
 216 /* Return a pointer to the "i"th vdisk dring element */
 217 #define VD_DRING_ELEM(i)        ((vd_dring_entry_t *)(void *)   \
 218             (vd->dring + (i)*vd->descriptor_size))
 219 
 220 /* Return the virtual disk client's type as a string (for use in messages) */
 221 #define VD_CLIENT(vd)                                                   \
 222         (((vd)->xfer_mode == VIO_DESC_MODE) ? "in-band client" :     \
 223             (((vd)->xfer_mode == VIO_DRING_MODE_V1_0) ? "dring client" :    \
 224                 (((vd)->xfer_mode == 0) ? "null client" :            \
 225                     "unsupported client")))
 226 
 227 /* Read disk label from a disk image */
 228 #define VD_DSKIMG_LABEL_READ(vd, labelp) \
 229         vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BREAD, (caddr_t)labelp, \
 230             0, sizeof (struct dk_label))
 231 
 232 /* Write disk label to a disk image */
 233 #define VD_DSKIMG_LABEL_WRITE(vd, labelp)       \
 234         vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BWRITE, (caddr_t)labelp, \
 235             0, sizeof (struct dk_label))
 236 
 237 /* Identify if a backend is a disk image */
 238 #define VD_DSKIMG(vd)   ((vd)->vdisk_type == VD_DISK_TYPE_DISK &&    \
 239         ((vd)->file || (vd)->volume))
 240 
 241 /* Next index in a write queue */
 242 #define VD_WRITE_INDEX_NEXT(vd, id)             \
 243         ((((id) + 1) >= vd->dring_len)? 0 : (id) + 1)
 244 
 245 /* Message for disk access rights reset failure */
 246 #define VD_RESET_ACCESS_FAILURE_MSG \
 247         "Fail to reset disk access rights for disk %s"
 248 
 249 /*
 250  * Specification of an MD node passed to the MDEG to filter any
 251  * 'vport' nodes that do not belong to the specified node. This
 252  * template is copied for each vds instance and filled in with
 253  * the appropriate 'cfg-handle' value before being passed to the MDEG.
 254  */
 255 static mdeg_prop_spec_t vds_prop_template[] = {
 256         { MDET_PROP_STR,        "name",         VDS_NAME },
 257         { MDET_PROP_VAL,        "cfg-handle",   NULL },
 258         { MDET_LIST_END,        NULL,           NULL }
 259 };
 260 
 261 #define VDS_SET_MDEG_PROP_INST(specp, val) (specp)[1].ps_val = (val);
 262 
 263 /*
 264  * Matching criteria passed to the MDEG to register interest
 265  * in changes to 'virtual-device-port' nodes identified by their
 266  * 'id' property.
 267  */
 268 static md_prop_match_t  vd_prop_match[] = {
 269         { MDET_PROP_VAL,        VD_ID_PROP },
 270         { MDET_LIST_END,        NULL }
 271 };
 272 
 273 static mdeg_node_match_t vd_match = {"virtual-device-port",
 274                                     vd_prop_match};
 275 
 276 /*
 277  * Options for the VD_BLOCK_DEVICE_OPTS property.
 278  */
 279 #define VD_OPT_RDONLY           0x1     /* read-only  */
 280 #define VD_OPT_SLICE            0x2     /* single slice */
 281 #define VD_OPT_EXCLUSIVE        0x4     /* exclusive access */
 282 
 283 #define VD_OPTION_NLEN  128
 284 
 285 typedef struct vd_option {
 286         char vdo_name[VD_OPTION_NLEN];
 287         uint64_t vdo_value;
 288 } vd_option_t;
 289 
 290 vd_option_t vd_bdev_options[] = {
 291         { "ro",         VD_OPT_RDONLY },
 292         { "slice",      VD_OPT_SLICE },
 293         { "excl",       VD_OPT_EXCLUSIVE }
 294 };
 295 
 296 /* Debugging macros */
 297 #ifdef DEBUG
 298 
 299 static int      vd_msglevel = 0;
 300 
 301 #define PR0 if (vd_msglevel > 0)     PRN
 302 #define PR1 if (vd_msglevel > 1)     PRN
 303 #define PR2 if (vd_msglevel > 2)     PRN
 304 
 305 #define VD_DUMP_DRING_ELEM(elem)                                        \
 306         PR0("dst:%x op:%x st:%u nb:%lx addr:%lx ncook:%u\n",            \
 307             elem->hdr.dstate,                                                \
 308             elem->payload.operation,                                 \
 309             elem->payload.status,                                    \
 310             elem->payload.nbytes,                                    \
 311             elem->payload.addr,                                              \
 312             elem->payload.ncookies);
 313 
 314 char *
 315 vd_decode_state(int state)
 316 {
 317         char *str;
 318 
 319 #define CASE_STATE(_s)  case _s: str = #_s; break;
 320 
 321         switch (state) {
 322         CASE_STATE(VD_STATE_INIT)
 323         CASE_STATE(VD_STATE_VER)
 324         CASE_STATE(VD_STATE_ATTR)
 325         CASE_STATE(VD_STATE_DRING)
 326         CASE_STATE(VD_STATE_RDX)
 327         CASE_STATE(VD_STATE_DATA)
 328         default: str = "unknown"; break;
 329         }
 330 
 331 #undef CASE_STATE
 332 
 333         return (str);
 334 }
 335 
 336 void
 337 vd_decode_tag(vio_msg_t *msg)
 338 {
 339         char *tstr, *sstr, *estr;
 340 
 341 #define CASE_TYPE(_s)   case _s: tstr = #_s; break;
 342 
 343         switch (msg->tag.vio_msgtype) {
 344         CASE_TYPE(VIO_TYPE_CTRL)
 345         CASE_TYPE(VIO_TYPE_DATA)
 346         CASE_TYPE(VIO_TYPE_ERR)
 347         default: tstr = "unknown"; break;
 348         }
 349 
 350 #undef CASE_TYPE
 351 
 352 #define CASE_SUBTYPE(_s) case _s: sstr = #_s; break;
 353 
 354         switch (msg->tag.vio_subtype) {
 355         CASE_SUBTYPE(VIO_SUBTYPE_INFO)
 356         CASE_SUBTYPE(VIO_SUBTYPE_ACK)
 357         CASE_SUBTYPE(VIO_SUBTYPE_NACK)
 358         default: sstr = "unknown"; break;
 359         }
 360 
 361 #undef CASE_SUBTYPE
 362 
 363 #define CASE_ENV(_s)    case _s: estr = #_s; break;
 364 
 365         switch (msg->tag.vio_subtype_env) {
 366         CASE_ENV(VIO_VER_INFO)
 367         CASE_ENV(VIO_ATTR_INFO)
 368         CASE_ENV(VIO_DRING_REG)
 369         CASE_ENV(VIO_DRING_UNREG)
 370         CASE_ENV(VIO_RDX)
 371         CASE_ENV(VIO_PKT_DATA)
 372         CASE_ENV(VIO_DESC_DATA)
 373         CASE_ENV(VIO_DRING_DATA)
 374         default: estr = "unknown"; break;
 375         }
 376 
 377 #undef CASE_ENV
 378 
 379         PR1("(%x/%x/%x) message : (%s/%s/%s)",
 380             msg->tag.vio_msgtype, msg->tag.vio_subtype,
 381             msg->tag.vio_subtype_env, tstr, sstr, estr);
 382 }
 383 
 384 #else   /* !DEBUG */
 385 
 386 #define PR0(...)
 387 #define PR1(...)
 388 #define PR2(...)
 389 
 390 #define VD_DUMP_DRING_ELEM(elem)
 391 
 392 #define vd_decode_state(_s)     (NULL)
 393 #define vd_decode_tag(_s)       (NULL)
 394 
 395 #endif  /* DEBUG */
 396 
 397 
 398 /*
 399  * Soft state structure for a vds instance
 400  */
 401 typedef struct vds {
 402         uint_t          initialized;    /* driver inst initialization flags */
 403         dev_info_t      *dip;           /* driver inst devinfo pointer */
 404         ldi_ident_t     ldi_ident;      /* driver's identifier for LDI */
 405         mod_hash_t      *vd_table;      /* table of virtual disks served */
 406         mdeg_node_spec_t *ispecp;       /* mdeg node specification */
 407         mdeg_handle_t   mdeg;           /* handle for MDEG operations  */
 408         vd_driver_type_t *driver_types; /* extra driver types (from vds.conf) */
 409         int             num_drivers;    /* num of extra driver types */
 410 } vds_t;
 411 
 412 /*
 413  * Types of descriptor-processing tasks
 414  */
 415 typedef enum vd_task_type {
 416         VD_NONFINAL_RANGE_TASK, /* task for intermediate descriptor in range */
 417         VD_FINAL_RANGE_TASK,    /* task for last in a range of descriptors */
 418 } vd_task_type_t;
 419 
 420 /*
 421  * Structure describing the task for processing a descriptor
 422  */
 423 typedef struct vd_task {
 424         struct vd               *vd;            /* vd instance task is for */
 425         vd_task_type_t          type;           /* type of descriptor task */
 426         int                     index;          /* dring elem index for task */
 427         vio_msg_t               *msg;           /* VIO message task is for */
 428         size_t                  msglen;         /* length of message content */
 429         vd_dring_payload_t      *request;       /* request task will perform */
 430         struct buf              buf;            /* buf(9s) for I/O request */
 431         ldc_mem_handle_t        mhdl;           /* task memory handle */
 432         int                     status;         /* status of processing task */
 433         int     (*completef)(struct vd_task *task); /* completion func ptr */
 434         uint32_t                write_index;    /* index in the write_queue */
 435 } vd_task_t;
 436 
 437 /*
 438  * Soft state structure for a virtual disk instance
 439  */
 440 typedef struct vd {
 441         uint64_t                id;             /* vdisk id */
 442         uint_t                  initialized;    /* vdisk initialization flags */
 443         uint64_t                operations;     /* bitmask of VD_OPs exported */
 444         vio_ver_t               version;        /* ver negotiated with client */
 445         vds_t                   *vds;           /* server for this vdisk */
 446         ddi_taskq_t             *startq;        /* queue for I/O start tasks */
 447         ddi_taskq_t             *completionq;   /* queue for completion tasks */
 448         ddi_taskq_t             *ioq;           /* queue for I/O */
 449         uint32_t                write_index;    /* next write index */
 450         buf_t                   **write_queue;  /* queue for async writes */
 451         ldi_handle_t            ldi_handle[V_NUMPAR];   /* LDI slice handles */
 452         char                    device_path[MAXPATHLEN + 1]; /* vdisk device */
 453         dev_t                   dev[V_NUMPAR];  /* dev numbers for slices */
 454         int                     open_flags;     /* open flags */
 455         uint_t                  nslices;        /* number of slices we export */
 456         size_t                  vdisk_size;     /* number of blocks in vdisk */
 457         size_t                  vdisk_bsize;    /* blk size of the vdisk */
 458         vd_disk_type_t          vdisk_type;     /* slice or entire disk */
 459         vd_disk_label_t         vdisk_label;    /* EFI or VTOC label */
 460         vd_media_t              vdisk_media;    /* media type of backing dev. */
 461         boolean_t               is_atapi_dev;   /* Is this an IDE CD-ROM dev? */
 462         ushort_t                max_xfer_sz;    /* max xfer size in DEV_BSIZE */
 463         size_t                  backend_bsize;  /* blk size of backend device */
 464         int                     vio_bshift;     /* shift for blk convertion */
 465         boolean_t               volume;         /* is vDisk backed by volume */
 466         boolean_t               zvol;           /* is vDisk backed by a zvol */
 467         boolean_t               file;           /* is vDisk backed by a file? */
 468         boolean_t               scsi;           /* is vDisk backed by scsi? */
 469         vnode_t                 *file_vnode;    /* file vnode */
 470         size_t                  dskimg_size;    /* size of disk image */
 471         ddi_devid_t             dskimg_devid;   /* devid for disk image */
 472         int                     efi_reserved;   /* EFI reserved slice */
 473         caddr_t                 flabel;         /* fake label for slice type */
 474         uint_t                  flabel_size;    /* fake label size */
 475         uint_t                  flabel_limit;   /* limit of the fake label */
 476         struct dk_geom          dk_geom;        /* synthetic for slice type */
 477         struct extvtoc          vtoc;           /* synthetic for slice type */
 478         vd_slice_t              slices[VD_MAXPART]; /* logical partitions */
 479         boolean_t               ownership;      /* disk ownership status */
 480         ldc_status_t            ldc_state;      /* LDC connection state */
 481         ldc_handle_t            ldc_handle;     /* handle for LDC comm */
 482         size_t                  max_msglen;     /* largest LDC message len */
 483         vd_state_t              state;          /* client handshake state */
 484         uint8_t                 xfer_mode;      /* transfer mode with client */
 485         uint32_t                sid;            /* client's session ID */
 486         uint64_t                seq_num;        /* message sequence number */
 487         uint64_t                dring_ident;    /* identifier of dring */
 488         ldc_dring_handle_t      dring_handle;   /* handle for dring ops */
 489         uint32_t                descriptor_size;        /* num bytes in desc */
 490         uint32_t                dring_len;      /* number of dring elements */
 491         uint8_t                 dring_mtype;    /* dring mem map type */
 492         caddr_t                 dring;          /* address of dring */
 493         caddr_t                 vio_msgp;       /* vio msg staging buffer */
 494         vd_task_t               inband_task;    /* task for inband descriptor */
 495         vd_task_t               *dring_task;    /* tasks dring elements */
 496 
 497         kmutex_t                lock;           /* protects variables below */
 498         boolean_t               enabled;        /* is vdisk enabled? */
 499         boolean_t               reset_state;    /* reset connection state? */
 500         boolean_t               reset_ldc;      /* reset LDC channel? */
 501 } vd_t;
 502 
 503 /*
 504  * Macros to manipulate the fake label (flabel) for single slice disks.
 505  *
 506  * If we fake a VTOC label then the fake label consists of only one block
 507  * containing the VTOC label (struct dk_label).
 508  *
 509  * If we fake an EFI label then the fake label consists of a blank block
 510  * followed by a GPT (efi_gpt_t) and a GPE (efi_gpe_t).
 511  *
 512  */
 513 #define VD_LABEL_VTOC_SIZE(lba)                                 \
 514         P2ROUNDUP(sizeof (struct dk_label), (lba))
 515 
 516 #define VD_LABEL_EFI_SIZE(lba)                                  \
 517         P2ROUNDUP(2 * (lba) + sizeof (efi_gpe_t) * VD_MAXPART,  \
 518             (lba))
 519 
 520 #define VD_LABEL_VTOC(vd)       \
 521                 ((struct dk_label *)(void *)((vd)->flabel))
 522 
 523 #define VD_LABEL_EFI_GPT(vd, lba)       \
 524                 ((efi_gpt_t *)(void *)((vd)->flabel + (lba)))
 525 #define VD_LABEL_EFI_GPE(vd, lba)       \
 526                 ((efi_gpe_t *)(void *)((vd)->flabel + 2 * (lba)))
 527 
 528 
 529 typedef struct vds_operation {
 530         char    *namep;
 531         uint8_t operation;
 532         int     (*start)(vd_task_t *task);
 533         int     (*complete)(vd_task_t *task);
 534 } vds_operation_t;
 535 
 536 typedef struct vd_ioctl {
 537         uint8_t         operation;              /* vdisk operation */
 538         const char      *operation_name;        /* vdisk operation name */
 539         size_t          nbytes;                 /* size of operation buffer */
 540         int             cmd;                    /* corresponding ioctl cmd */
 541         const char      *cmd_name;              /* ioctl cmd name */
 542         void            *arg;                   /* ioctl cmd argument */
 543         /* convert input vd_buf to output ioctl_arg */
 544         int             (*copyin)(void *vd_buf, size_t, void *ioctl_arg);
 545         /* convert input ioctl_arg to output vd_buf */
 546         void            (*copyout)(void *ioctl_arg, void *vd_buf);
 547         /* write is true if the operation writes any data to the backend */
 548         boolean_t       write;
 549 } vd_ioctl_t;
 550 
 551 /* Define trivial copyin/copyout conversion function flag */
 552 #define VD_IDENTITY_IN  ((int (*)(void *, size_t, void *))-1)
 553 #define VD_IDENTITY_OUT ((void (*)(void *, void *))-1)
 554 
 555 
 556 static int      vds_ldc_retries = VDS_RETRIES;
 557 static int      vds_ldc_delay = VDS_LDC_DELAY;
 558 static int      vds_dev_retries = VDS_RETRIES;
 559 static int      vds_dev_delay = VDS_DEV_DELAY;
 560 static void     *vds_state;
 561 
 562 static short    vd_scsi_rdwr_timeout = VD_SCSI_RDWR_TIMEOUT;
 563 static int      vd_scsi_debug = USCSI_SILENT;
 564 
 565 /*
 566  * Number of threads in the taskq handling vdisk I/O. This can be set up to
 567  * the size of the DRing which is the maximum number of I/O we can receive
 568  * in parallel. Note that using a high number of threads can improve performance
 569  * but this is going to consume a lot of resources if there are many vdisks.
 570  */
 571 static int      vd_ioq_nthreads = VD_IOQ_NTHREADS;
 572 
 573 /*
 574  * Tunable to define the behavior for flushing asynchronous writes used to
 575  * performed some write I/O requests. The default behavior is to group as
 576  * much asynchronous writes as possible and to flush them immediatly.
 577  *
 578  * If the tunable is set to 0 then explicit flushing is disabled. In that
 579  * case, data will be flushed by traditional mechanism (like fsflush) but
 580  * this might not happen immediatly.
 581  *
 582  */
 583 static int      vd_awflush = VD_AWFLUSH_IMMEDIATE | VD_AWFLUSH_GROUP;
 584 
 585 /*
 586  * Tunable to define the behavior of the service domain if the vdisk server
 587  * fails to reset disk exclusive access when a LDC channel is reset. When a
 588  * LDC channel is reset the vdisk server will try to reset disk exclusive
 589  * access by releasing any SCSI-2 reservation or resetting the disk. If these
 590  * actions fail then the default behavior (vd_reset_access_failure = 0) is to
 591  * print a warning message. This default behavior can be changed by setting
 592  * the vd_reset_access_failure variable to A_REBOOT (= 0x1) and that will
 593  * cause the service domain to reboot, or A_DUMP (= 0x5) and that will cause
 594  * the service domain to panic. In both cases, the reset of the service domain
 595  * should trigger a reset SCSI buses and hopefully clear any SCSI-2 reservation.
 596  */
 597 static int      vd_reset_access_failure = 0;
 598 
 599 /*
 600  * Tunable for backward compatibility. When this variable is set to B_TRUE,
 601  * all disk volumes (ZFS, SVM, VxvM volumes) will be exported as single
 602  * slice disks whether or not they have the "slice" option set. This is
 603  * to provide a simple backward compatibility mechanism when upgrading
 604  * the vds driver and using a domain configuration created before the
 605  * "slice" option was available.
 606  */
 607 static boolean_t vd_volume_force_slice = B_FALSE;
 608 
 609 /*
 610  * The label of disk images created with some earlier versions of the virtual
 611  * disk software is not entirely correct and have an incorrect v_sanity field
 612  * (usually 0) instead of VTOC_SANE. This creates a compatibility problem with
 613  * these images because we are now validating that the disk label (and the
 614  * sanity) is correct when a disk image is opened.
 615  *
 616  * This tunable is set to false to not validate the sanity field and ensure
 617  * compatibility. If the tunable is set to true, we will do a strict checking
 618  * of the sanity but this can create compatibility problems with old disk
 619  * images.
 620  */
 621 static boolean_t vd_dskimg_validate_sanity = B_FALSE;
 622 
 623 /*
 624  * Enables the use of LDC_DIRECT_MAP when mapping in imported descriptor rings.
 625  */
 626 static boolean_t vd_direct_mapped_drings = B_TRUE;
 627 
 628 /*
 629  * When a backend is exported as a single-slice disk then we entirely fake
 630  * its disk label. So it can be exported either with a VTOC label or with
 631  * an EFI label. If vd_slice_label is set to VD_DISK_LABEL_VTOC then all
 632  * single-slice disks will be exported with a VTOC label; and if it is set
 633  * to VD_DISK_LABEL_EFI then all single-slice disks will be exported with
 634  * an EFI label.
 635  *
 636  * If vd_slice_label is set to VD_DISK_LABEL_UNK and the backend is a disk
 637  * or volume device then it will be exported with the same type of label as
 638  * defined on the device. Otherwise if the backend is a file then it will
 639  * exported with the disk label type set in the vd_file_slice_label variable.
 640  *
 641  * Note that if the backend size is greater than 1TB then it will always be
 642  * exported with an EFI label no matter what the setting is.
 643  */
 644 static vd_disk_label_t vd_slice_label = VD_DISK_LABEL_UNK;
 645 
 646 static vd_disk_label_t vd_file_slice_label = VD_DISK_LABEL_VTOC;
 647 
 648 /*
 649  * Tunable for backward compatibility. If this variable is set to B_TRUE then
 650  * single-slice disks are exported as disks with only one slice instead of
 651  * faking a complete disk partitioning.
 652  */
 653 static boolean_t vd_slice_single_slice = B_FALSE;
 654 
 655 /*
 656  * Supported protocol version pairs, from highest (newest) to lowest (oldest)
 657  *
 658  * Each supported major version should appear only once, paired with (and only
 659  * with) its highest supported minor version number (as the protocol requires
 660  * supporting all lower minor version numbers as well)
 661  */
 662 static const vio_ver_t  vds_version[] = {{1, 1}};
 663 static const size_t     vds_num_versions =
 664     sizeof (vds_version)/sizeof (vds_version[0]);
 665 
 666 static void vd_free_dring_task(vd_t *vdp);
 667 static int vd_setup_vd(vd_t *vd);
 668 static int vd_setup_single_slice_disk(vd_t *vd);
 669 static int vd_setup_slice_image(vd_t *vd);
 670 static int vd_setup_disk_image(vd_t *vd);
 671 static int vd_backend_check_size(vd_t *vd);
 672 static boolean_t vd_enabled(vd_t *vd);
 673 static ushort_t vd_lbl2cksum(struct dk_label *label);
 674 static int vd_dskimg_validate_geometry(vd_t *vd);
 675 static boolean_t vd_dskimg_is_iso_image(vd_t *vd);
 676 static void vd_set_exported_operations(vd_t *vd);
 677 static void vd_reset_access(vd_t *vd);
 678 static int vd_backend_ioctl(vd_t *vd, int cmd, caddr_t arg);
 679 static int vds_efi_alloc_and_read(vd_t *, efi_gpt_t **, efi_gpe_t **);
 680 static void vds_efi_free(vd_t *, efi_gpt_t *, efi_gpe_t *);
 681 static void vds_driver_types_free(vds_t *vds);
 682 static void vd_vtocgeom_to_label(struct extvtoc *vtoc, struct dk_geom *geom,
 683     struct dk_label *label);
 684 static void vd_label_to_vtocgeom(struct dk_label *label, struct extvtoc *vtoc,
 685     struct dk_geom *geom);
 686 static boolean_t vd_slice_geom_isvalid(vd_t *vd, struct dk_geom *geom);
 687 static boolean_t vd_slice_vtoc_isvalid(vd_t *vd, struct extvtoc *vtoc);
 688 
 689 extern int is_pseudo_device(dev_info_t *);
 690 
 691 /*
 692  * Function:
 693  *      vd_get_readable_size
 694  *
 695  * Description:
 696  *      Convert a given size in bytes to a human readable format in
 697  *      kilobytes, megabytes, gigabytes or terabytes.
 698  *
 699  * Parameters:
 700  *      full_size       - the size to convert in bytes.
 701  *      size            - the converted size.
 702  *      unit            - the unit of the converted size: 'K' (kilobyte),
 703  *                        'M' (Megabyte), 'G' (Gigabyte), 'T' (Terabyte).
 704  *
 705  * Return Code:
 706  *      none
 707  */
 708 static void
 709 vd_get_readable_size(size_t full_size, size_t *size, char *unit)
 710 {
 711         if (full_size < (1ULL << 20)) {
 712                 *size = full_size >> 10;
 713                 *unit = 'K'; /* Kilobyte */
 714         } else if (full_size < (1ULL << 30)) {
 715                 *size = full_size >> 20;
 716                 *unit = 'M'; /* Megabyte */
 717         } else if (full_size < (1ULL << 40)) {
 718                 *size = full_size >> 30;
 719                 *unit = 'G'; /* Gigabyte */
 720         } else {
 721                 *size = full_size >> 40;
 722                 *unit = 'T'; /* Terabyte */
 723         }
 724 }
 725 
 726 /*
 727  * Function:
 728  *      vd_dskimg_io_params
 729  *
 730  * Description:
 731  *      Convert virtual disk I/O parameters (slice, block, length) to
 732  *      (offset, length) relative to the disk image and according to
 733  *      the virtual disk partitioning.
 734  *
 735  * Parameters:
 736  *      vd              - disk on which the operation is performed.
 737  *      slice           - slice to which is the I/O parameters apply.
 738  *                        VD_SLICE_NONE indicates that parameters are
 739  *                        are relative to the entire virtual disk.
 740  *      blkp            - pointer to the starting block relative to the
 741  *                        slice; return the starting block relative to
 742  *                        the disk image.
 743  *      lenp            - pointer to the number of bytes requested; return
 744  *                        the number of bytes that can effectively be used.
 745  *
 746  * Return Code:
 747  *      0               - I/O parameters have been successfully converted;
 748  *                        blkp and lenp point to the converted values.
 749  *      ENODATA         - no data are available for the given I/O parameters;
 750  *                        This occurs if the starting block is past the limit
 751  *                        of the slice.
 752  *      EINVAL          - I/O parameters are invalid.
 753  */
 754 static int
 755 vd_dskimg_io_params(vd_t *vd, int slice, size_t *blkp, size_t *lenp)
 756 {
 757         size_t blk = *blkp;
 758         size_t len = *lenp;
 759         size_t offset, maxlen;
 760 
 761         ASSERT(vd->file || VD_DSKIMG(vd));
 762         ASSERT(len > 0);
 763         ASSERT(vd->vdisk_bsize == DEV_BSIZE);
 764 
 765         /*
 766          * If a file is exported as a slice then we don't care about the vtoc.
 767          * In that case, the vtoc is a fake mainly to make newfs happy and we
 768          * handle any I/O as a raw disk access so that we can have access to the
 769          * entire backend.
 770          */
 771         if (vd->vdisk_type == VD_DISK_TYPE_SLICE || slice == VD_SLICE_NONE) {
 772                 /* raw disk access */
 773                 offset = blk * DEV_BSIZE;
 774                 if (offset >= vd->dskimg_size) {
 775                         /* offset past the end of the disk */
 776                         PR0("offset (0x%lx) >= size (0x%lx)",
 777                             offset, vd->dskimg_size);
 778                         return (ENODATA);
 779                 }
 780                 maxlen = vd->dskimg_size - offset;
 781         } else {
 782                 ASSERT(slice >= 0 && slice < V_NUMPAR);
 783 
 784                 /*
 785                  * v1.0 vDisk clients depended on the server not verifying
 786                  * the label of a unformatted disk.  This "feature" is
 787                  * maintained for backward compatibility but all versions
 788                  * from v1.1 onwards must do the right thing.
 789                  */
 790                 if (vd->vdisk_label == VD_DISK_LABEL_UNK &&
 791                     vio_ver_is_supported(vd->version, 1, 1)) {
 792                         (void) vd_dskimg_validate_geometry(vd);
 793                         if (vd->vdisk_label == VD_DISK_LABEL_UNK) {
 794                                 PR0("Unknown disk label, can't do I/O "
 795                                     "from slice %d", slice);
 796                                 return (EINVAL);
 797                         }
 798                 }
 799 
 800                 if (vd->vdisk_label == VD_DISK_LABEL_VTOC) {
 801                         ASSERT(vd->vtoc.v_sectorsz == DEV_BSIZE);
 802                 } else {
 803                         ASSERT(vd->vdisk_label == VD_DISK_LABEL_EFI);
 804                 }
 805 
 806                 if (blk >= vd->slices[slice].nblocks) {
 807                         /* address past the end of the slice */
 808                         PR0("req_addr (0x%lx) >= psize (0x%lx)",
 809                             blk, vd->slices[slice].nblocks);
 810                         return (ENODATA);
 811                 }
 812 
 813                 offset = (vd->slices[slice].start + blk) * DEV_BSIZE;
 814                 maxlen = (vd->slices[slice].nblocks - blk) * DEV_BSIZE;
 815         }
 816 
 817         /*
 818          * If the requested size is greater than the size
 819          * of the partition, truncate the read/write.
 820          */
 821         if (len > maxlen) {
 822                 PR0("I/O size truncated to %lu bytes from %lu bytes",
 823                     maxlen, len);
 824                 len = maxlen;
 825         }
 826 
 827         /*
 828          * We have to ensure that we are reading/writing into the mmap
 829          * range. If we have a partial disk image (e.g. an image of
 830          * s0 instead s2) the system can try to access slices that
 831          * are not included into the disk image.
 832          */
 833         if ((offset + len) > vd->dskimg_size) {
 834                 PR0("offset + nbytes (0x%lx + 0x%lx) > "
 835                     "dskimg_size (0x%lx)", offset, len, vd->dskimg_size);
 836                 return (EINVAL);
 837         }
 838 
 839         *blkp = offset / DEV_BSIZE;
 840         *lenp = len;
 841 
 842         return (0);
 843 }
 844 
 845 /*
 846  * Function:
 847  *      vd_dskimg_rw
 848  *
 849  * Description:
 850  *      Read or write to a disk image. It handles the case where the disk
 851  *      image is a file or a volume exported as a full disk or a file
 852  *      exported as single-slice disk. Read or write to volumes exported as
 853  *      single slice disks are done by directly using the ldi interface.
 854  *
 855  * Parameters:
 856  *      vd              - disk on which the operation is performed.
 857  *      slice           - slice on which the operation is performed,
 858  *                        VD_SLICE_NONE indicates that the operation
 859  *                        is done using an absolute disk offset.
 860  *      operation       - operation to execute: read (VD_OP_BREAD) or
 861  *                        write (VD_OP_BWRITE).
 862  *      data            - buffer where data are read to or written from.
 863  *      blk             - starting block for the operation.
 864  *      len             - number of bytes to read or write.
 865  *
 866  * Return Code:
 867  *      n >= 0               - success, n indicates the number of bytes read
 868  *                        or written.
 869  *      -1              - error.
 870  */
 871 static ssize_t
 872 vd_dskimg_rw(vd_t *vd, int slice, int operation, caddr_t data, size_t offset,
 873     size_t len)
 874 {
 875         ssize_t resid;
 876         struct buf buf;
 877         int status;
 878 
 879         ASSERT(vd->file || VD_DSKIMG(vd));
 880         ASSERT(len > 0);
 881         ASSERT(vd->vdisk_bsize == DEV_BSIZE);
 882 
 883         if ((status = vd_dskimg_io_params(vd, slice, &offset, &len)) != 0)
 884                 return ((status == ENODATA)? 0: -1);
 885 
 886         if (vd->volume) {
 887 
 888                 bioinit(&buf);
 889                 buf.b_flags     = B_BUSY |
 890                     ((operation == VD_OP_BREAD)? B_READ : B_WRITE);
 891                 buf.b_bcount    = len;
 892                 buf.b_lblkno    = offset;
 893                 buf.b_edev      = vd->dev[0];
 894                 buf.b_un.b_addr = data;
 895 
 896                 /*
 897                  * We use ldi_strategy() and not ldi_read()/ldi_write() because
 898                  * the read/write functions of the underlying driver may try to
 899                  * lock pages of the data buffer, and this requires the data
 900                  * buffer to be kmem_alloc'ed (and not allocated on the stack).
 901                  *
 902                  * Also using ldi_strategy() ensures that writes are immediatly
 903                  * commited and not cached as this may be the case with
 904                  * ldi_write() (for example with a ZFS volume).
 905                  */
 906                 if (ldi_strategy(vd->ldi_handle[0], &buf) != 0) {
 907                         biofini(&buf);
 908                         return (-1);
 909                 }
 910 
 911                 if (biowait(&buf) != 0) {
 912                         biofini(&buf);
 913                         return (-1);
 914                 }
 915 
 916                 resid = buf.b_resid;
 917                 biofini(&buf);
 918 
 919                 ASSERT(resid <= len);
 920                 return (len - resid);
 921         }
 922 
 923         ASSERT(vd->file);
 924 
 925         status = vn_rdwr((operation == VD_OP_BREAD)? UIO_READ : UIO_WRITE,
 926             vd->file_vnode, data, len, offset * DEV_BSIZE, UIO_SYSSPACE, FSYNC,
 927             RLIM64_INFINITY, kcred, &resid);
 928 
 929         if (status != 0)
 930                 return (-1);
 931 
 932         return (len);
 933 }
 934 
 935 /*
 936  * Function:
 937  *      vd_build_default_label
 938  *
 939  * Description:
 940  *      Return a default label for a given disk size. This is used when the disk
 941  *      does not have a valid VTOC so that the user can get a valid default
 942  *      configuration. The default label has all slice sizes set to 0 (except
 943  *      slice 2 which is the entire disk) to force the user to write a valid
 944  *      label onto the disk image.
 945  *
 946  * Parameters:
 947  *      disk_size       - the disk size in bytes
 948  *      bsize           - the disk block size in bytes
 949  *      label           - the returned default label.
 950  *
 951  * Return Code:
 952  *      none.
 953  */
 954 static void
 955 vd_build_default_label(size_t disk_size, size_t bsize, struct dk_label *label)
 956 {
 957         size_t size;
 958         char unit;
 959 
 960         ASSERT(bsize > 0);
 961 
 962         bzero(label, sizeof (struct dk_label));
 963 
 964         /*
 965          * Ideally we would like the cylinder size (nsect * nhead) to be the
 966          * same whatever the disk size is. That way the VTOC label could be
 967          * easily updated in case the disk size is increased (keeping the
 968          * same cylinder size allows to preserve the existing partitioning
 969          * when updating the VTOC label). But it is not possible to have
 970          * a fixed cylinder size and to cover all disk size.
 971          *
 972          * So we define different cylinder sizes depending on the disk size.
 973          * The cylinder size is chosen so that we don't have too few cylinders
 974          * for a small disk image, or so many on a big disk image that you
 975          * waste space for backup superblocks or cylinder group structures.
 976          * Also we must have a resonable number of cylinders and sectors so
 977          * that newfs can run using default values.
 978          *
 979          *      +-----------+--------+---------+--------+
 980          *      | disk_size |  < 2MB | 2MB-4GB | >= 8GB |
 981          *      +-----------+--------+---------+--------+
 982          *      | nhead     |    1   |     1   |    96  |
 983          *      | nsect     |  200   |   600   |   768  |
 984          *      +-----------+--------+---------+--------+
 985          *
 986          * Other parameters are computed from these values:
 987          *
 988          *      pcyl = disk_size / (nhead * nsect * 512)
 989          *      acyl = (pcyl > 2)? 2 : 0
 990          *      ncyl = pcyl - acyl
 991          *
 992          * The maximum number of cylinder is 65535 so this allows to define a
 993          * geometry for a disk size up to 65535 * 96 * 768 * 512 = 2.24 TB
 994          * which is more than enough to cover the maximum size allowed by the
 995          * extended VTOC format (2TB).
 996          */
 997 
 998         if (disk_size >= 8 * ONE_GIGABYTE) {
 999 
1000                 label->dkl_nhead = 96;
1001                 label->dkl_nsect = 768;
1002 
1003         } else if (disk_size >= 2 * ONE_MEGABYTE) {
1004 
1005                 label->dkl_nhead = 1;
1006                 label->dkl_nsect = 600;
1007 
1008         } else {
1009 
1010                 label->dkl_nhead = 1;
1011                 label->dkl_nsect = 200;
1012         }
1013 
1014         label->dkl_pcyl = disk_size /
1015             (label->dkl_nsect * label->dkl_nhead * bsize);
1016 
1017         if (label->dkl_pcyl == 0)
1018                 label->dkl_pcyl = 1;
1019 
1020         label->dkl_acyl = 0;
1021 
1022         if (label->dkl_pcyl > 2)
1023                 label->dkl_acyl = 2;
1024 
1025         label->dkl_ncyl = label->dkl_pcyl - label->dkl_acyl;
1026         label->dkl_write_reinstruct = 0;
1027         label->dkl_read_reinstruct = 0;
1028         label->dkl_rpm = 7200;
1029         label->dkl_apc = 0;
1030         label->dkl_intrlv = 0;
1031 
1032         PR0("requested disk size: %ld bytes\n", disk_size);
1033         PR0("setup: ncyl=%d nhead=%d nsec=%d\n", label->dkl_pcyl,
1034             label->dkl_nhead, label->dkl_nsect);
1035         PR0("provided disk size: %ld bytes\n", (uint64_t)
1036             (label->dkl_pcyl * label->dkl_nhead *
1037             label->dkl_nsect * bsize));
1038 
1039         vd_get_readable_size(disk_size, &size, &unit);
1040 
1041         /*
1042          * We must have a correct label name otherwise format(1m) will
1043          * not recognized the disk as labeled.
1044          */
1045         (void) snprintf(label->dkl_asciilabel, LEN_DKL_ASCII,
1046             "SUN-DiskImage-%ld%cB cyl %d alt %d hd %d sec %d",
1047             size, unit,
1048             label->dkl_ncyl, label->dkl_acyl, label->dkl_nhead,
1049             label->dkl_nsect);
1050 
1051         /* default VTOC */
1052         label->dkl_vtoc.v_version = V_EXTVERSION;
1053         label->dkl_vtoc.v_nparts = V_NUMPAR;
1054         label->dkl_vtoc.v_sanity = VTOC_SANE;
1055         label->dkl_vtoc.v_part[VD_ENTIRE_DISK_SLICE].p_tag = V_BACKUP;
1056         label->dkl_map[VD_ENTIRE_DISK_SLICE].dkl_cylno = 0;
1057         label->dkl_map[VD_ENTIRE_DISK_SLICE].dkl_nblk = label->dkl_ncyl *
1058             label->dkl_nhead * label->dkl_nsect;
1059         label->dkl_magic = DKL_MAGIC;
1060         label->dkl_cksum = vd_lbl2cksum(label);
1061 }
1062 
1063 /*
1064  * Function:
1065  *      vd_dskimg_set_vtoc
1066  *
1067  * Description:
1068  *      Set the vtoc of a disk image by writing the label and backup
1069  *      labels into the disk image backend.
1070  *
1071  * Parameters:
1072  *      vd              - disk on which the operation is performed.
1073  *      label           - the data to be written.
1074  *
1075  * Return Code:
1076  *      0               - success.
1077  *      n > 0                - error, n indicates the errno code.
1078  */
1079 static int
1080 vd_dskimg_set_vtoc(vd_t *vd, struct dk_label *label)
1081 {
1082         size_t blk, sec, cyl, head, cnt;
1083 
1084         ASSERT(VD_DSKIMG(vd));
1085 
1086         if (VD_DSKIMG_LABEL_WRITE(vd, label) < 0) {
1087                 PR0("fail to write disk label");
1088                 return (EIO);
1089         }
1090 
1091         /*
1092          * Backup labels are on the last alternate cylinder's
1093          * first five odd sectors.
1094          */
1095         if (label->dkl_acyl == 0) {
1096                 PR0("no alternate cylinder, can not store backup labels");
1097                 return (0);
1098         }
1099 
1100         cyl = label->dkl_ncyl  + label->dkl_acyl - 1;
1101         head = label->dkl_nhead - 1;
1102 
1103         blk = (cyl * ((label->dkl_nhead * label->dkl_nsect) - label->dkl_apc)) +
1104             (head * label->dkl_nsect);
1105 
1106         /*
1107          * Write the backup labels. Make sure we don't try to write past
1108          * the last cylinder.
1109          */
1110         sec = 1;
1111 
1112         for (cnt = 0; cnt < VD_DSKIMG_NUM_BACKUP; cnt++) {
1113 
1114                 if (sec >= label->dkl_nsect) {
1115                         PR0("not enough sector to store all backup labels");
1116                         return (0);
1117                 }
1118 
1119                 if (vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BWRITE,
1120                     (caddr_t)label, blk + sec, sizeof (struct dk_label)) < 0) {
1121                         PR0("error writing backup label at block %lu\n",
1122                             blk + sec);
1123                         return (EIO);
1124                 }
1125 
1126                 PR1("wrote backup label at block %lu\n", blk + sec);
1127 
1128                 sec += 2;
1129         }
1130 
1131         return (0);
1132 }
1133 
1134 /*
1135  * Function:
1136  *      vd_dskimg_get_devid_block
1137  *
1138  * Description:
1139  *      Return the block number where the device id is stored.
1140  *
1141  * Parameters:
1142  *      vd              - disk on which the operation is performed.
1143  *      blkp            - pointer to the block number
1144  *
1145  * Return Code:
1146  *      0               - success
1147  *      ENOSPC          - disk has no space to store a device id
1148  */
1149 static int
1150 vd_dskimg_get_devid_block(vd_t *vd, size_t *blkp)
1151 {
1152         diskaddr_t spc, head, cyl;
1153 
1154         ASSERT(VD_DSKIMG(vd));
1155 
1156         if (vd->vdisk_label == VD_DISK_LABEL_UNK) {
1157                 /*
1158                  * If no label is defined we don't know where to find
1159                  * a device id.
1160                  */
1161                 return (ENOSPC);
1162         }
1163 
1164         if (vd->vdisk_label == VD_DISK_LABEL_EFI) {
1165                 /*
1166                  * For an EFI disk, the devid is at the beginning of
1167                  * the reserved slice
1168                  */
1169                 if (vd->efi_reserved == -1) {
1170                         PR0("EFI disk has no reserved slice");
1171                         return (ENOSPC);
1172                 }
1173 
1174                 *blkp = vd->slices[vd->efi_reserved].start;
1175                 return (0);
1176         }
1177 
1178         ASSERT(vd->vdisk_label == VD_DISK_LABEL_VTOC);
1179 
1180         /* this geometry doesn't allow us to have a devid */
1181         if (vd->dk_geom.dkg_acyl < 2) {
1182                 PR0("not enough alternate cylinder available for devid "
1183                     "(acyl=%u)", vd->dk_geom.dkg_acyl);
1184                 return (ENOSPC);
1185         }
1186 
1187         /* the devid is in on the track next to the last cylinder */
1188         cyl = vd->dk_geom.dkg_ncyl + vd->dk_geom.dkg_acyl - 2;
1189         spc = vd->dk_geom.dkg_nhead * vd->dk_geom.dkg_nsect;
1190         head = vd->dk_geom.dkg_nhead - 1;
1191 
1192         *blkp = (cyl * (spc - vd->dk_geom.dkg_apc)) +
1193             (head * vd->dk_geom.dkg_nsect) + 1;
1194 
1195         return (0);
1196 }
1197 
1198 /*
1199  * Return the checksum of a disk block containing an on-disk devid.
1200  */
1201 static uint_t
1202 vd_dkdevid2cksum(struct dk_devid *dkdevid)
1203 {
1204         uint_t chksum, *ip;
1205         int i;
1206 
1207         chksum = 0;
1208         ip = (void *)dkdevid;
1209         for (i = 0; i < ((DEV_BSIZE - sizeof (int)) / sizeof (int)); i++)
1210                 chksum ^= ip[i];
1211 
1212         return (chksum);
1213 }
1214 
1215 /*
1216  * Function:
1217  *      vd_dskimg_read_devid
1218  *
1219  * Description:
1220  *      Read the device id stored on a disk image.
1221  *
1222  * Parameters:
1223  *      vd              - disk on which the operation is performed.
1224  *      devid           - the return address of the device ID.
1225  *
1226  * Return Code:
1227  *      0               - success
1228  *      EIO             - I/O error while trying to access the disk image
1229  *      EINVAL          - no valid device id was found
1230  *      ENOSPC          - disk has no space to store a device id
1231  */
1232 static int
1233 vd_dskimg_read_devid(vd_t *vd, ddi_devid_t *devid)
1234 {
1235         struct dk_devid *dkdevid;
1236         size_t blk;
1237         uint_t chksum;
1238         int status, sz;
1239 
1240         ASSERT(vd->vdisk_bsize == DEV_BSIZE);
1241 
1242         if ((status = vd_dskimg_get_devid_block(vd, &blk)) != 0)
1243                 return (status);
1244 
1245         dkdevid = kmem_zalloc(DEV_BSIZE, KM_SLEEP);
1246 
1247         /* get the devid */
1248         if ((vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BREAD, (caddr_t)dkdevid, blk,
1249             DEV_BSIZE)) < 0) {
1250                 PR0("error reading devid block at %lu", blk);
1251                 status = EIO;
1252                 goto done;
1253         }
1254 
1255         /* validate the revision */
1256         if ((dkdevid->dkd_rev_hi != DK_DEVID_REV_MSB) ||
1257             (dkdevid->dkd_rev_lo != DK_DEVID_REV_LSB)) {
1258                 PR0("invalid devid found at block %lu (bad revision)", blk);
1259                 status = EINVAL;
1260                 goto done;
1261         }
1262 
1263         /* compute checksum */
1264         chksum = vd_dkdevid2cksum(dkdevid);
1265 
1266         /* compare the checksums */
1267         if (DKD_GETCHKSUM(dkdevid) != chksum) {
1268                 PR0("invalid devid found at block %lu (bad checksum)", blk);
1269                 status = EINVAL;
1270                 goto done;
1271         }
1272 
1273         /* validate the device id */
1274         if (ddi_devid_valid((ddi_devid_t)&dkdevid->dkd_devid) != DDI_SUCCESS) {
1275                 PR0("invalid devid found at block %lu", blk);
1276                 status = EINVAL;
1277                 goto done;
1278         }
1279 
1280         PR1("devid read at block %lu", blk);
1281 
1282         sz = ddi_devid_sizeof((ddi_devid_t)&dkdevid->dkd_devid);
1283         *devid = kmem_alloc(sz, KM_SLEEP);
1284         bcopy(&dkdevid->dkd_devid, *devid, sz);
1285 
1286 done:
1287         kmem_free(dkdevid, DEV_BSIZE);
1288         return (status);
1289 
1290 }
1291 
1292 /*
1293  * Function:
1294  *      vd_dskimg_write_devid
1295  *
1296  * Description:
1297  *      Write a device id into disk image.
1298  *
1299  * Parameters:
1300  *      vd              - disk on which the operation is performed.
1301  *      devid           - the device ID to store.
1302  *
1303  * Return Code:
1304  *      0               - success
1305  *      EIO             - I/O error while trying to access the disk image
1306  *      ENOSPC          - disk has no space to store a device id
1307  */
1308 static int
1309 vd_dskimg_write_devid(vd_t *vd, ddi_devid_t devid)
1310 {
1311         struct dk_devid *dkdevid;
1312         uint_t chksum;
1313         size_t blk;
1314         int status;
1315 
1316         ASSERT(vd->vdisk_bsize == DEV_BSIZE);
1317 
1318         if (devid == NULL) {
1319                 /* nothing to write */
1320                 return (0);
1321         }
1322 
1323         if ((status = vd_dskimg_get_devid_block(vd, &blk)) != 0)
1324                 return (status);
1325 
1326         dkdevid = kmem_zalloc(DEV_BSIZE, KM_SLEEP);
1327 
1328         /* set revision */
1329         dkdevid->dkd_rev_hi = DK_DEVID_REV_MSB;
1330         dkdevid->dkd_rev_lo = DK_DEVID_REV_LSB;
1331 
1332         /* copy devid */
1333         bcopy(devid, &dkdevid->dkd_devid, ddi_devid_sizeof(devid));
1334 
1335         /* compute checksum */
1336         chksum = vd_dkdevid2cksum(dkdevid);
1337 
1338         /* set checksum */
1339         DKD_FORMCHKSUM(chksum, dkdevid);
1340 
1341         /* store the devid */
1342         if ((status = vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BWRITE,
1343             (caddr_t)dkdevid, blk, DEV_BSIZE)) < 0) {
1344                 PR0("Error writing devid block at %lu", blk);
1345                 status = EIO;
1346         } else {
1347                 PR1("devid written at block %lu", blk);
1348                 status = 0;
1349         }
1350 
1351         kmem_free(dkdevid, DEV_BSIZE);
1352         return (status);
1353 }
1354 
1355 /*
1356  * Function:
1357  *      vd_do_scsi_rdwr
1358  *
1359  * Description:
1360  *      Read or write to a SCSI disk using an absolute disk offset.
1361  *
1362  * Parameters:
1363  *      vd              - disk on which the operation is performed.
1364  *      operation       - operation to execute: read (VD_OP_BREAD) or
1365  *                        write (VD_OP_BWRITE).
1366  *      data            - buffer where data are read to or written from.
1367  *      blk             - starting block for the operation.
1368  *      len             - number of bytes to read or write.
1369  *
1370  * Return Code:
1371  *      0               - success
1372  *      n != 0          - error.
1373  */
1374 static int
1375 vd_do_scsi_rdwr(vd_t *vd, int operation, caddr_t data, size_t blk, size_t len)
1376 {
1377         struct uscsi_cmd ucmd;
1378         union scsi_cdb cdb;
1379         int nsectors, nblk;
1380         int max_sectors;
1381         int status, rval;
1382 
1383         ASSERT(!vd->file);
1384         ASSERT(!vd->volume);
1385         ASSERT(vd->vdisk_bsize > 0);
1386 
1387         max_sectors = vd->max_xfer_sz;
1388         nblk = (len / vd->vdisk_bsize);
1389 
1390         if (len % vd->vdisk_bsize != 0)
1391                 return (EINVAL);
1392 
1393         /*
1394          * Build and execute the uscsi ioctl.  We build a group0, group1
1395          * or group4 command as necessary, since some targets
1396          * do not support group1 commands.
1397          */
1398         while (nblk) {
1399 
1400                 bzero(&ucmd, sizeof (ucmd));
1401                 bzero(&cdb, sizeof (cdb));
1402 
1403                 nsectors = (max_sectors < nblk) ? max_sectors : nblk;
1404 
1405                 /*
1406                  * Some of the optical drives on sun4v machines are ATAPI
1407                  * devices which use Group 1 Read/Write commands so we need
1408                  * to explicitly check a flag which is set when a domain
1409                  * is bound.
1410                  */
1411                 if (blk < (2 << 20) && nsectors <= 0xff && !vd->is_atapi_dev) {
1412                         FORMG0ADDR(&cdb, blk);
1413                         FORMG0COUNT(&cdb, (uchar_t)nsectors);
1414                         ucmd.uscsi_cdblen = CDB_GROUP0;
1415                 } else if (blk > 0xffffffff) {
1416                         FORMG4LONGADDR(&cdb, blk);
1417                         FORMG4COUNT(&cdb, nsectors);
1418                         ucmd.uscsi_cdblen = CDB_GROUP4;
1419                         cdb.scc_cmd |= SCMD_GROUP4;
1420                 } else {
1421                         FORMG1ADDR(&cdb, blk);
1422                         FORMG1COUNT(&cdb, nsectors);
1423                         ucmd.uscsi_cdblen = CDB_GROUP1;
1424                         cdb.scc_cmd |= SCMD_GROUP1;
1425                 }
1426                 ucmd.uscsi_cdb = (caddr_t)&cdb;
1427                 ucmd.uscsi_bufaddr = data;
1428                 ucmd.uscsi_buflen = nsectors * vd->backend_bsize;
1429                 ucmd.uscsi_timeout = vd_scsi_rdwr_timeout;
1430                 /*
1431                  * Set flags so that the command is isolated from normal
1432                  * commands and no error message is printed.
1433                  */
1434                 ucmd.uscsi_flags = USCSI_ISOLATE | USCSI_SILENT;
1435 
1436                 if (operation == VD_OP_BREAD) {
1437                         cdb.scc_cmd |= SCMD_READ;
1438                         ucmd.uscsi_flags |= USCSI_READ;
1439                 } else {
1440                         cdb.scc_cmd |= SCMD_WRITE;
1441                 }
1442 
1443                 status = ldi_ioctl(vd->ldi_handle[VD_ENTIRE_DISK_SLICE],
1444                     USCSICMD, (intptr_t)&ucmd, (vd->open_flags | FKIOCTL),
1445                     kcred, &rval);
1446 
1447                 if (status == 0)
1448                         status = ucmd.uscsi_status;
1449 
1450                 if (status != 0)
1451                         break;
1452 
1453                 /*
1454                  * Check if partial DMA breakup is required. If so, reduce
1455                  * the request size by half and retry the last request.
1456                  */
1457                 if (ucmd.uscsi_resid == ucmd.uscsi_buflen) {
1458                         max_sectors >>= 1;
1459                         if (max_sectors <= 0) {
1460                                 status = EIO;
1461                                 break;
1462                         }
1463                         continue;
1464                 }
1465 
1466                 if (ucmd.uscsi_resid != 0) {
1467                         status = EIO;
1468                         break;
1469                 }
1470 
1471                 blk += nsectors;
1472                 nblk -= nsectors;
1473                 data += nsectors * vd->vdisk_bsize;
1474         }
1475 
1476         return (status);
1477 }
1478 
1479 /*
1480  * Function:
1481  *      vd_scsi_rdwr
1482  *
1483  * Description:
1484  *      Wrapper function to read or write to a SCSI disk using an absolute
1485  *      disk offset. It checks the blocksize of the underlying device and,
1486  *      if necessary, adjusts the buffers accordingly before calling
1487  *      vd_do_scsi_rdwr() to do the actual read or write.
1488  *
1489  * Parameters:
1490  *      vd              - disk on which the operation is performed.
1491  *      operation       - operation to execute: read (VD_OP_BREAD) or
1492  *                        write (VD_OP_BWRITE).
1493  *      data            - buffer where data are read to or written from.
1494  *      blk             - starting block for the operation.
1495  *      len             - number of bytes to read or write.
1496  *
1497  * Return Code:
1498  *      0               - success
1499  *      n != 0          - error.
1500  */
1501 static int
1502 vd_scsi_rdwr(vd_t *vd, int operation, caddr_t data, size_t vblk, size_t vlen)
1503 {
1504         int     rv;
1505 
1506         size_t  pblk;   /* physical device block number of data on device */
1507         size_t  delta;  /* relative offset between pblk and vblk */
1508         size_t  pnblk;  /* number of physical blocks to be read from device */
1509         size_t  plen;   /* length of data to be read from physical device */
1510         char    *buf;   /* buffer area to fit physical device's block size */
1511 
1512         if (vd->backend_bsize == 0) {
1513                 /*
1514                  * The block size was not available during the attach,
1515                  * try to update it now.
1516                  */
1517                 if (vd_backend_check_size(vd) != 0)
1518                         return (EIO);
1519         }
1520 
1521         /*
1522          * If the vdisk block size and the block size of the underlying device
1523          * match we can skip straight to vd_do_scsi_rdwr(), otherwise we need
1524          * to create a buffer large enough to handle the device's block size
1525          * and adjust the block to be read from and the amount of data to
1526          * read to correspond with the device's block size.
1527          */
1528         if (vd->vdisk_bsize == vd->backend_bsize)
1529                 return (vd_do_scsi_rdwr(vd, operation, data, vblk, vlen));
1530 
1531         if (vd->vdisk_bsize > vd->backend_bsize)
1532                 return (EINVAL);
1533 
1534         /*
1535          * Writing of physical block sizes larger than the virtual block size
1536          * is not supported. This would be added if/when support for guests
1537          * writing to DVDs is implemented.
1538          */
1539         if (operation == VD_OP_BWRITE)
1540                 return (ENOTSUP);
1541 
1542         /* BEGIN CSTYLED */
1543         /*
1544          * Below is a diagram showing the relationship between the physical
1545          * and virtual blocks. If the virtual blocks marked by 'X' below are
1546          * requested, then the physical blocks denoted by 'Y' are read.
1547          *
1548          *           vblk
1549          *             |      vlen
1550          *             |<--------------->|
1551          *             v                 v
1552          *  --+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-   virtual disk:
1553          *    |  |  |  |XX|XX|XX|XX|XX|XX|  |  |  |  |  |  } block size is
1554          *  --+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-   vd->vdisk_bsize
1555          *          :  :                 :  :
1556          *         >:==:< delta          :  :
1557          *          :  :                 :  :
1558          *  --+-----+-----+-----+-----+-----+-----+-----+--   physical disk:
1559          *    |     |YY:YY|YYYYY|YYYYY|YY:YY|     |     |   } block size is
1560          *  --+-----+-----+-----+-----+-----+-----+-----+--   vd->backend_bsize
1561          *          ^                       ^
1562          *          |<--------------------->|
1563          *          |         plen
1564          *         pblk 
1565          */
1566         /* END CSTYLED */
1567         pblk = (vblk * vd->vdisk_bsize) / vd->backend_bsize;
1568         delta = (vblk * vd->vdisk_bsize) - (pblk * vd->backend_bsize);
1569         pnblk = ((delta + vlen - 1) / vd->backend_bsize) + 1;
1570         plen = pnblk * vd->backend_bsize;
1571 
1572         PR2("vblk %lx:pblk %lx: vlen %ld:plen %ld", vblk, pblk, vlen, plen);
1573 
1574         buf = kmem_zalloc(sizeof (caddr_t) * plen, KM_SLEEP);
1575         rv = vd_do_scsi_rdwr(vd, operation, (caddr_t)buf, pblk, plen);
1576         bcopy(buf + delta, data, vlen);
1577 
1578         kmem_free(buf, sizeof (caddr_t) * plen);
1579 
1580         return (rv);
1581 }
1582 
1583 /*
1584  * Function:
1585  *      vd_slice_flabel_read
1586  *
1587  * Description:
1588  *      This function simulates a read operation from the fake label of
1589  *      a single-slice disk.
1590  *
1591  * Parameters:
1592  *      vd              - single-slice disk to read from
1593  *      data            - buffer where data should be read to
1594  *      offset          - offset in byte where the read should start
1595  *      length          - number of bytes to read
1596  *
1597  * Return Code:
1598  *      n >= 0               - success, n indicates the number of bytes read
1599  *      -1              - error
1600  */
1601 static ssize_t
1602 vd_slice_flabel_read(vd_t *vd, caddr_t data, size_t offset, size_t length)
1603 {
1604         size_t n = 0;
1605         uint_t limit = vd->flabel_limit * vd->vdisk_bsize;
1606 
1607         ASSERT(vd->vdisk_type == VD_DISK_TYPE_SLICE);
1608         ASSERT(vd->flabel != NULL);
1609 
1610         /* if offset is past the fake label limit there's nothing to read */
1611         if (offset >= limit)
1612                 return (0);
1613 
1614         /* data with offset 0 to flabel_size are read from flabel */
1615         if (offset < vd->flabel_size) {
1616 
1617                 if (offset + length <= vd->flabel_size) {
1618                         bcopy(vd->flabel + offset, data, length);
1619                         return (length);
1620                 }
1621 
1622                 n = vd->flabel_size - offset;
1623                 bcopy(vd->flabel + offset, data, n);
1624                 data += n;
1625         }
1626 
1627         /* data with offset from flabel_size to flabel_limit are all zeros */
1628         if (offset + length <= limit) {
1629                 bzero(data, length - n);
1630                 return (length);
1631         }
1632 
1633         bzero(data, limit - offset - n);
1634         return (limit - offset);
1635 }
1636 
1637 /*
1638  * Function:
1639  *      vd_slice_flabel_write
1640  *
1641  * Description:
1642  *      This function simulates a write operation to the fake label of
1643  *      a single-slice disk. Write operations are actually faked and return
1644  *      success although the label is never changed. This is mostly to
1645  *      simulate a successful label update.
1646  *
1647  * Parameters:
1648  *      vd              - single-slice disk to write to
1649  *      data            - buffer where data should be written from
1650  *      offset          - offset in byte where the write should start
1651  *      length          - number of bytes to written
1652  *
1653  * Return Code:
1654  *      n >= 0               - success, n indicates the number of bytes written
1655  *      -1              - error
1656  */
1657 static ssize_t
1658 vd_slice_flabel_write(vd_t *vd, caddr_t data, size_t offset, size_t length)
1659 {
1660         uint_t limit = vd->flabel_limit * vd->vdisk_bsize;
1661         struct dk_label *label;
1662         struct dk_geom geom;
1663         struct extvtoc vtoc;
1664 
1665         ASSERT(vd->vdisk_type == VD_DISK_TYPE_SLICE);
1666         ASSERT(vd->flabel != NULL);
1667 
1668         if (offset >= limit)
1669                 return (0);
1670 
1671         /*
1672          * If this is a request to overwrite the VTOC disk label, check that
1673          * the new label is similar to the previous one and return that the
1674          * write was successful, but note that nothing is actually overwritten.
1675          */
1676         if (vd->vdisk_label == VD_DISK_LABEL_VTOC &&
1677             offset == 0 && length == vd->vdisk_bsize) {
1678                 label = (void *)data;
1679 
1680                 /* check that this is a valid label */
1681                 if (label->dkl_magic != DKL_MAGIC ||
1682                     label->dkl_cksum != vd_lbl2cksum(label))
1683                         return (-1);
1684 
1685                 /* check the vtoc and geometry */
1686                 vd_label_to_vtocgeom(label, &vtoc, &geom);
1687                 if (vd_slice_geom_isvalid(vd, &geom) &&
1688                     vd_slice_vtoc_isvalid(vd, &vtoc))
1689                         return (length);
1690         }
1691 
1692         /* fail any other write */
1693         return (-1);
1694 }
1695 
1696 /*
1697  * Function:
1698  *      vd_slice_fake_rdwr
1699  *
1700  * Description:
1701  *      This function simulates a raw read or write operation to a single-slice
1702  *      disk. It only handles the faked part of the operation i.e. I/Os to
1703  *      blocks which have no mapping with the vdisk backend (I/Os to the
1704  *      beginning and to the end of the vdisk).
1705  *
1706  *      The function returns 0 is the operation is completed and it has been
1707  *      entirely handled as a fake read or write. In that case, lengthp points
1708  *      to the number of bytes not read or written. Values returned by datap
1709  *      and blkp are undefined.
1710  *
1711  *      If the fake operation has succeeded but the read or write is not
1712  *      complete (i.e. the read/write operation extends beyond the blocks
1713  *      we fake) then the function returns EAGAIN and datap, blkp and lengthp
1714  *      pointers points to the parameters for completing the operation.
1715  *
1716  *      In case of an error, for example if the slice is empty or parameters
1717  *      are invalid, then the function returns a non-zero value different
1718  *      from EAGAIN. In that case, the returned values of datap, blkp and
1719  *      lengthp are undefined.
1720  *
1721  * Parameters:
1722  *      vd              - single-slice disk on which the operation is performed
1723  *      slice           - slice on which the operation is performed,
1724  *                        VD_SLICE_NONE indicates that the operation
1725  *                        is done using an absolute disk offset.
1726  *      operation       - operation to execute: read (VD_OP_BREAD) or
1727  *                        write (VD_OP_BWRITE).
1728  *      datap           - pointer to the buffer where data are read to
1729  *                        or written from. Return the pointer where remaining
1730  *                        data have to be read to or written from.
1731  *      blkp            - pointer to the starting block for the operation.
1732  *                        Return the starting block relative to the vdisk
1733  *                        backend for the remaining operation.
1734  *      lengthp         - pointer to the number of bytes to read or write.
1735  *                        This should be a multiple of vdisk_bsize. Return the
1736  *                        remaining number of bytes to read or write.
1737  *
1738  * Return Code:
1739  *      0               - read/write operation is completed
1740  *      EAGAIN          - read/write operation is not completed
1741  *      other values    - error
1742  */
1743 static int
1744 vd_slice_fake_rdwr(vd_t *vd, int slice, int operation, caddr_t *datap,
1745     size_t *blkp, size_t *lengthp)
1746 {
1747         struct dk_label *label;
1748         caddr_t data;
1749         size_t blk, length, csize;
1750         size_t ablk, asize, aoff, alen;
1751         ssize_t n;
1752         int sec, status;
1753         size_t bsize = vd->vdisk_bsize;
1754 
1755         ASSERT(vd->vdisk_type == VD_DISK_TYPE_SLICE);
1756         ASSERT(slice != 0);
1757 
1758         data = *datap;
1759         blk = *blkp;
1760         length = *lengthp;
1761 
1762         /*
1763          * If this is not a raw I/O or an I/O from a full disk slice then
1764          * this is an I/O to/from an empty slice.
1765          */
1766         if (slice != VD_SLICE_NONE &&
1767             (slice != VD_ENTIRE_DISK_SLICE ||
1768             vd->vdisk_label != VD_DISK_LABEL_VTOC) &&
1769             (slice != VD_EFI_WD_SLICE ||
1770             vd->vdisk_label != VD_DISK_LABEL_EFI)) {
1771                 return (EIO);
1772         }
1773 
1774         if (length % bsize != 0)
1775                 return (EINVAL);
1776 
1777         /* handle any I/O with the fake label */
1778         if (operation == VD_OP_BWRITE)
1779                 n = vd_slice_flabel_write(vd, data, blk * bsize, length);
1780         else
1781                 n = vd_slice_flabel_read(vd, data, blk * bsize, length);
1782 
1783         if (n == -1)
1784                 return (EINVAL);
1785 
1786         ASSERT(n % bsize == 0);
1787 
1788         /* adjust I/O arguments */
1789         data += n;
1790         blk += n / bsize;
1791         length -= n;
1792 
1793         /* check if there's something else to process */
1794         if (length == 0) {
1795                 status = 0;
1796                 goto done;
1797         }
1798 
1799         if (vd->vdisk_label == VD_DISK_LABEL_VTOC &&
1800             slice == VD_ENTIRE_DISK_SLICE) {
1801                 status = EAGAIN;
1802                 goto done;
1803         }
1804 
1805         if (vd->vdisk_label == VD_DISK_LABEL_EFI) {
1806                 asize = EFI_MIN_RESV_SIZE + (EFI_MIN_ARRAY_SIZE / bsize) + 1;
1807                 ablk = vd->vdisk_size - asize;
1808         } else {
1809                 ASSERT(vd->vdisk_label == VD_DISK_LABEL_VTOC);
1810                 ASSERT(vd->dk_geom.dkg_apc == 0);
1811 
1812                 csize = vd->dk_geom.dkg_nhead * vd->dk_geom.dkg_nsect;
1813                 ablk = vd->dk_geom.dkg_ncyl * csize;
1814                 asize = vd->dk_geom.dkg_acyl * csize;
1815         }
1816 
1817         alen = length / bsize;
1818         aoff = blk;
1819 
1820         /* if we have reached the last block then the I/O is completed */
1821         if (aoff == ablk + asize) {
1822                 status = 0;
1823                 goto done;
1824         }
1825 
1826         /* if we are past the last block then return an error */
1827         if (aoff > ablk + asize)
1828                 return (EIO);
1829 
1830         /* check if there is any I/O to end of the disk */
1831         if (aoff + alen < ablk) {
1832                 status = EAGAIN;
1833                 goto done;
1834         }
1835 
1836         /* we don't allow any write to the end of the disk */
1837         if (operation == VD_OP_BWRITE)
1838                 return (EIO);
1839 
1840         if (aoff < ablk) {
1841                 alen -= (ablk - aoff);
1842                 aoff = ablk;
1843         }
1844 
1845         if (aoff + alen > ablk + asize) {
1846                 alen = ablk + asize - aoff;
1847         }
1848 
1849         alen *= bsize;
1850 
1851         if (operation == VD_OP_BREAD) {
1852                 bzero(data + (aoff - blk) * bsize, alen);
1853 
1854                 if (vd->vdisk_label == VD_DISK_LABEL_VTOC) {
1855                         /* check if we read backup labels */
1856                         label = VD_LABEL_VTOC(vd);
1857                         ablk += (label->dkl_acyl - 1) * csize +
1858                             (label->dkl_nhead - 1) * label->dkl_nsect;
1859 
1860                         for (sec = 1; (sec < 5 * 2 + 1); sec += 2) {
1861 
1862                                 if (ablk + sec >= blk &&
1863                                     ablk + sec < blk + (length / bsize)) {
1864                                         bcopy(label, data +
1865                                             (ablk + sec - blk) * bsize,
1866                                             sizeof (struct dk_label));
1867                                 }
1868                         }
1869                 }
1870         }
1871 
1872         length -= alen;
1873 
1874         status = (length == 0)? 0: EAGAIN;
1875 
1876 done:
1877         ASSERT(length == 0 || blk >= vd->flabel_limit);
1878 
1879         /*
1880          * Return the parameters for the remaining I/O. The starting block is
1881          * adjusted so that it is relative to the vdisk backend.
1882          */
1883         *datap = data;
1884         *blkp = blk - vd->flabel_limit;
1885         *lengthp = length;
1886 
1887         return (status);
1888 }
1889 
1890 static int
1891 vd_flush_write(vd_t *vd)
1892 {
1893         int status, rval;
1894 
1895         if (vd->file) {
1896                 status = VOP_FSYNC(vd->file_vnode, FSYNC, kcred, NULL);
1897         } else {
1898                 status = ldi_ioctl(vd->ldi_handle[0], DKIOCFLUSHWRITECACHE,
1899                     NULL, vd->open_flags | FKIOCTL, kcred, &rval);
1900         }
1901 
1902         return (status);
1903 }
1904 
1905 static void
1906 vd_bio_task(void *arg)
1907 {
1908         struct buf *buf = (struct buf *)arg;
1909         vd_task_t *task = (vd_task_t *)buf->b_private;
1910         vd_t *vd = task->vd;
1911         ssize_t resid;
1912         int status;
1913 
1914         ASSERT(vd->vdisk_bsize == DEV_BSIZE);
1915 
1916         if (vd->zvol) {
1917 
1918                 status = ldi_strategy(vd->ldi_handle[0], buf);
1919 
1920         } else {
1921 
1922                 ASSERT(vd->file);
1923 
1924                 status = vn_rdwr((buf->b_flags & B_READ)? UIO_READ : UIO_WRITE,
1925                     vd->file_vnode, buf->b_un.b_addr, buf->b_bcount,
1926                     buf->b_lblkno * DEV_BSIZE, UIO_SYSSPACE, 0,
1927                     RLIM64_INFINITY, kcred, &resid);
1928 
1929                 if (status == 0) {
1930                         buf->b_resid = resid;
1931                         biodone(buf);
1932                         return;
1933                 }
1934         }
1935 
1936         if (status != 0) {
1937                 bioerror(buf, status);
1938                 biodone(buf);
1939         }
1940 }
1941 
1942 /*
1943  * We define our own biodone function so that buffers used for
1944  * asynchronous writes are not released when biodone() is called.
1945  */
1946 static int
1947 vd_biodone(struct buf *bp)
1948 {
1949         ASSERT((bp->b_flags & B_DONE) == 0);
1950         ASSERT(SEMA_HELD(&bp->b_sem));
1951 
1952         bp->b_flags |= B_DONE;
1953         sema_v(&bp->b_io);
1954 
1955         return (0);
1956 }
1957 
1958 /*
1959  * Return Values
1960  *      EINPROGRESS     - operation was successfully started
1961  *      EIO             - encountered LDC (aka. task error)
1962  *      0               - operation completed successfully
1963  *
1964  * Side Effect
1965  *     sets request->status = <disk operation status>
1966  */
1967 static int
1968 vd_start_bio(vd_task_t *task)
1969 {
1970         int                     rv, status = 0;
1971         vd_t                    *vd             = task->vd;
1972         vd_dring_payload_t      *request        = task->request;
1973         struct buf              *buf            = &task->buf;
1974         uint8_t                 mtype;
1975         int                     slice;
1976         char                    *bufaddr = 0;
1977         size_t                  buflen;
1978         size_t                  offset, length, nbytes;
1979 
1980         ASSERT(vd != NULL);
1981         ASSERT(request != NULL);
1982 
1983         slice = request->slice;
1984 
1985         ASSERT(slice == VD_SLICE_NONE || slice < vd->nslices);
1986         ASSERT((request->operation == VD_OP_BREAD) ||
1987             (request->operation == VD_OP_BWRITE));
1988 
1989         if (request->nbytes == 0) {
1990                 /* no service for trivial requests */
1991                 request->status = EINVAL;
1992                 return (0);
1993         }
1994 
1995         PR1("%s %lu bytes at block %lu",
1996             (request->operation == VD_OP_BREAD) ? "Read" : "Write",
1997             request->nbytes, request->addr);
1998 
1999         /*
2000          * We have to check the open flags because the functions processing
2001          * the read/write request will not do it.
2002          */
2003         if (request->operation == VD_OP_BWRITE && !(vd->open_flags & FWRITE)) {
2004                 PR0("write fails because backend is opened read-only");
2005                 request->nbytes = 0;
2006                 request->status = EROFS;
2007                 return (0);
2008         }
2009 
2010         mtype = LDC_SHADOW_MAP;
2011 
2012         /* Map memory exported by client */
2013         status = ldc_mem_map(task->mhdl, request->cookie, request->ncookies,
2014             mtype, (request->operation == VD_OP_BREAD) ? LDC_MEM_W : LDC_MEM_R,
2015             &bufaddr, NULL);
2016         if (status != 0) {
2017                 PR0("ldc_mem_map() returned err %d ", status);
2018                 return (EIO);
2019         }
2020 
2021         /*
2022          * The buffer size has to be 8-byte aligned, so the client should have
2023          * sent a buffer which size is roundup to the next 8-byte aligned value.
2024          */
2025         buflen = P2ROUNDUP(request->nbytes, 8);
2026 
2027         status = ldc_mem_acquire(task->mhdl, 0, buflen);
2028         if (status != 0) {
2029                 (void) ldc_mem_unmap(task->mhdl);
2030                 PR0("ldc_mem_acquire() returned err %d ", status);
2031                 return (EIO);
2032         }
2033 
2034         offset = request->addr;
2035         nbytes = request->nbytes;
2036         length = nbytes;
2037 
2038         /* default number of byte returned by the I/O */
2039         request->nbytes = 0;
2040 
2041         if (vd->vdisk_type == VD_DISK_TYPE_SLICE) {
2042 
2043                 if (slice != 0) {
2044                         /* handle any fake I/O */
2045                         rv = vd_slice_fake_rdwr(vd, slice, request->operation,
2046                             &bufaddr, &offset, &length);
2047 
2048                         /* record the number of bytes from the fake I/O */
2049                         request->nbytes = nbytes - length;
2050 
2051                         if (rv == 0) {
2052                                 request->status = 0;
2053                                 goto io_done;
2054                         }
2055 
2056                         if (rv != EAGAIN) {
2057                                 request->nbytes = 0;
2058                                 request->status = EIO;
2059                                 goto io_done;
2060                         }
2061 
2062                         /*
2063                          * If we return with EAGAIN then this means that there
2064                          * are still data to read or write.
2065                          */
2066                         ASSERT(length != 0);
2067 
2068                         /*
2069                          * We need to continue the I/O from the slice backend to
2070                          * complete the request. The variables bufaddr, offset
2071                          * and length have been adjusted to have the right
2072                          * information to do the remaining I/O from the backend.
2073                          * The backend is entirely mapped to slice 0 so we just
2074                          * have to complete the I/O from that slice.
2075                          */
2076                         slice = 0;
2077                 }
2078 
2079         } else if (vd->volume || vd->file) {
2080 
2081                 rv = vd_dskimg_io_params(vd, slice, &offset, &length);
2082                 if (rv != 0) {
2083                         request->status = (rv == ENODATA)? 0: EIO;
2084                         goto io_done;
2085                 }
2086                 slice = 0;
2087 
2088         } else if (slice == VD_SLICE_NONE) {
2089 
2090                 /*
2091                  * This is not a disk image so it is a real disk. We
2092                  * assume that the underlying device driver supports
2093                  * USCSICMD ioctls. This is the case of all SCSI devices
2094                  * (sd, ssd...).
2095                  *
2096                  * In the future if we have non-SCSI disks we would need
2097                  * to invoke the appropriate function to do I/O using an
2098                  * absolute disk offset (for example using DIOCTL_RWCMD
2099                  * for IDE disks).
2100                  */
2101                 rv = vd_scsi_rdwr(vd, request->operation, bufaddr, offset,
2102                     length);
2103                 if (rv != 0) {
2104                         request->status = EIO;
2105                 } else {
2106                         request->nbytes = length;
2107                         request->status = 0;
2108                 }
2109                 goto io_done;
2110         }
2111 
2112         /* Start the block I/O */
2113         bioinit(buf);
2114         buf->b_flags = B_BUSY;
2115         buf->b_bcount        = length;
2116         buf->b_lblkno        = offset;
2117         buf->b_bufsize       = buflen;
2118         buf->b_edev  = vd->dev[slice];
2119         buf->b_un.b_addr = bufaddr;
2120         buf->b_iodone        = vd_biodone;
2121 
2122         if (vd->file || vd->zvol) {
2123                 /*
2124                  * I/O to a file are dispatched to an I/O queue, so that several
2125                  * I/Os can be processed in parallel. We also do that for ZFS
2126                  * volumes because the ZFS volume strategy() function will only
2127                  * return after the I/O is completed (instead of just starting
2128                  * the I/O).
2129                  */
2130 
2131                 if (request->operation == VD_OP_BREAD) {
2132                         buf->b_flags |= B_READ;
2133                 } else {
2134                         /*
2135                          * For ZFS volumes and files, we do an asynchronous
2136                          * write and we will wait for the completion of the
2137                          * write in vd_complete_bio() by flushing the volume
2138                          * or file.
2139                          *
2140                          * This done for performance reasons, so that we can
2141                          * group together several write requests into a single
2142                          * flush operation.
2143                          */
2144                         buf->b_flags |= B_WRITE | B_ASYNC;
2145 
2146                         /*
2147                          * We keep track of the write so that we can group
2148                          * requests when flushing. The write queue has the
2149                          * same number of slots as the dring so this prevents
2150                          * the write queue from wrapping and overwriting
2151                          * existing entries: if the write queue gets full
2152                          * then that means that the dring is full so we stop
2153                          * receiving new requests until an existing request
2154                          * is processed, removed from the write queue and
2155                          * then from the dring.
2156                          */
2157                         task->write_index = vd->write_index;
2158                         vd->write_queue[task->write_index] = buf;
2159                         vd->write_index =
2160                             VD_WRITE_INDEX_NEXT(vd, vd->write_index);
2161                 }
2162 
2163                 buf->b_private = task;
2164 
2165                 ASSERT(vd->ioq != NULL);
2166 
2167                 request->status = 0;
2168                 (void) ddi_taskq_dispatch(task->vd->ioq, vd_bio_task, buf,
2169                     DDI_SLEEP);
2170 
2171         } else {
2172 
2173                 if (request->operation == VD_OP_BREAD) {
2174                         buf->b_flags |= B_READ;
2175                 } else {
2176                         buf->b_flags |= B_WRITE;
2177                 }
2178 
2179                 /* convert VIO block number to buf block number */
2180                 buf->b_lblkno = offset << vd->vio_bshift;
2181 
2182                 request->status = ldi_strategy(vd->ldi_handle[slice], buf);
2183         }
2184 
2185         /*
2186          * This is to indicate to the caller that the request
2187          * needs to be finished by vd_complete_bio() by calling
2188          * biowait() there and waiting for that to return before
2189          * triggering the notification of the vDisk client.
2190          *
2191          * This is necessary when writing to real disks as
2192          * otherwise calls to ldi_strategy() would be serialized
2193          * behind the calls to biowait() and performance would
2194          * suffer.
2195          */
2196         if (request->status == 0)
2197                 return (EINPROGRESS);
2198 
2199         biofini(buf);
2200 
2201 io_done:
2202         /* Clean up after error or completion */
2203         rv = ldc_mem_release(task->mhdl, 0, buflen);
2204         if (rv) {
2205                 PR0("ldc_mem_release() returned err %d ", rv);
2206                 status = EIO;
2207         }
2208         rv = ldc_mem_unmap(task->mhdl);
2209         if (rv) {
2210                 PR0("ldc_mem_unmap() returned err %d ", rv);
2211                 status = EIO;
2212         }
2213 
2214         return (status);
2215 }
2216 
2217 /*
2218  * This function should only be called from vd_notify to ensure that requests
2219  * are responded to in the order that they are received.
2220  */
2221 static int
2222 send_msg(ldc_handle_t ldc_handle, void *msg, size_t msglen)
2223 {
2224         int     status;
2225         size_t  nbytes;
2226 
2227         do {
2228                 nbytes = msglen;
2229                 status = ldc_write(ldc_handle, msg, &nbytes);
2230                 if (status != EWOULDBLOCK)
2231                         break;
2232                 drv_usecwait(vds_ldc_delay);
2233         } while (status == EWOULDBLOCK);
2234 
2235         if (status != 0) {
2236                 if (status != ECONNRESET)
2237                         PR0("ldc_write() returned errno %d", status);
2238                 return (status);
2239         } else if (nbytes != msglen) {
2240                 PR0("ldc_write() performed only partial write");
2241                 return (EIO);
2242         }
2243 
2244         PR1("SENT %lu bytes", msglen);
2245         return (0);
2246 }
2247 
2248 static void
2249 vd_need_reset(vd_t *vd, boolean_t reset_ldc)
2250 {
2251         mutex_enter(&vd->lock);
2252         vd->reset_state      = B_TRUE;
2253         vd->reset_ldc        = reset_ldc;
2254         mutex_exit(&vd->lock);
2255 }
2256 
2257 /*
2258  * Reset the state of the connection with a client, if needed; reset the LDC
2259  * transport as well, if needed.  This function should only be called from the
2260  * "vd_recv_msg", as it waits for tasks - otherwise a deadlock can occur.
2261  */
2262 static void
2263 vd_reset_if_needed(vd_t *vd)
2264 {
2265         int     status = 0;
2266 
2267         mutex_enter(&vd->lock);
2268         if (!vd->reset_state) {
2269                 ASSERT(!vd->reset_ldc);
2270                 mutex_exit(&vd->lock);
2271                 return;
2272         }
2273         mutex_exit(&vd->lock);
2274 
2275         PR0("Resetting connection state with %s", VD_CLIENT(vd));
2276 
2277         /*
2278          * Let any asynchronous I/O complete before possibly pulling the rug
2279          * out from under it; defer checking vd->reset_ldc, as one of the
2280          * asynchronous tasks might set it
2281          */
2282         if (vd->ioq != NULL)
2283                 ddi_taskq_wait(vd->ioq);
2284         ddi_taskq_wait(vd->completionq);
2285 
2286         status = vd_flush_write(vd);
2287         if (status) {
2288                 PR0("flushwrite returned error %d", status);
2289         }
2290 
2291         if ((vd->initialized & VD_DRING) &&
2292             ((status = ldc_mem_dring_unmap(vd->dring_handle)) != 0))
2293                 PR0("ldc_mem_dring_unmap() returned errno %d", status);
2294 
2295         vd_free_dring_task(vd);
2296 
2297         /* Free the staging buffer for msgs */
2298         if (vd->vio_msgp != NULL) {
2299                 kmem_free(vd->vio_msgp, vd->max_msglen);
2300                 vd->vio_msgp = NULL;
2301         }
2302 
2303         /* Free the inband message buffer */
2304         if (vd->inband_task.msg != NULL) {
2305                 kmem_free(vd->inband_task.msg, vd->max_msglen);
2306                 vd->inband_task.msg = NULL;
2307         }
2308 
2309         mutex_enter(&vd->lock);
2310 
2311         if (vd->reset_ldc)
2312                 PR0("taking down LDC channel");
2313         if (vd->reset_ldc && ((status = ldc_down(vd->ldc_handle)) != 0))
2314                 PR0("ldc_down() returned errno %d", status);
2315 
2316         /* Reset exclusive access rights */
2317         vd_reset_access(vd);
2318 
2319         vd->initialized      &= ~(VD_SID | VD_SEQ_NUM | VD_DRING);
2320         vd->state    = VD_STATE_INIT;
2321         vd->max_msglen       = sizeof (vio_msg_t);   /* baseline vio message size */
2322 
2323         /* Allocate the staging buffer */
2324         vd->vio_msgp = kmem_alloc(vd->max_msglen, KM_SLEEP);
2325 
2326         PR0("calling ldc_up\n");
2327         (void) ldc_up(vd->ldc_handle);
2328 
2329         vd->reset_state      = B_FALSE;
2330         vd->reset_ldc        = B_FALSE;
2331 
2332         mutex_exit(&vd->lock);
2333 }
2334 
2335 static void vd_recv_msg(void *arg);
2336 
2337 static void
2338 vd_mark_in_reset(vd_t *vd)
2339 {
2340         int status;
2341 
2342         PR0("vd_mark_in_reset: marking vd in reset\n");
2343 
2344         vd_need_reset(vd, B_FALSE);
2345         status = ddi_taskq_dispatch(vd->startq, vd_recv_msg, vd, DDI_SLEEP);
2346         if (status == DDI_FAILURE) {
2347                 PR0("cannot schedule task to recv msg\n");
2348                 vd_need_reset(vd, B_TRUE);
2349                 return;
2350         }
2351 }
2352 
2353 static int
2354 vd_mark_elem_done(vd_t *vd, int idx, int elem_status, int elem_nbytes)
2355 {
2356         boolean_t               accepted;
2357         int                     status;
2358         on_trap_data_t          otd;
2359         vd_dring_entry_t        *elem = VD_DRING_ELEM(idx);
2360 
2361         if (vd->reset_state)
2362                 return (0);
2363 
2364         /* Acquire the element */
2365         if ((status = VIO_DRING_ACQUIRE(&otd, vd->dring_mtype,
2366             vd->dring_handle, idx, idx)) != 0) {
2367                 if (status == ECONNRESET) {
2368                         vd_mark_in_reset(vd);
2369                         return (0);
2370                 } else {
2371                         return (status);
2372                 }
2373         }
2374 
2375         /* Set the element's status and mark it done */
2376         accepted = (elem->hdr.dstate == VIO_DESC_ACCEPTED);
2377         if (accepted) {
2378                 elem->payload.nbytes = elem_nbytes;
2379                 elem->payload.status = elem_status;
2380                 elem->hdr.dstate     = VIO_DESC_DONE;
2381         } else {
2382                 /* Perhaps client timed out waiting for I/O... */
2383                 PR0("element %u no longer \"accepted\"", idx);
2384                 VD_DUMP_DRING_ELEM(elem);
2385         }
2386         /* Release the element */
2387         if ((status = VIO_DRING_RELEASE(vd->dring_mtype,
2388             vd->dring_handle, idx, idx)) != 0) {
2389                 if (status == ECONNRESET) {
2390                         vd_mark_in_reset(vd);
2391                         return (0);
2392                 } else {
2393                         PR0("VIO_DRING_RELEASE() returned errno %d",
2394                             status);
2395                         return (status);
2396                 }
2397         }
2398 
2399         return (accepted ? 0 : EINVAL);
2400 }
2401 
2402 /*
2403  * Return Values
2404  *      0       - operation completed successfully
2405  *      EIO     - encountered LDC / task error
2406  *
2407  * Side Effect
2408  *      sets request->status = <disk operation status>
2409  */
2410 static int
2411 vd_complete_bio(vd_task_t *task)
2412 {
2413         int                     status          = 0;
2414         int                     rv              = 0;
2415         vd_t                    *vd             = task->vd;
2416         vd_dring_payload_t      *request        = task->request;
2417         struct buf              *buf            = &task->buf;
2418         int                     wid, nwrites;
2419 
2420 
2421         ASSERT(vd != NULL);
2422         ASSERT(request != NULL);
2423         ASSERT(task->msg != NULL);
2424         ASSERT(task->msglen >= sizeof (*task->msg));
2425 
2426         if (buf->b_flags & B_DONE) {
2427                 /*
2428                  * If the I/O is already done then we don't call biowait()
2429                  * because biowait() might already have been called when
2430                  * flushing a previous asynchronous write. So we just
2431                  * retrieve the status of the request.
2432                  */
2433                 request->status = geterror(buf);
2434         } else {
2435                 /*
2436                  * Wait for the I/O. For synchronous I/O, biowait() will return
2437                  * when the I/O has completed. For asynchronous write, it will
2438                  * return the write has been submitted to the backend, but it
2439                  * may not have been committed.
2440                  */
2441                 request->status = biowait(buf);
2442         }
2443 
2444         if (buf->b_flags & B_ASYNC) {
2445                 /*
2446                  * Asynchronous writes are used when writing to a file or a
2447                  * ZFS volume. In that case the bio notification indicates
2448                  * that the write has started. We have to flush the backend
2449                  * to ensure that the write has been committed before marking
2450                  * the request as completed.
2451                  */
2452                 ASSERT(task->request->operation == VD_OP_BWRITE);
2453 
2454                 wid = task->write_index;
2455 
2456                 /* check if write has been already flushed */
2457                 if (vd->write_queue[wid] != NULL) {
2458 
2459                         vd->write_queue[wid] = NULL;
2460                         wid = VD_WRITE_INDEX_NEXT(vd, wid);
2461 
2462                         /*
2463                          * Because flushing is time consuming, it is worth
2464                          * waiting for any other writes so that they can be
2465                          * included in this single flush request.
2466                          */
2467                         if (vd_awflush & VD_AWFLUSH_GROUP) {
2468                                 nwrites = 1;
2469                                 while (vd->write_queue[wid] != NULL) {
2470                                         (void) biowait(vd->write_queue[wid]);
2471                                         vd->write_queue[wid] = NULL;
2472                                         wid = VD_WRITE_INDEX_NEXT(vd, wid);
2473                                         nwrites++;
2474                                 }
2475                                 DTRACE_PROBE2(flushgrp, vd_task_t *, task,
2476                                     int, nwrites);
2477                         }
2478 
2479                         if (vd_awflush & VD_AWFLUSH_IMMEDIATE) {
2480                                 request->status = vd_flush_write(vd);
2481                         } else if (vd_awflush & VD_AWFLUSH_DEFER) {
2482                                 (void) taskq_dispatch(system_taskq,
2483                                     (void (*)(void *))vd_flush_write, vd,
2484                                     DDI_SLEEP);
2485                                 request->status = 0;
2486                         }
2487                 }
2488         }
2489 
2490         /* Update the number of bytes read/written */
2491         request->nbytes += buf->b_bcount - buf->b_resid;
2492 
2493         /* Release the buffer */
2494         if (!vd->reset_state)
2495                 status = ldc_mem_release(task->mhdl, 0, buf->b_bufsize);
2496         if (status) {
2497                 PR0("ldc_mem_release() returned errno %d copying to "
2498                     "client", status);
2499                 if (status == ECONNRESET) {
2500                         vd_mark_in_reset(vd);
2501                 }
2502                 rv = EIO;
2503         }
2504 
2505         /* Unmap the memory, even if in reset */
2506         status = ldc_mem_unmap(task->mhdl);
2507         if (status) {
2508                 PR0("ldc_mem_unmap() returned errno %d copying to client",
2509                     status);
2510                 if (status == ECONNRESET) {
2511                         vd_mark_in_reset(vd);
2512                 }
2513                 rv = EIO;
2514         }
2515 
2516         biofini(buf);
2517 
2518         return (rv);
2519 }
2520 
2521 /*
2522  * Description:
2523  *      This function is called by the two functions called by a taskq
2524  *      [ vd_complete_notify() and vd_serial_notify()) ] to send the
2525  *      message to the client.
2526  *
2527  * Parameters:
2528  *      arg     - opaque pointer to structure containing task to be completed
2529  *
2530  * Return Values
2531  *      None
2532  */
2533 static void
2534 vd_notify(vd_task_t *task)
2535 {
2536         int     status;
2537 
2538         ASSERT(task != NULL);
2539         ASSERT(task->vd != NULL);
2540 
2541         /*
2542          * Send the "ack" or "nack" back to the client; if sending the message
2543          * via LDC fails, arrange to reset both the connection state and LDC
2544          * itself
2545          */
2546         PR2("Sending %s",
2547             (task->msg->tag.vio_subtype == VIO_SUBTYPE_ACK) ? "ACK" : "NACK");
2548 
2549         status = send_msg(task->vd->ldc_handle, task->msg, task->msglen);
2550         switch (status) {
2551         case 0:
2552                 break;
2553         case ECONNRESET:
2554                 vd_mark_in_reset(task->vd);
2555                 break;
2556         default:
2557                 PR0("initiating full reset");
2558                 vd_need_reset(task->vd, B_TRUE);
2559                 break;
2560         }
2561 
2562         DTRACE_PROBE1(task__end, vd_task_t *, task);
2563 }
2564 
2565 /*
2566  * Description:
2567  *      Mark the Dring entry as Done and (if necessary) send an ACK/NACK to
2568  *      the vDisk client
2569  *
2570  * Parameters:
2571  *      task            - structure containing the request sent from client
2572  *
2573  * Return Values
2574  *      None
2575  */
2576 static void
2577 vd_complete_notify(vd_task_t *task)
2578 {
2579         int                     status          = 0;
2580         vd_t                    *vd             = task->vd;
2581         vd_dring_payload_t      *request        = task->request;
2582 
2583         /* Update the dring element for a dring client */
2584         if (!vd->reset_state && (vd->xfer_mode == VIO_DRING_MODE_V1_0)) {
2585                 status = vd_mark_elem_done(vd, task->index,
2586                     request->status, request->nbytes);
2587                 if (status == ECONNRESET)
2588                         vd_mark_in_reset(vd);
2589                 else if (status == EACCES)
2590                         vd_need_reset(vd, B_TRUE);
2591         }
2592 
2593         /*
2594          * If a transport error occurred while marking the element done or
2595          * previously while executing the task, arrange to "nack" the message
2596          * when the final task in the descriptor element range completes
2597          */
2598         if ((status != 0) || (task->status != 0))
2599                 task->msg->tag.vio_subtype = VIO_SUBTYPE_NACK;
2600 
2601         /*
2602          * Only the final task for a range of elements will respond to and
2603          * free the message
2604          */
2605         if (task->type == VD_NONFINAL_RANGE_TASK) {
2606                 return;
2607         }
2608 
2609         /*
2610          * We should only send an ACK/NACK here if we are not currently in
2611          * reset as, depending on how we reset, the dring may have been
2612          * blown away and we don't want to ACK/NACK a message that isn't
2613          * there.
2614          */
2615         if (!vd->reset_state)
2616                 vd_notify(task);
2617 }
2618 
2619 /*
2620  * Description:
2621  *      This is the basic completion function called to handle inband data
2622  *      requests and handshake messages. All it needs to do is trigger a
2623  *      message to the client that the request is completed.
2624  *
2625  * Parameters:
2626  *      arg     - opaque pointer to structure containing task to be completed
2627  *
2628  * Return Values
2629  *      None
2630  */
2631 static void
2632 vd_serial_notify(void *arg)
2633 {
2634         vd_task_t               *task = (vd_task_t *)arg;
2635 
2636         ASSERT(task != NULL);
2637         vd_notify(task);
2638 }
2639 
2640 /* ARGSUSED */
2641 static int
2642 vd_geom2dk_geom(void *vd_buf, size_t vd_buf_len, void *ioctl_arg)
2643 {
2644         VD_GEOM2DK_GEOM((vd_geom_t *)vd_buf, (struct dk_geom *)ioctl_arg);
2645         return (0);
2646 }
2647 
2648 /* ARGSUSED */
2649 static int
2650 vd_vtoc2vtoc(void *vd_buf, size_t vd_buf_len, void *ioctl_arg)
2651 {
2652         VD_VTOC2VTOC((vd_vtoc_t *)vd_buf, (struct extvtoc *)ioctl_arg);
2653         return (0);
2654 }
2655 
2656 static void
2657 dk_geom2vd_geom(void *ioctl_arg, void *vd_buf)
2658 {
2659         DK_GEOM2VD_GEOM((struct dk_geom *)ioctl_arg, (vd_geom_t *)vd_buf);
2660 }
2661 
2662 static void
2663 vtoc2vd_vtoc(void *ioctl_arg, void *vd_buf)
2664 {
2665         VTOC2VD_VTOC((struct extvtoc *)ioctl_arg, (vd_vtoc_t *)vd_buf);
2666 }
2667 
2668 static int
2669 vd_get_efi_in(void *vd_buf, size_t vd_buf_len, void *ioctl_arg)
2670 {
2671         vd_efi_t *vd_efi = (vd_efi_t *)vd_buf;
2672         dk_efi_t *dk_efi = (dk_efi_t *)ioctl_arg;
2673         size_t data_len;
2674 
2675         data_len = vd_buf_len - (sizeof (vd_efi_t) - sizeof (uint64_t));
2676         if (vd_efi->length > data_len)
2677                 return (EINVAL);
2678 
2679         dk_efi->dki_lba = vd_efi->lba;
2680         dk_efi->dki_length = vd_efi->length;
2681         dk_efi->dki_data = kmem_zalloc(vd_efi->length, KM_SLEEP);
2682         return (0);
2683 }
2684 
2685 static void
2686 vd_get_efi_out(void *ioctl_arg, void *vd_buf)
2687 {
2688         int len;
2689         vd_efi_t *vd_efi = (vd_efi_t *)vd_buf;
2690         dk_efi_t *dk_efi = (dk_efi_t *)ioctl_arg;
2691 
2692         len = vd_efi->length;
2693         DK_EFI2VD_EFI(dk_efi, vd_efi);
2694         kmem_free(dk_efi->dki_data, len);
2695 }
2696 
2697 static int
2698 vd_set_efi_in(void *vd_buf, size_t vd_buf_len, void *ioctl_arg)
2699 {
2700         vd_efi_t *vd_efi = (vd_efi_t *)vd_buf;
2701         dk_efi_t *dk_efi = (dk_efi_t *)ioctl_arg;
2702         size_t data_len;
2703 
2704         data_len = vd_buf_len - (sizeof (vd_efi_t) - sizeof (uint64_t));
2705         if (vd_efi->length > data_len)
2706                 return (EINVAL);
2707 
2708         dk_efi->dki_data = kmem_alloc(vd_efi->length, KM_SLEEP);
2709         VD_EFI2DK_EFI(vd_efi, dk_efi);
2710         return (0);
2711 }
2712 
2713 static void
2714 vd_set_efi_out(void *ioctl_arg, void *vd_buf)
2715 {
2716         vd_efi_t *vd_efi = (vd_efi_t *)vd_buf;
2717         dk_efi_t *dk_efi = (dk_efi_t *)ioctl_arg;
2718 
2719         kmem_free(dk_efi->dki_data, vd_efi->length);
2720 }
2721 
2722 static int
2723 vd_scsicmd_in(void *vd_buf, size_t vd_buf_len, void *ioctl_arg)
2724 {
2725         size_t vd_scsi_len;
2726         vd_scsi_t *vd_scsi = (vd_scsi_t *)vd_buf;
2727         struct uscsi_cmd *uscsi = (struct uscsi_cmd *)ioctl_arg;
2728 
2729         /* check buffer size */
2730         vd_scsi_len = VD_SCSI_SIZE;
2731         vd_scsi_len += P2ROUNDUP(vd_scsi->cdb_len, sizeof (uint64_t));
2732         vd_scsi_len += P2ROUNDUP(vd_scsi->sense_len, sizeof (uint64_t));
2733         vd_scsi_len += P2ROUNDUP(vd_scsi->datain_len, sizeof (uint64_t));
2734         vd_scsi_len += P2ROUNDUP(vd_scsi->dataout_len, sizeof (uint64_t));
2735 
2736         ASSERT(vd_scsi_len % sizeof (uint64_t) == 0);
2737 
2738         if (vd_buf_len < vd_scsi_len)
2739                 return (EINVAL);
2740 
2741         /* set flags */
2742         uscsi->uscsi_flags = vd_scsi_debug;
2743 
2744         if (vd_scsi->options & VD_SCSI_OPT_NORETRY) {
2745                 uscsi->uscsi_flags |= USCSI_ISOLATE;
2746                 uscsi->uscsi_flags |= USCSI_DIAGNOSE;
2747         }
2748 
2749         /* task attribute */
2750         switch (vd_scsi->task_attribute) {
2751         case VD_SCSI_TASK_ACA:
2752                 uscsi->uscsi_flags |= USCSI_HEAD;
2753                 break;
2754         case VD_SCSI_TASK_HQUEUE:
2755                 uscsi->uscsi_flags |= USCSI_HTAG;
2756                 break;
2757         case VD_SCSI_TASK_ORDERED:
2758                 uscsi->uscsi_flags |= USCSI_OTAG;
2759                 break;
2760         default:
2761                 uscsi->uscsi_flags |= USCSI_NOTAG;
2762                 break;
2763         }
2764 
2765         /* timeout */
2766         uscsi->uscsi_timeout = vd_scsi->timeout;
2767 
2768         /* cdb data */
2769         uscsi->uscsi_cdb = (caddr_t)VD_SCSI_DATA_CDB(vd_scsi);
2770         uscsi->uscsi_cdblen = vd_scsi->cdb_len;
2771 
2772         /* sense buffer */
2773         if (vd_scsi->sense_len != 0) {
2774                 uscsi->uscsi_flags |= USCSI_RQENABLE;
2775                 uscsi->uscsi_rqbuf = (caddr_t)VD_SCSI_DATA_SENSE(vd_scsi);
2776                 uscsi->uscsi_rqlen = vd_scsi->sense_len;
2777         }
2778 
2779         if (vd_scsi->datain_len != 0 && vd_scsi->dataout_len != 0) {
2780                 /* uscsi does not support read/write request */
2781                 return (EINVAL);
2782         }
2783 
2784         /* request data-in */
2785         if (vd_scsi->datain_len != 0) {
2786                 uscsi->uscsi_flags |= USCSI_READ;
2787                 uscsi->uscsi_buflen = vd_scsi->datain_len;
2788                 uscsi->uscsi_bufaddr = (char *)VD_SCSI_DATA_IN(vd_scsi);
2789         }
2790 
2791         /* request data-out */
2792         if (vd_scsi->dataout_len != 0) {
2793                 uscsi->uscsi_buflen = vd_scsi->dataout_len;
2794                 uscsi->uscsi_bufaddr = (char *)VD_SCSI_DATA_OUT(vd_scsi);
2795         }
2796 
2797         return (0);
2798 }
2799 
2800 static void
2801 vd_scsicmd_out(void *ioctl_arg, void *vd_buf)
2802 {
2803         vd_scsi_t *vd_scsi = (vd_scsi_t *)vd_buf;
2804         struct uscsi_cmd *uscsi = (struct uscsi_cmd *)ioctl_arg;
2805 
2806         /* output fields */
2807         vd_scsi->cmd_status = uscsi->uscsi_status;
2808 
2809         /* sense data */
2810         if ((uscsi->uscsi_flags & USCSI_RQENABLE) &&
2811             (uscsi->uscsi_status == STATUS_CHECK ||
2812             uscsi->uscsi_status == STATUS_TERMINATED)) {
2813                 vd_scsi->sense_status = uscsi->uscsi_rqstatus;
2814                 if (uscsi->uscsi_rqstatus == STATUS_GOOD)
2815                         vd_scsi->sense_len -= uscsi->uscsi_rqresid;
2816                 else
2817                         vd_scsi->sense_len = 0;
2818         } else {
2819                 vd_scsi->sense_len = 0;
2820         }
2821 
2822         if (uscsi->uscsi_status != STATUS_GOOD) {
2823                 vd_scsi->dataout_len = 0;
2824                 vd_scsi->datain_len = 0;
2825                 return;
2826         }
2827 
2828         if (uscsi->uscsi_flags & USCSI_READ) {
2829                 /* request data (read) */
2830                 vd_scsi->datain_len -= uscsi->uscsi_resid;
2831                 vd_scsi->dataout_len = 0;
2832         } else {
2833                 /* request data (write) */
2834                 vd_scsi->datain_len = 0;
2835                 vd_scsi->dataout_len -= uscsi->uscsi_resid;
2836         }
2837 }
2838 
2839 static ushort_t
2840 vd_lbl2cksum(struct dk_label *label)
2841 {
2842         int     count;
2843         ushort_t sum, *sp;
2844 
2845         count = (sizeof (struct dk_label)) / (sizeof (short)) - 1;
2846         sp = (ushort_t *)label;
2847         sum = 0;
2848         while (count--) {
2849                 sum ^= *sp++;
2850         }
2851 
2852         return (sum);
2853 }
2854 
2855 /*
2856  * Copy information from a vtoc and dk_geom structures to a dk_label structure.
2857  */
2858 static void
2859 vd_vtocgeom_to_label(struct extvtoc *vtoc, struct dk_geom *geom,
2860     struct dk_label *label)
2861 {
2862         int i;
2863 
2864         ASSERT(vtoc->v_nparts == V_NUMPAR);
2865         ASSERT(vtoc->v_sanity == VTOC_SANE);
2866 
2867         bzero(label, sizeof (struct dk_label));
2868 
2869         label->dkl_ncyl = geom->dkg_ncyl;
2870         label->dkl_acyl = geom->dkg_acyl;
2871         label->dkl_pcyl = geom->dkg_pcyl;
2872         label->dkl_nhead = geom->dkg_nhead;
2873         label->dkl_nsect = geom->dkg_nsect;
2874         label->dkl_intrlv = geom->dkg_intrlv;
2875         label->dkl_apc = geom->dkg_apc;
2876         label->dkl_rpm = geom->dkg_rpm;
2877         label->dkl_write_reinstruct = geom->dkg_write_reinstruct;
2878         label->dkl_read_reinstruct = geom->dkg_read_reinstruct;
2879 
2880         label->dkl_vtoc.v_nparts = V_NUMPAR;
2881         label->dkl_vtoc.v_sanity = VTOC_SANE;
2882         label->dkl_vtoc.v_version = vtoc->v_version;
2883         for (i = 0; i < V_NUMPAR; i++) {
2884                 label->dkl_vtoc.v_timestamp[i] = vtoc->timestamp[i];
2885                 label->dkl_vtoc.v_part[i].p_tag = vtoc->v_part[i].p_tag;
2886                 label->dkl_vtoc.v_part[i].p_flag = vtoc->v_part[i].p_flag;
2887                 label->dkl_map[i].dkl_cylno = vtoc->v_part[i].p_start /
2888                     (label->dkl_nhead * label->dkl_nsect);
2889                 label->dkl_map[i].dkl_nblk = vtoc->v_part[i].p_size;
2890         }
2891 
2892         /*
2893          * The bootinfo array can not be copied with bcopy() because
2894          * elements are of type long in vtoc (so 64-bit) and of type
2895          * int in dk_vtoc (so 32-bit).
2896          */
2897         label->dkl_vtoc.v_bootinfo[0] = vtoc->v_bootinfo[0];
2898         label->dkl_vtoc.v_bootinfo[1] = vtoc->v_bootinfo[1];
2899         label->dkl_vtoc.v_bootinfo[2] = vtoc->v_bootinfo[2];
2900         bcopy(vtoc->v_asciilabel, label->dkl_asciilabel, LEN_DKL_ASCII);
2901         bcopy(vtoc->v_volume, label->dkl_vtoc.v_volume, LEN_DKL_VVOL);
2902 
2903         /* re-compute checksum */
2904         label->dkl_magic = DKL_MAGIC;
2905         label->dkl_cksum = vd_lbl2cksum(label);
2906 }
2907 
2908 /*
2909  * Copy information from a dk_label structure to a vtoc and dk_geom structures.
2910  */
2911 static void
2912 vd_label_to_vtocgeom(struct dk_label *label, struct extvtoc *vtoc,
2913     struct dk_geom *geom)
2914 {
2915         int i;
2916 
2917         bzero(vtoc, sizeof (struct extvtoc));
2918         bzero(geom, sizeof (struct dk_geom));
2919 
2920         geom->dkg_ncyl = label->dkl_ncyl;
2921         geom->dkg_acyl = label->dkl_acyl;
2922         geom->dkg_nhead = label->dkl_nhead;
2923         geom->dkg_nsect = label->dkl_nsect;
2924         geom->dkg_intrlv = label->dkl_intrlv;
2925         geom->dkg_apc = label->dkl_apc;
2926         geom->dkg_rpm = label->dkl_rpm;
2927         geom->dkg_pcyl = label->dkl_pcyl;
2928         geom->dkg_write_reinstruct = label->dkl_write_reinstruct;
2929         geom->dkg_read_reinstruct = label->dkl_read_reinstruct;
2930 
2931         vtoc->v_sanity = label->dkl_vtoc.v_sanity;
2932         vtoc->v_version = label->dkl_vtoc.v_version;
2933         vtoc->v_sectorsz = DEV_BSIZE;
2934         vtoc->v_nparts = label->dkl_vtoc.v_nparts;
2935 
2936         for (i = 0; i < vtoc->v_nparts; i++) {
2937                 vtoc->v_part[i].p_tag = label->dkl_vtoc.v_part[i].p_tag;
2938                 vtoc->v_part[i].p_flag = label->dkl_vtoc.v_part[i].p_flag;
2939                 vtoc->v_part[i].p_start = label->dkl_map[i].dkl_cylno *
2940                     (label->dkl_nhead * label->dkl_nsect);
2941                 vtoc->v_part[i].p_size = label->dkl_map[i].dkl_nblk;
2942                 vtoc->timestamp[i] = label->dkl_vtoc.v_timestamp[i];
2943         }
2944 
2945         /*
2946          * The bootinfo array can not be copied with bcopy() because
2947          * elements are of type long in vtoc (so 64-bit) and of type
2948          * int in dk_vtoc (so 32-bit).
2949          */
2950         vtoc->v_bootinfo[0] = label->dkl_vtoc.v_bootinfo[0];
2951         vtoc->v_bootinfo[1] = label->dkl_vtoc.v_bootinfo[1];
2952         vtoc->v_bootinfo[2] = label->dkl_vtoc.v_bootinfo[2];
2953         bcopy(label->dkl_asciilabel, vtoc->v_asciilabel, LEN_DKL_ASCII);
2954         bcopy(label->dkl_vtoc.v_volume, vtoc->v_volume, LEN_DKL_VVOL);
2955 }
2956 
2957 /*
2958  * Check if a geometry is valid for a single-slice disk. A geometry is
2959  * considered valid if the main attributes of the geometry match with the
2960  * attributes of the fake geometry we have created.
2961  */
2962 static boolean_t
2963 vd_slice_geom_isvalid(vd_t *vd, struct dk_geom *geom)
2964 {
2965         ASSERT(vd->vdisk_type == VD_DISK_TYPE_SLICE);
2966         ASSERT(vd->vdisk_label == VD_DISK_LABEL_VTOC);
2967 
2968         if (geom->dkg_ncyl != vd->dk_geom.dkg_ncyl ||
2969             geom->dkg_acyl != vd->dk_geom.dkg_acyl ||
2970             geom->dkg_nsect != vd->dk_geom.dkg_nsect ||
2971             geom->dkg_pcyl != vd->dk_geom.dkg_pcyl)
2972                 return (B_FALSE);
2973 
2974         return (B_TRUE);
2975 }
2976 
2977 /*
2978  * Check if a vtoc is valid for a single-slice disk. A vtoc is considered
2979  * valid if the main attributes of the vtoc match with the attributes of the
2980  * fake vtoc we have created.
2981  */
2982 static boolean_t
2983 vd_slice_vtoc_isvalid(vd_t *vd, struct extvtoc *vtoc)
2984 {
2985         size_t csize;
2986         int i;
2987 
2988         ASSERT(vd->vdisk_type == VD_DISK_TYPE_SLICE);
2989         ASSERT(vd->vdisk_label == VD_DISK_LABEL_VTOC);
2990 
2991         if (vtoc->v_sanity != vd->vtoc.v_sanity ||
2992             vtoc->v_version != vd->vtoc.v_version ||
2993             vtoc->v_nparts != vd->vtoc.v_nparts ||
2994             strcmp(vtoc->v_volume, vd->vtoc.v_volume) != 0 ||
2995             strcmp(vtoc->v_asciilabel, vd->vtoc.v_asciilabel) != 0)
2996                 return (B_FALSE);
2997 
2998         /* slice 2 should be unchanged */
2999         if (vtoc->v_part[VD_ENTIRE_DISK_SLICE].p_start !=
3000             vd->vtoc.v_part[VD_ENTIRE_DISK_SLICE].p_start ||
3001             vtoc->v_part[VD_ENTIRE_DISK_SLICE].p_size !=
3002             vd->vtoc.v_part[VD_ENTIRE_DISK_SLICE].p_size)
3003                 return (B_FALSE);
3004 
3005         /*
3006          * Slice 0 should be mostly unchanged and cover most of the disk.
3007          * However we allow some flexibility wrt to the start and the size
3008          * of this slice mainly because we can't exactly know how it will
3009          * be defined by the OS installer.
3010          *
3011          * We allow slice 0 to be defined as starting on any of the first
3012          * 4 cylinders.
3013          */
3014         csize = vd->dk_geom.dkg_nhead * vd->dk_geom.dkg_nsect;
3015 
3016         if (vtoc->v_part[0].p_start > 4 * csize ||
3017             vtoc->v_part[0].p_size > vtoc->v_part[VD_ENTIRE_DISK_SLICE].p_size)
3018                         return (B_FALSE);
3019 
3020         if (vd->vtoc.v_part[0].p_size >= 4 * csize &&
3021             vtoc->v_part[0].p_size < vd->vtoc.v_part[0].p_size - 4 *csize)
3022                         return (B_FALSE);
3023 
3024         /* any other slice should have a size of 0 */
3025         for (i = 1; i < vtoc->v_nparts; i++) {
3026                 if (i != VD_ENTIRE_DISK_SLICE &&
3027                     vtoc->v_part[i].p_size != 0)
3028                         return (B_FALSE);
3029         }
3030 
3031         return (B_TRUE);
3032 }
3033 
3034 /*
3035  * Handle ioctls to a disk slice.
3036  *
3037  * Return Values
3038  *      0       - Indicates that there are no errors in disk operations
3039  *      ENOTSUP - Unknown disk label type or unsupported DKIO ioctl
3040  *      EINVAL  - Not enough room to copy the EFI label
3041  *
3042  */
3043 static int
3044 vd_do_slice_ioctl(vd_t *vd, int cmd, void *ioctl_arg)
3045 {
3046         dk_efi_t *dk_ioc;
3047         struct extvtoc *vtoc;
3048         struct dk_geom *geom;
3049         size_t len, lba;
3050 
3051         ASSERT(vd->vdisk_type == VD_DISK_TYPE_SLICE);
3052 
3053         if (cmd == DKIOCFLUSHWRITECACHE)
3054                 return (vd_flush_write(vd));
3055 
3056         switch (vd->vdisk_label) {
3057 
3058         /* ioctls for a single slice disk with a VTOC label */
3059         case VD_DISK_LABEL_VTOC:
3060 
3061                 switch (cmd) {
3062 
3063                 case DKIOCGGEOM:
3064                         ASSERT(ioctl_arg != NULL);
3065                         bcopy(&vd->dk_geom, ioctl_arg, sizeof (vd->dk_geom));
3066                         return (0);
3067 
3068                 case DKIOCGEXTVTOC:
3069                         ASSERT(ioctl_arg != NULL);
3070                         bcopy(&vd->vtoc, ioctl_arg, sizeof (vd->vtoc));
3071                         return (0);
3072 
3073                 case DKIOCSGEOM:
3074                         ASSERT(ioctl_arg != NULL);
3075                         if (vd_slice_single_slice)
3076                                 return (ENOTSUP);
3077 
3078                         /* fake success only if new geometry is valid */
3079                         geom = (struct dk_geom *)ioctl_arg;
3080                         if (!vd_slice_geom_isvalid(vd, geom))
3081                                 return (EINVAL);
3082 
3083                         return (0);
3084 
3085                 case DKIOCSEXTVTOC:
3086                         ASSERT(ioctl_arg != NULL);
3087                         if (vd_slice_single_slice)
3088                                 return (ENOTSUP);
3089 
3090                         /* fake sucess only if the new vtoc is valid */
3091                         vtoc = (struct extvtoc *)ioctl_arg;
3092                         if (!vd_slice_vtoc_isvalid(vd, vtoc))
3093                                 return (EINVAL);
3094 
3095                         return (0);
3096 
3097                 default:
3098                         return (ENOTSUP);
3099                 }
3100 
3101         /* ioctls for a single slice disk with an EFI label */
3102         case VD_DISK_LABEL_EFI:
3103 
3104                 if (cmd != DKIOCGETEFI && cmd != DKIOCSETEFI)
3105                         return (ENOTSUP);
3106 
3107                 ASSERT(ioctl_arg != NULL);
3108                 dk_ioc = (dk_efi_t *)ioctl_arg;
3109 
3110                 len = dk_ioc->dki_length;
3111                 lba = dk_ioc->dki_lba;
3112 
3113                 if ((lba != VD_EFI_LBA_GPT && lba != VD_EFI_LBA_GPE) ||
3114                     (lba == VD_EFI_LBA_GPT && len < sizeof (efi_gpt_t)) ||
3115                     (lba == VD_EFI_LBA_GPE && len < sizeof (efi_gpe_t)))
3116                         return (EINVAL);
3117 
3118                 switch (cmd) {
3119                 case DKIOCGETEFI:
3120                         len = vd_slice_flabel_read(vd,
3121                             (caddr_t)dk_ioc->dki_data,
3122                             lba * vd->vdisk_bsize, len);
3123 
3124                         ASSERT(len > 0);
3125 
3126                         return (0);
3127 
3128                 case DKIOCSETEFI:
3129                         if (vd_slice_single_slice)
3130                                 return (ENOTSUP);
3131 
3132                         /* we currently don't support writing EFI */
3133                         return (EIO);
3134                 }
3135 
3136         default:
3137                 /* Unknown disk label type */
3138                 return (ENOTSUP);
3139         }
3140 }
3141 
3142 static int
3143 vds_efi_alloc_and_read(vd_t *vd, efi_gpt_t **gpt, efi_gpe_t **gpe)
3144 {
3145         vd_efi_dev_t edev;
3146         int status;
3147 
3148         VD_EFI_DEV_SET(edev, vd, (vd_efi_ioctl_func)vd_backend_ioctl);
3149 
3150         status = vd_efi_alloc_and_read(&edev, gpt, gpe);
3151 
3152         return (status);
3153 }
3154 
3155 static void
3156 vds_efi_free(vd_t *vd, efi_gpt_t *gpt, efi_gpe_t *gpe)
3157 {
3158         vd_efi_dev_t edev;
3159 
3160         VD_EFI_DEV_SET(edev, vd, (vd_efi_ioctl_func)vd_backend_ioctl);
3161 
3162         vd_efi_free(&edev, gpt, gpe);
3163 }
3164 
3165 static int
3166 vd_dskimg_validate_efi(vd_t *vd)
3167 {
3168         efi_gpt_t *gpt;
3169         efi_gpe_t *gpe;
3170         int i, nparts, status;
3171         struct uuid efi_reserved = EFI_RESERVED;
3172 
3173         if ((status = vds_efi_alloc_and_read(vd, &gpt, &gpe)) != 0)
3174                 return (status);
3175 
3176         bzero(&vd->vtoc, sizeof (struct extvtoc));
3177         bzero(&vd->dk_geom, sizeof (struct dk_geom));
3178         bzero(vd->slices, sizeof (vd_slice_t) * VD_MAXPART);
3179 
3180         vd->efi_reserved = -1;
3181 
3182         nparts = gpt->efi_gpt_NumberOfPartitionEntries;
3183 
3184         for (i = 0; i < nparts && i < VD_MAXPART; i++) {
3185 
3186                 if (gpe[i].efi_gpe_StartingLBA == 0 &&
3187                     gpe[i].efi_gpe_EndingLBA == 0) {
3188                         continue;
3189                 }
3190 
3191                 vd->slices[i].start = gpe[i].efi_gpe_StartingLBA;
3192                 vd->slices[i].nblocks = gpe[i].efi_gpe_EndingLBA -
3193                     gpe[i].efi_gpe_StartingLBA + 1;
3194 
3195                 if (bcmp(&gpe[i].efi_gpe_PartitionTypeGUID, &efi_reserved,
3196                     sizeof (struct uuid)) == 0)
3197                         vd->efi_reserved = i;
3198 
3199         }
3200 
3201         ASSERT(vd->vdisk_size != 0);
3202         vd->slices[VD_EFI_WD_SLICE].start = 0;
3203         vd->slices[VD_EFI_WD_SLICE].nblocks = vd->vdisk_size;
3204 
3205         vds_efi_free(vd, gpt, gpe);
3206 
3207         return (status);
3208 }
3209 
3210 /*
3211  * Function:
3212  *      vd_dskimg_validate_geometry
3213  *
3214  * Description:
3215  *      Read the label and validate the geometry of a disk image. The driver
3216  *      label, vtoc and geometry information are updated according to the
3217  *      label read from the disk image.
3218  *
3219  *      If no valid label is found, the label is set to unknown and the
3220  *      function returns EINVAL, but a default vtoc and geometry are provided
3221  *      to the driver. If an EFI label is found, ENOTSUP is returned.
3222  *
3223  * Parameters:
3224  *      vd      - disk on which the operation is performed.
3225  *
3226  * Return Code:
3227  *      0       - success.
3228  *      EIO     - error reading the label from the disk image.
3229  *      EINVAL  - unknown disk label.
3230  *      ENOTSUP - geometry not applicable (EFI label).
3231  */
3232 static int
3233 vd_dskimg_validate_geometry(vd_t *vd)
3234 {
3235         struct dk_label label;
3236         struct dk_geom *geom = &vd->dk_geom;
3237         struct extvtoc *vtoc = &vd->vtoc;
3238         int i;
3239         int status = 0;
3240 
3241         ASSERT(VD_DSKIMG(vd));
3242 
3243         if (VD_DSKIMG_LABEL_READ(vd, &label) < 0)
3244                 return (EIO);
3245 
3246         if (label.dkl_magic != DKL_MAGIC ||
3247             label.dkl_cksum != vd_lbl2cksum(&label) ||
3248             (vd_dskimg_validate_sanity &&
3249             label.dkl_vtoc.v_sanity != VTOC_SANE) ||
3250             label.dkl_vtoc.v_nparts != V_NUMPAR) {
3251 
3252                 if (vd_dskimg_validate_efi(vd) == 0) {
3253                         vd->vdisk_label = VD_DISK_LABEL_EFI;
3254                         return (ENOTSUP);
3255                 }
3256 
3257                 vd->vdisk_label = VD_DISK_LABEL_UNK;
3258                 vd_build_default_label(vd->dskimg_size, vd->vdisk_bsize,
3259                     &label);
3260                 status = EINVAL;
3261         } else {
3262                 vd->vdisk_label = VD_DISK_LABEL_VTOC;
3263         }
3264 
3265         /* Update the driver geometry and vtoc */
3266         vd_label_to_vtocgeom(&label, vtoc, geom);
3267 
3268         /* Update logical partitions */
3269         bzero(vd->slices, sizeof (vd_slice_t) * VD_MAXPART);
3270         if (vd->vdisk_label != VD_DISK_LABEL_UNK) {
3271                 for (i = 0; i < vtoc->v_nparts; i++) {
3272                         vd->slices[i].start = vtoc->v_part[i].p_start;
3273                         vd->slices[i].nblocks = vtoc->v_part[i].p_size;
3274                 }
3275         }
3276 
3277         return (status);
3278 }
3279 
3280 /*
3281  * Handle ioctls to a disk image.
3282  *
3283  * Return Values
3284  *      0       - Indicates that there are no errors
3285  *      != 0    - Disk operation returned an error
3286  */
3287 static int
3288 vd_do_dskimg_ioctl(vd_t *vd, int cmd, void *ioctl_arg)
3289 {
3290         struct dk_label label;
3291         struct dk_geom *geom;
3292         struct extvtoc *vtoc;
3293         dk_efi_t *efi;
3294         int rc;
3295 
3296         ASSERT(VD_DSKIMG(vd));
3297 
3298         switch (cmd) {
3299 
3300         case DKIOCGGEOM:
3301                 ASSERT(ioctl_arg != NULL);
3302                 geom = (struct dk_geom *)ioctl_arg;
3303 
3304                 rc = vd_dskimg_validate_geometry(vd);
3305                 if (rc != 0 && rc != EINVAL)
3306                         return (rc);
3307                 bcopy(&vd->dk_geom, geom, sizeof (struct dk_geom));
3308                 return (0);
3309 
3310         case DKIOCGEXTVTOC:
3311                 ASSERT(ioctl_arg != NULL);
3312                 vtoc = (struct extvtoc *)ioctl_arg;
3313 
3314                 rc = vd_dskimg_validate_geometry(vd);
3315                 if (rc != 0 && rc != EINVAL)
3316                         return (rc);
3317                 bcopy(&vd->vtoc, vtoc, sizeof (struct extvtoc));
3318                 return (0);
3319 
3320         case DKIOCSGEOM:
3321                 ASSERT(ioctl_arg != NULL);
3322                 geom = (struct dk_geom *)ioctl_arg;
3323 
3324                 if (geom->dkg_nhead == 0 || geom->dkg_nsect == 0)
3325                         return (EINVAL);
3326 
3327                 /*
3328                  * The current device geometry is not updated, just the driver
3329                  * "notion" of it. The device geometry will be effectively
3330                  * updated when a label is written to the device during a next
3331                  * DKIOCSEXTVTOC.
3332                  */
3333                 bcopy(ioctl_arg, &vd->dk_geom, sizeof (vd->dk_geom));
3334                 return (0);
3335 
3336         case DKIOCSEXTVTOC:
3337                 ASSERT(ioctl_arg != NULL);
3338                 ASSERT(vd->dk_geom.dkg_nhead != 0 &&
3339                     vd->dk_geom.dkg_nsect != 0);
3340                 vtoc = (struct extvtoc *)ioctl_arg;
3341 
3342                 if (vtoc->v_sanity != VTOC_SANE ||
3343                     vtoc->v_sectorsz != DEV_BSIZE ||
3344                     vtoc->v_nparts != V_NUMPAR)
3345                         return (EINVAL);
3346 
3347                 vd_vtocgeom_to_label(vtoc, &vd->dk_geom, &label);
3348 
3349                 /* write label to the disk image */
3350                 if ((rc = vd_dskimg_set_vtoc(vd, &label)) != 0)
3351                         return (rc);
3352 
3353                 break;
3354 
3355         case DKIOCFLUSHWRITECACHE:
3356                 return (vd_flush_write(vd));
3357 
3358         case DKIOCGETEFI:
3359                 ASSERT(ioctl_arg != NULL);
3360                 efi = (dk_efi_t *)ioctl_arg;
3361 
3362                 if (vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BREAD,
3363                     (caddr_t)efi->dki_data, efi->dki_lba, efi->dki_length) < 0)
3364                         return (EIO);
3365 
3366                 return (0);
3367 
3368         case DKIOCSETEFI:
3369                 ASSERT(ioctl_arg != NULL);
3370                 efi = (dk_efi_t *)ioctl_arg;
3371 
3372                 if (vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BWRITE,
3373                     (caddr_t)efi->dki_data, efi->dki_lba, efi->dki_length) < 0)
3374                         return (EIO);
3375 
3376                 break;
3377 
3378 
3379         default:
3380                 return (ENOTSUP);
3381         }
3382 
3383         ASSERT(cmd == DKIOCSEXTVTOC || cmd == DKIOCSETEFI);
3384 
3385         /* label has changed, revalidate the geometry */
3386         (void) vd_dskimg_validate_geometry(vd);
3387 
3388         /*
3389          * The disk geometry may have changed, so we need to write
3390          * the devid (if there is one) so that it is stored at the
3391          * right location.
3392          */
3393         if (vd_dskimg_write_devid(vd, vd->dskimg_devid) != 0) {
3394                 PR0("Fail to write devid");
3395         }
3396 
3397         return (0);
3398 }
3399 
3400 static int
3401 vd_backend_ioctl(vd_t *vd, int cmd, caddr_t arg)
3402 {
3403         int rval = 0, status;
3404         struct vtoc vtoc;
3405 
3406         /*
3407          * Call the appropriate function to execute the ioctl depending
3408          * on the type of vdisk.
3409          */
3410         if (vd->vdisk_type == VD_DISK_TYPE_SLICE) {
3411 
3412                 /* slice, file or volume exported as a single slice disk */
3413                 status = vd_do_slice_ioctl(vd, cmd, arg);
3414 
3415         } else if (VD_DSKIMG(vd)) {
3416 
3417                 /* file or volume exported as a full disk */
3418                 status = vd_do_dskimg_ioctl(vd, cmd, arg);
3419 
3420         } else {
3421 
3422                 /* disk device exported as a full disk */
3423                 status = ldi_ioctl(vd->ldi_handle[0], cmd, (intptr_t)arg,
3424                     vd->open_flags | FKIOCTL, kcred, &rval);
3425 
3426                 /*
3427                  * By default VTOC ioctls are done using ioctls for the
3428                  * extended VTOC. Some drivers (in particular non-Sun drivers)
3429                  * may not support these ioctls. In that case, we fallback to
3430                  * the regular VTOC ioctls.
3431                  */
3432                 if (status == ENOTTY) {
3433                         switch (cmd) {
3434 
3435                         case DKIOCGEXTVTOC:
3436                                 cmd = DKIOCGVTOC;
3437                                 status = ldi_ioctl(vd->ldi_handle[0], cmd,
3438                                     (intptr_t)&vtoc, vd->open_flags | FKIOCTL,
3439                                     kcred, &rval);
3440                                 vtoctoextvtoc(vtoc,
3441                                     (*(struct extvtoc *)(void *)arg));
3442                                 break;
3443 
3444                         case DKIOCSEXTVTOC:
3445                                 cmd = DKIOCSVTOC;
3446                                 extvtoctovtoc((*(struct extvtoc *)(void *)arg),
3447                                     vtoc);
3448                                 status = ldi_ioctl(vd->ldi_handle[0], cmd,
3449                                     (intptr_t)&vtoc, vd->open_flags | FKIOCTL,
3450                                     kcred, &rval);
3451                                 break;
3452                         }
3453                 }
3454         }
3455 
3456 #ifdef DEBUG
3457         if (rval != 0) {
3458                 PR0("ioctl %x set rval = %d, which is not being returned"
3459                     " to caller", cmd, rval);
3460         }
3461 #endif /* DEBUG */
3462 
3463         return (status);
3464 }
3465 
3466 /*
3467  * Description:
3468  *      This is the function that processes the ioctl requests (farming it
3469  *      out to functions that handle slices, files or whole disks)
3470  *
3471  * Return Values
3472  *     0                - ioctl operation completed successfully
3473  *     != 0             - The LDC error value encountered
3474  *                        (propagated back up the call stack as a task error)
3475  *
3476  * Side Effect
3477  *     sets request->status to the return value of the ioctl function.
3478  */
3479 static int
3480 vd_do_ioctl(vd_t *vd, vd_dring_payload_t *request, void* buf, vd_ioctl_t *ioctl)
3481 {
3482         int     status = 0;
3483         size_t  nbytes = request->nbytes;    /* modifiable copy */
3484 
3485 
3486         ASSERT(request->slice < vd->nslices);
3487         PR0("Performing %s", ioctl->operation_name);
3488 
3489         /* Get data from client and convert, if necessary */
3490         if (ioctl->copyin != NULL)  {
3491                 ASSERT(nbytes != 0 && buf != NULL);
3492                 PR1("Getting \"arg\" data from client");
3493                 if ((status = ldc_mem_copy(vd->ldc_handle, buf, 0, &nbytes,
3494                     request->cookie, request->ncookies,
3495                     LDC_COPY_IN)) != 0) {
3496                         PR0("ldc_mem_copy() returned errno %d "
3497                             "copying from client", status);
3498                         return (status);
3499                 }
3500 
3501                 /* Convert client's data, if necessary */
3502                 if (ioctl->copyin == VD_IDENTITY_IN) {
3503                         /* use client buffer */
3504                         ioctl->arg = buf;
3505                 } else {
3506                         /* convert client vdisk operation data to ioctl data */
3507                         status = (ioctl->copyin)(buf, nbytes,
3508                             (void *)ioctl->arg);
3509                         if (status != 0) {
3510                                 request->status = status;
3511                                 return (0);
3512                         }
3513                 }
3514         }
3515 
3516         if (ioctl->operation == VD_OP_SCSICMD) {
3517                 struct uscsi_cmd *uscsi = (struct uscsi_cmd *)ioctl->arg;
3518 
3519                 /* check write permission */
3520                 if (!(vd->open_flags & FWRITE) &&
3521                     !(uscsi->uscsi_flags & USCSI_READ)) {
3522                         PR0("uscsi fails because backend is opened read-only");
3523                         request->status = EROFS;
3524                         return (0);
3525                 }
3526         }
3527 
3528         /*
3529          * Send the ioctl to the disk backend.
3530          */
3531         request->status = vd_backend_ioctl(vd, ioctl->cmd, ioctl->arg);
3532 
3533         if (request->status != 0) {
3534                 PR0("ioctl(%s) = errno %d", ioctl->cmd_name, request->status);
3535                 if (ioctl->operation == VD_OP_SCSICMD &&
3536                     ((struct uscsi_cmd *)ioctl->arg)->uscsi_status != 0)
3537                         /*
3538                          * USCSICMD has reported an error and the uscsi_status
3539                          * field is not zero. This means that the SCSI command
3540                          * has completed but it has an error. So we should
3541                          * mark the VD operation has succesfully completed
3542                          * and clients can check the SCSI status field for
3543                          * SCSI errors.
3544                          */
3545                         request->status = 0;
3546                 else
3547                         return (0);
3548         }
3549 
3550         /* Convert data and send to client, if necessary */
3551         if (ioctl->copyout != NULL)  {
3552                 ASSERT(nbytes != 0 && buf != NULL);
3553                 PR1("Sending \"arg\" data to client");
3554 
3555                 /* Convert ioctl data to vdisk operation data, if necessary */
3556                 if (ioctl->copyout != VD_IDENTITY_OUT)
3557                         (ioctl->copyout)((void *)ioctl->arg, buf);
3558 
3559                 if ((status = ldc_mem_copy(vd->ldc_handle, buf, 0, &nbytes,
3560                     request->cookie, request->ncookies,
3561                     LDC_COPY_OUT)) != 0) {
3562                         PR0("ldc_mem_copy() returned errno %d "
3563                             "copying to client", status);
3564                         return (status);
3565                 }
3566         }
3567 
3568         return (status);
3569 }
3570 
3571 #define RNDSIZE(expr) P2ROUNDUP(sizeof (expr), sizeof (uint64_t))
3572 
3573 /*
3574  * Description:
3575  *      This generic function is called by the task queue to complete
3576  *      the processing of the tasks. The specific completion function
3577  *      is passed in as a field in the task pointer.
3578  *
3579  * Parameters:
3580  *      arg     - opaque pointer to structure containing task to be completed
3581  *
3582  * Return Values
3583  *      None
3584  */
3585 static void
3586 vd_complete(void *arg)
3587 {
3588         vd_task_t       *task = (vd_task_t *)arg;
3589 
3590         ASSERT(task != NULL);
3591         ASSERT(task->status == EINPROGRESS);
3592         ASSERT(task->completef != NULL);
3593 
3594         task->status = task->completef(task);
3595         if (task->status)
3596                 PR0("%s: Error %d completing task", __func__, task->status);
3597 
3598         /* Now notify the vDisk client */
3599         vd_complete_notify(task);
3600 }
3601 
3602 static int
3603 vd_ioctl(vd_task_t *task)
3604 {
3605         int                     i, status;
3606         void                    *buf = NULL;
3607         struct dk_geom          dk_geom = {0};
3608         struct extvtoc          vtoc = {0};
3609         struct dk_efi           dk_efi = {0};
3610         struct uscsi_cmd        uscsi = {0};
3611         vd_t                    *vd             = task->vd;
3612         vd_dring_payload_t      *request        = task->request;
3613         vd_ioctl_t              ioctl[] = {
3614                 /* Command (no-copy) operations */
3615                 {VD_OP_FLUSH, STRINGIZE(VD_OP_FLUSH), 0,
3616                     DKIOCFLUSHWRITECACHE, STRINGIZE(DKIOCFLUSHWRITECACHE),
3617                     NULL, NULL, NULL, B_TRUE},
3618 
3619                 /* "Get" (copy-out) operations */
3620                 {VD_OP_GET_WCE, STRINGIZE(VD_OP_GET_WCE), RNDSIZE(int),
3621                     DKIOCGETWCE, STRINGIZE(DKIOCGETWCE),
3622                     NULL, VD_IDENTITY_IN, VD_IDENTITY_OUT, B_FALSE},
3623                 {VD_OP_GET_DISKGEOM, STRINGIZE(VD_OP_GET_DISKGEOM),
3624                     RNDSIZE(vd_geom_t),
3625                     DKIOCGGEOM, STRINGIZE(DKIOCGGEOM),
3626                     &dk_geom, NULL, dk_geom2vd_geom, B_FALSE},
3627                 {VD_OP_GET_VTOC, STRINGIZE(VD_OP_GET_VTOC), RNDSIZE(vd_vtoc_t),
3628                     DKIOCGEXTVTOC, STRINGIZE(DKIOCGEXTVTOC),
3629                     &vtoc, NULL, vtoc2vd_vtoc, B_FALSE},
3630                 {VD_OP_GET_EFI, STRINGIZE(VD_OP_GET_EFI), RNDSIZE(vd_efi_t),
3631                     DKIOCGETEFI, STRINGIZE(DKIOCGETEFI),
3632                     &dk_efi, vd_get_efi_in, vd_get_efi_out, B_FALSE},
3633 
3634                 /* "Set" (copy-in) operations */
3635                 {VD_OP_SET_WCE, STRINGIZE(VD_OP_SET_WCE), RNDSIZE(int),
3636                     DKIOCSETWCE, STRINGIZE(DKIOCSETWCE),
3637                     NULL, VD_IDENTITY_IN, VD_IDENTITY_OUT, B_TRUE},
3638                 {VD_OP_SET_DISKGEOM, STRINGIZE(VD_OP_SET_DISKGEOM),
3639                     RNDSIZE(vd_geom_t),
3640                     DKIOCSGEOM, STRINGIZE(DKIOCSGEOM),
3641                     &dk_geom, vd_geom2dk_geom, NULL, B_TRUE},
3642                 {VD_OP_SET_VTOC, STRINGIZE(VD_OP_SET_VTOC), RNDSIZE(vd_vtoc_t),
3643                     DKIOCSEXTVTOC, STRINGIZE(DKIOCSEXTVTOC),
3644                     &vtoc, vd_vtoc2vtoc, NULL, B_TRUE},
3645                 {VD_OP_SET_EFI, STRINGIZE(VD_OP_SET_EFI), RNDSIZE(vd_efi_t),
3646                     DKIOCSETEFI, STRINGIZE(DKIOCSETEFI),
3647                     &dk_efi, vd_set_efi_in, vd_set_efi_out, B_TRUE},
3648 
3649                 {VD_OP_SCSICMD, STRINGIZE(VD_OP_SCSICMD), RNDSIZE(vd_scsi_t),
3650                     USCSICMD, STRINGIZE(USCSICMD),
3651                     &uscsi, vd_scsicmd_in, vd_scsicmd_out, B_FALSE},
3652         };
3653         size_t          nioctls = (sizeof (ioctl))/(sizeof (ioctl[0]));
3654 
3655 
3656         ASSERT(vd != NULL);
3657         ASSERT(request != NULL);
3658         ASSERT(request->slice < vd->nslices);
3659 
3660         /*
3661          * Determine ioctl corresponding to caller's "operation" and
3662          * validate caller's "nbytes"
3663          */
3664         for (i = 0; i < nioctls; i++) {
3665                 if (request->operation == ioctl[i].operation) {
3666                         /* LDC memory operations require 8-byte multiples */
3667                         ASSERT(ioctl[i].nbytes % sizeof (uint64_t) == 0);
3668 
3669                         if (request->operation == VD_OP_GET_EFI ||
3670                             request->operation == VD_OP_SET_EFI ||
3671                             request->operation == VD_OP_SCSICMD) {
3672                                 if (request->nbytes >= ioctl[i].nbytes)
3673                                         break;
3674                                 PR0("%s:  Expected at least nbytes = %lu, "
3675                                     "got %lu", ioctl[i].operation_name,
3676                                     ioctl[i].nbytes, request->nbytes);
3677                                 return (EINVAL);
3678                         }
3679 
3680                         if (request->nbytes != ioctl[i].nbytes) {
3681                                 PR0("%s:  Expected nbytes = %lu, got %lu",
3682                                     ioctl[i].operation_name, ioctl[i].nbytes,
3683                                     request->nbytes);
3684                                 return (EINVAL);
3685                         }
3686 
3687                         break;
3688                 }
3689         }
3690         ASSERT(i < nioctls); /* because "operation" already validated */
3691 
3692         if (!(vd->open_flags & FWRITE) && ioctl[i].write) {
3693                 PR0("%s fails because backend is opened read-only",
3694                     ioctl[i].operation_name);
3695                 request->status = EROFS;
3696                 return (0);
3697         }
3698 
3699         if (request->nbytes)
3700                 buf = kmem_zalloc(request->nbytes, KM_SLEEP);
3701         status = vd_do_ioctl(vd, request, buf, &ioctl[i]);
3702         if (request->nbytes)
3703                 kmem_free(buf, request->nbytes);
3704 
3705         return (status);
3706 }
3707 
3708 static int
3709 vd_get_devid(vd_task_t *task)
3710 {
3711         vd_t *vd = task->vd;
3712         vd_dring_payload_t *request = task->request;
3713         vd_devid_t *vd_devid;
3714         impl_devid_t *devid;
3715         int status, bufid_len, devid_len, len, sz;
3716         int bufbytes;
3717 
3718         PR1("Get Device ID, nbytes=%ld", request->nbytes);
3719 
3720         if (vd->vdisk_type == VD_DISK_TYPE_SLICE) {
3721                 /*
3722                  * We don't support devid for single-slice disks because we
3723                  * have no space to store a fabricated devid and for physical
3724                  * disk slices, we can't use the devid of the disk otherwise
3725                  * exporting multiple slices from the same disk will produce
3726                  * the same devids.
3727                  */
3728                 PR2("No Device ID for slices");
3729                 request->status = ENOTSUP;
3730                 return (0);
3731         }
3732 
3733         if (VD_DSKIMG(vd)) {
3734                 if (vd->dskimg_devid == NULL) {
3735                         PR2("No Device ID");
3736                         request->status = ENOENT;
3737                         return (0);
3738                 } else {
3739                         sz = ddi_devid_sizeof(vd->dskimg_devid);
3740                         devid = kmem_alloc(sz, KM_SLEEP);
3741                         bcopy(vd->dskimg_devid, devid, sz);
3742                 }
3743         } else {
3744                 if (ddi_lyr_get_devid(vd->dev[request->slice],
3745                     (ddi_devid_t *)&devid) != DDI_SUCCESS) {
3746                         PR2("No Device ID");
3747                         request->status = ENOENT;
3748                         return (0);
3749                 }
3750         }
3751 
3752         bufid_len = request->nbytes - sizeof (vd_devid_t) + 1;
3753         devid_len = DEVID_GETLEN(devid);
3754 
3755         /*
3756          * Save the buffer size here for use in deallocation.
3757          * The actual number of bytes copied is returned in
3758          * the 'nbytes' field of the request structure.
3759          */
3760         bufbytes = request->nbytes;
3761 
3762         vd_devid = kmem_zalloc(bufbytes, KM_SLEEP);
3763         vd_devid->length = devid_len;
3764         vd_devid->type = DEVID_GETTYPE(devid);
3765 
3766         len = (devid_len > bufid_len)? bufid_len : devid_len;
3767 
3768         bcopy(devid->did_id, vd_devid->id, len);
3769 
3770         request->status = 0;
3771 
3772         /* LDC memory operations require 8-byte multiples */
3773         ASSERT(request->nbytes % sizeof (uint64_t) == 0);
3774 
3775         if ((status = ldc_mem_copy(vd->ldc_handle, (caddr_t)vd_devid, 0,
3776             &request->nbytes, request->cookie, request->ncookies,
3777             LDC_COPY_OUT)) != 0) {
3778                 PR0("ldc_mem_copy() returned errno %d copying to client",
3779                     status);
3780         }
3781         PR1("post mem_copy: nbytes=%ld", request->nbytes);
3782 
3783         kmem_free(vd_devid, bufbytes);
3784         ddi_devid_free((ddi_devid_t)devid);
3785 
3786         return (status);
3787 }
3788 
3789 static int
3790 vd_scsi_reset(vd_t *vd)
3791 {
3792         int rval, status;
3793         struct uscsi_cmd uscsi = { 0 };
3794 
3795         uscsi.uscsi_flags = vd_scsi_debug | USCSI_RESET;
3796         uscsi.uscsi_timeout = vd_scsi_rdwr_timeout;
3797 
3798         status = ldi_ioctl(vd->ldi_handle[0], USCSICMD, (intptr_t)&uscsi,
3799             (vd->open_flags | FKIOCTL), kcred, &rval);
3800 
3801         return (status);
3802 }
3803 
3804 static int
3805 vd_reset(vd_task_t *task)
3806 {
3807         vd_t *vd = task->vd;
3808         vd_dring_payload_t *request = task->request;
3809 
3810         ASSERT(request->operation == VD_OP_RESET);
3811         ASSERT(vd->scsi);
3812 
3813         PR0("Performing VD_OP_RESET");
3814 
3815         if (request->nbytes != 0) {
3816                 PR0("VD_OP_RESET:  Expected nbytes = 0, got %lu",
3817                     request->nbytes);
3818                 return (EINVAL);
3819         }
3820 
3821         request->status = vd_scsi_reset(vd);
3822 
3823         return (0);
3824 }
3825 
3826 static int
3827 vd_get_capacity(vd_task_t *task)
3828 {
3829         int rv;
3830         size_t nbytes;
3831         vd_t *vd = task->vd;
3832         vd_dring_payload_t *request = task->request;
3833         vd_capacity_t vd_cap = { 0 };
3834 
3835         ASSERT(request->operation == VD_OP_GET_CAPACITY);
3836 
3837         PR0("Performing VD_OP_GET_CAPACITY");
3838 
3839         nbytes = request->nbytes;
3840 
3841         if (nbytes != RNDSIZE(vd_capacity_t)) {
3842                 PR0("VD_OP_GET_CAPACITY:  Expected nbytes = %lu, got %lu",
3843                     RNDSIZE(vd_capacity_t), nbytes);
3844                 return (EINVAL);
3845         }
3846 
3847         /*
3848          * Check the backend size in case it has changed. If the check fails
3849          * then we will return the last known size.
3850          */
3851 
3852         (void) vd_backend_check_size(vd);
3853         ASSERT(vd->vdisk_size != 0);
3854 
3855         request->status = 0;
3856 
3857         vd_cap.vdisk_block_size = vd->vdisk_bsize;
3858         vd_cap.vdisk_size = vd->vdisk_size;
3859 
3860         if ((rv = ldc_mem_copy(vd->ldc_handle, (char *)&vd_cap, 0, &nbytes,
3861             request->cookie, request->ncookies, LDC_COPY_OUT)) != 0) {
3862                 PR0("ldc_mem_copy() returned errno %d copying to client", rv);
3863                 return (rv);
3864         }
3865 
3866         return (0);
3867 }
3868 
3869 static int
3870 vd_get_access(vd_task_t *task)
3871 {
3872         uint64_t access;
3873         int rv, rval = 0;
3874         size_t nbytes;
3875         vd_t *vd = task->vd;
3876         vd_dring_payload_t *request = task->request;
3877 
3878         ASSERT(request->operation == VD_OP_GET_ACCESS);
3879         ASSERT(vd->scsi);
3880 
3881         PR0("Performing VD_OP_GET_ACCESS");
3882 
3883         nbytes = request->nbytes;
3884 
3885         if (nbytes != sizeof (uint64_t)) {
3886                 PR0("VD_OP_GET_ACCESS:  Expected nbytes = %lu, got %lu",
3887                     sizeof (uint64_t), nbytes);
3888                 return (EINVAL);
3889         }
3890 
3891         request->status = ldi_ioctl(vd->ldi_handle[request->slice], MHIOCSTATUS,
3892             NULL, (vd->open_flags | FKIOCTL), kcred, &rval);
3893 
3894         if (request->status != 0)
3895                 return (0);
3896 
3897         access = (rval == 0)? VD_ACCESS_ALLOWED : VD_ACCESS_DENIED;
3898 
3899         if ((rv = ldc_mem_copy(vd->ldc_handle, (char *)&access, 0, &nbytes,
3900             request->cookie, request->ncookies, LDC_COPY_OUT)) != 0) {
3901                 PR0("ldc_mem_copy() returned errno %d copying to client", rv);
3902                 return (rv);
3903         }
3904 
3905         return (0);
3906 }
3907 
3908 static int
3909 vd_set_access(vd_task_t *task)
3910 {
3911         uint64_t flags;
3912         int rv, rval;
3913         size_t nbytes;
3914         vd_t *vd = task->vd;
3915         vd_dring_payload_t *request = task->request;
3916 
3917         ASSERT(request->operation == VD_OP_SET_ACCESS);
3918         ASSERT(vd->scsi);
3919 
3920         nbytes = request->nbytes;
3921 
3922         if (nbytes != sizeof (uint64_t)) {
3923                 PR0("VD_OP_SET_ACCESS:  Expected nbytes = %lu, got %lu",
3924                     sizeof (uint64_t), nbytes);
3925                 return (EINVAL);
3926         }
3927 
3928         if ((rv = ldc_mem_copy(vd->ldc_handle, (char *)&flags, 0, &nbytes,
3929             request->cookie, request->ncookies, LDC_COPY_IN)) != 0) {
3930                 PR0("ldc_mem_copy() returned errno %d copying from client", rv);
3931                 return (rv);
3932         }
3933 
3934         if (flags == VD_ACCESS_SET_CLEAR) {
3935                 PR0("Performing VD_OP_SET_ACCESS (CLEAR)");
3936                 request->status = ldi_ioctl(vd->ldi_handle[request->slice],
3937                     MHIOCRELEASE, NULL, (vd->open_flags | FKIOCTL), kcred,
3938                     &rval);
3939                 if (request->status == 0)
3940                         vd->ownership = B_FALSE;
3941                 return (0);
3942         }
3943 
3944         /*
3945          * As per the VIO spec, the PREEMPT and PRESERVE flags are only valid
3946          * when the EXCLUSIVE flag is set.
3947          */
3948         if (!(flags & VD_ACCESS_SET_EXCLUSIVE)) {
3949                 PR0("Invalid VD_OP_SET_ACCESS flags: 0x%lx", flags);
3950                 request->status = EINVAL;
3951                 return (0);
3952         }
3953 
3954         switch (flags & (VD_ACCESS_SET_PREEMPT | VD_ACCESS_SET_PRESERVE)) {
3955 
3956         case VD_ACCESS_SET_PREEMPT | VD_ACCESS_SET_PRESERVE:
3957                 /*
3958                  * Flags EXCLUSIVE and PREEMPT and PRESERVE. We have to
3959                  * acquire exclusive access rights, preserve them and we
3960                  * can use preemption. So we can use the MHIOCTKNOWN ioctl.
3961                  */
3962                 PR0("Performing VD_OP_SET_ACCESS (EXCLUSIVE|PREEMPT|PRESERVE)");
3963                 request->status = ldi_ioctl(vd->ldi_handle[request->slice],
3964                     MHIOCTKOWN, NULL, (vd->open_flags | FKIOCTL), kcred, &rval);
3965                 break;
3966 
3967         case VD_ACCESS_SET_PRESERVE:
3968                 /*
3969                  * Flags EXCLUSIVE and PRESERVE. We have to acquire exclusive
3970                  * access rights and preserve them, but not preempt any other
3971                  * host. So we need to use the MHIOCTKOWN ioctl to enable the
3972                  * "preserve" feature but we can not called it directly
3973                  * because it uses preemption. So before that, we use the
3974                  * MHIOCQRESERVE ioctl to ensure we can get exclusive rights
3975                  * without preempting anyone.
3976                  */
3977                 PR0("Performing VD_OP_SET_ACCESS (EXCLUSIVE|PRESERVE)");
3978                 request->status = ldi_ioctl(vd->ldi_handle[request->slice],
3979                     MHIOCQRESERVE, NULL, (vd->open_flags | FKIOCTL), kcred,
3980                     &rval);
3981                 if (request->status != 0)
3982                         break;
3983                 request->status = ldi_ioctl(vd->ldi_handle[request->slice],
3984                     MHIOCTKOWN, NULL, (vd->open_flags | FKIOCTL), kcred, &rval);
3985                 break;
3986 
3987         case VD_ACCESS_SET_PREEMPT:
3988                 /*
3989                  * Flags EXCLUSIVE and PREEMPT. We have to acquire exclusive
3990                  * access rights and we can use preemption. So we try to do
3991                  * a SCSI reservation, if it fails we reset the disk to clear
3992                  * any reservation and we try to reserve again.
3993                  */
3994                 PR0("Performing VD_OP_SET_ACCESS (EXCLUSIVE|PREEMPT)");
3995                 request->status = ldi_ioctl(vd->ldi_handle[request->slice],
3996                     MHIOCQRESERVE, NULL, (vd->open_flags | FKIOCTL), kcred,
3997                     &rval);
3998                 if (request->status == 0)
3999                         break;
4000 
4001                 /* reset the disk */
4002                 (void) vd_scsi_reset(vd);
4003 
4004                 /* try again even if the reset has failed */
4005                 request->status = ldi_ioctl(vd->ldi_handle[request->slice],
4006                     MHIOCQRESERVE, NULL, (vd->open_flags | FKIOCTL), kcred,
4007                     &rval);
4008                 break;
4009 
4010         case 0:
4011                 /* Flag EXCLUSIVE only. Just issue a SCSI reservation */
4012                 PR0("Performing VD_OP_SET_ACCESS (EXCLUSIVE)");
4013                 request->status = ldi_ioctl(vd->ldi_handle[request->slice],
4014                     MHIOCQRESERVE, NULL, (vd->open_flags | FKIOCTL), kcred,
4015                     &rval);
4016                 break;
4017         }
4018 
4019         if (request->status == 0)
4020                 vd->ownership = B_TRUE;
4021         else
4022                 PR0("VD_OP_SET_ACCESS: error %d", request->status);
4023 
4024         return (0);
4025 }
4026 
4027 static void
4028 vd_reset_access(vd_t *vd)
4029 {
4030         int status, rval;
4031 
4032         if (vd->file || vd->volume || !vd->ownership)
4033                 return;
4034 
4035         PR0("Releasing disk ownership");
4036         status = ldi_ioctl(vd->ldi_handle[0], MHIOCRELEASE, NULL,
4037             (vd->open_flags | FKIOCTL), kcred, &rval);
4038 
4039         /*
4040          * An EACCES failure means that there is a reservation conflict,
4041          * so we are not the owner of the disk anymore.
4042          */
4043         if (status == 0 || status == EACCES) {
4044                 vd->ownership = B_FALSE;
4045                 return;
4046         }
4047 
4048         PR0("Fail to release ownership, error %d", status);
4049 
4050         /*
4051          * We have failed to release the ownership, try to reset the disk
4052          * to release reservations.
4053          */
4054         PR0("Resetting disk");
4055         status = vd_scsi_reset(vd);
4056 
4057         if (status != 0)
4058                 PR0("Fail to reset disk, error %d", status);
4059 
4060         /* whatever the result of the reset is, we try the release again */
4061         status = ldi_ioctl(vd->ldi_handle[0], MHIOCRELEASE, NULL,
4062             (vd->open_flags | FKIOCTL), kcred, &rval);
4063 
4064         if (status == 0 || status == EACCES) {
4065                 vd->ownership = B_FALSE;
4066                 return;
4067         }
4068 
4069         PR0("Fail to release ownership, error %d", status);
4070 
4071         /*
4072          * At this point we have done our best to try to reset the
4073          * access rights to the disk and we don't know if we still
4074          * own a reservation and if any mechanism to preserve the
4075          * ownership is still in place. The ultimate solution would
4076          * be to reset the system but this is usually not what we
4077          * want to happen.
4078          */
4079 
4080         if (vd_reset_access_failure == A_REBOOT) {
4081                 cmn_err(CE_WARN, VD_RESET_ACCESS_FAILURE_MSG
4082                     ", rebooting the system", vd->device_path);
4083                 (void) uadmin(A_SHUTDOWN, AD_BOOT, NULL);
4084         } else if (vd_reset_access_failure == A_DUMP) {
4085                 panic(VD_RESET_ACCESS_FAILURE_MSG, vd->device_path);
4086         }
4087 
4088         cmn_err(CE_WARN, VD_RESET_ACCESS_FAILURE_MSG, vd->device_path);
4089 }
4090 
4091 /*
4092  * Define the supported operations once the functions for performing them have
4093  * been defined
4094  */
4095 static const vds_operation_t    vds_operation[] = {
4096 #define X(_s)   #_s, _s
4097         {X(VD_OP_BREAD),        vd_start_bio,   vd_complete_bio},
4098         {X(VD_OP_BWRITE),       vd_start_bio,   vd_complete_bio},
4099         {X(VD_OP_FLUSH),        vd_ioctl,       NULL},
4100         {X(VD_OP_GET_WCE),      vd_ioctl,       NULL},
4101         {X(VD_OP_SET_WCE),      vd_ioctl,       NULL},
4102         {X(VD_OP_GET_VTOC),     vd_ioctl,       NULL},
4103         {X(VD_OP_SET_VTOC),     vd_ioctl,       NULL},
4104         {X(VD_OP_GET_DISKGEOM), vd_ioctl,       NULL},
4105         {X(VD_OP_SET_DISKGEOM), vd_ioctl,       NULL},
4106         {X(VD_OP_GET_EFI),      vd_ioctl,       NULL},
4107         {X(VD_OP_SET_EFI),      vd_ioctl,       NULL},
4108         {X(VD_OP_GET_DEVID),    vd_get_devid,   NULL},
4109         {X(VD_OP_SCSICMD),      vd_ioctl,       NULL},
4110         {X(VD_OP_RESET),        vd_reset,       NULL},
4111         {X(VD_OP_GET_CAPACITY), vd_get_capacity, NULL},
4112         {X(VD_OP_SET_ACCESS),   vd_set_access,  NULL},
4113         {X(VD_OP_GET_ACCESS),   vd_get_access,  NULL},
4114 #undef  X
4115 };
4116 
4117 static const size_t     vds_noperations =
4118         (sizeof (vds_operation))/(sizeof (vds_operation[0]));
4119 
4120 /*
4121  * Process a task specifying a client I/O request
4122  *
4123  * Parameters:
4124  *      task            - structure containing the request sent from client
4125  *
4126  * Return Value
4127  *      0       - success
4128  *      ENOTSUP - Unknown/Unsupported VD_OP_XXX operation
4129  *      EINVAL  - Invalid disk slice
4130  *      != 0    - some other non-zero return value from start function
4131  */
4132 static int
4133 vd_do_process_task(vd_task_t *task)
4134 {
4135         int                     i;
4136         vd_t                    *vd             = task->vd;
4137         vd_dring_payload_t      *request        = task->request;
4138 
4139         ASSERT(vd != NULL);
4140         ASSERT(request != NULL);
4141 
4142         /* Find the requested operation */
4143         for (i = 0; i < vds_noperations; i++) {
4144                 if (request->operation == vds_operation[i].operation) {
4145                         /* all operations should have a start func */
4146                         ASSERT(vds_operation[i].start != NULL);
4147 
4148                         task->completef = vds_operation[i].complete;
4149                         break;
4150                 }
4151         }
4152 
4153         /*
4154          * We need to check that the requested operation is permitted
4155          * for the particular client that sent it or that the loop above
4156          * did not complete without finding the operation type (indicating
4157          * that the requested operation is unknown/unimplemented)
4158          */
4159         if ((VD_OP_SUPPORTED(vd->operations, request->operation) == B_FALSE) ||
4160             (i == vds_noperations)) {
4161                 PR0("Unsupported operation %u", request->operation);
4162                 request->status = ENOTSUP;
4163                 return (0);
4164         }
4165 
4166         /* Range-check slice */
4167         if (request->slice >= vd->nslices &&
4168             ((vd->vdisk_type != VD_DISK_TYPE_DISK && vd_slice_single_slice) ||
4169             request->slice != VD_SLICE_NONE)) {
4170                 PR0("Invalid \"slice\" %u (max %u) for virtual disk",
4171                     request->slice, (vd->nslices - 1));
4172                 request->status = EINVAL;
4173                 return (0);
4174         }
4175 
4176         /*
4177          * Call the function pointer that starts the operation.
4178          */
4179         return (vds_operation[i].start(task));
4180 }
4181 
4182 /*
4183  * Description:
4184  *      This function is called by both the in-band and descriptor ring
4185  *      message processing functions paths to actually execute the task
4186  *      requested by the vDisk client. It in turn calls its worker
4187  *      function, vd_do_process_task(), to carry our the request.
4188  *
4189  *      Any transport errors (e.g. LDC errors, vDisk protocol errors) are
4190  *      saved in the 'status' field of the task and are propagated back
4191  *      up the call stack to trigger a NACK
4192  *
4193  *      Any request errors (e.g. ENOTTY from an ioctl) are saved in
4194  *      the 'status' field of the request and result in an ACK being sent
4195  *      by the completion handler.
4196  *
4197  * Parameters:
4198  *      task            - structure containing the request sent from client
4199  *
4200  * Return Value
4201  *      0               - successful synchronous request.
4202  *      != 0            - transport error (e.g. LDC errors, vDisk protocol)
4203  *      EINPROGRESS     - task will be finished in a completion handler
4204  */
4205 static int
4206 vd_process_task(vd_task_t *task)
4207 {
4208         vd_t    *vd = task->vd;
4209         int     status;
4210 
4211         DTRACE_PROBE1(task__start, vd_task_t *, task);
4212 
4213         task->status =  vd_do_process_task(task);
4214 
4215         /*
4216          * If the task processing function returned EINPROGRESS indicating
4217          * that the task needs completing then schedule a taskq entry to
4218          * finish it now.
4219          *
4220          * Otherwise the task processing function returned either zero
4221          * indicating that the task was finished in the start function (and we
4222          * don't need to wait in a completion function) or the start function
4223          * returned an error - in both cases all that needs to happen is the
4224          * notification to the vDisk client higher up the call stack.
4225          * If the task was using a Descriptor Ring, we need to mark it as done
4226          * at this stage.
4227          */
4228         if (task->status == EINPROGRESS) {
4229                 /* Queue a task to complete the operation */
4230                 (void) ddi_taskq_dispatch(vd->completionq, vd_complete,
4231                     task, DDI_SLEEP);
4232                 return (EINPROGRESS);
4233         }
4234 
4235         if (!vd->reset_state && (vd->xfer_mode == VIO_DRING_MODE_V1_0)) {
4236                 /* Update the dring element if it's a dring client */
4237                 status = vd_mark_elem_done(vd, task->index,
4238                     task->request->status, task->request->nbytes);
4239                 if (status == ECONNRESET)
4240                         vd_mark_in_reset(vd);
4241                 else if (status == EACCES)
4242                         vd_need_reset(vd, B_TRUE);
4243         }
4244 
4245         return (task->status);
4246 }
4247 
4248 /*
4249  * Return true if the "type", "subtype", and "env" fields of the "tag" first
4250  * argument match the corresponding remaining arguments; otherwise, return false
4251  */
4252 boolean_t
4253 vd_msgtype(vio_msg_tag_t *tag, int type, int subtype, int env)
4254 {
4255         return ((tag->vio_msgtype == type) &&
4256             (tag->vio_subtype == subtype) &&
4257             (tag->vio_subtype_env == env)) ? B_TRUE : B_FALSE;
4258 }
4259 
4260 /*
4261  * Check whether the major/minor version specified in "ver_msg" is supported
4262  * by this server.
4263  */
4264 static boolean_t
4265 vds_supported_version(vio_ver_msg_t *ver_msg)
4266 {
4267         for (int i = 0; i < vds_num_versions; i++) {
4268                 ASSERT(vds_version[i].major > 0);
4269                 ASSERT((i == 0) ||
4270                     (vds_version[i].major < vds_version[i-1].major));
4271 
4272                 /*
4273                  * If the major versions match, adjust the minor version, if
4274                  * necessary, down to the highest value supported by this
4275                  * server and return true so this message will get "ack"ed;
4276                  * the client should also support all minor versions lower
4277                  * than the value it sent
4278                  */
4279                 if (ver_msg->ver_major == vds_version[i].major) {
4280                         if (ver_msg->ver_minor > vds_version[i].minor) {
4281                                 PR0("Adjusting minor version from %u to %u",
4282                                     ver_msg->ver_minor, vds_version[i].minor);
4283                                 ver_msg->ver_minor = vds_version[i].minor;
4284                         }
4285                         return (B_TRUE);
4286                 }
4287 
4288                 /*
4289                  * If the message contains a higher major version number, set
4290                  * the message's major/minor versions to the current values
4291                  * and return false, so this message will get "nack"ed with
4292                  * these values, and the client will potentially try again
4293                  * with the same or a lower version
4294                  */
4295                 if (ver_msg->ver_major > vds_version[i].major) {
4296                         ver_msg->ver_major = vds_version[i].major;
4297                         ver_msg->ver_minor = vds_version[i].minor;
4298                         return (B_FALSE);
4299                 }
4300 
4301                 /*
4302                  * Otherwise, the message's major version is less than the
4303                  * current major version, so continue the loop to the next
4304                  * (lower) supported version
4305                  */
4306         }
4307 
4308         /*
4309          * No common version was found; "ground" the version pair in the
4310          * message to terminate negotiation
4311          */
4312         ver_msg->ver_major = 0;
4313         ver_msg->ver_minor = 0;
4314         return (B_FALSE);
4315 }
4316 
4317 /*
4318  * Process a version message from a client.  vds expects to receive version
4319  * messages from clients seeking service, but never issues version messages
4320  * itself; therefore, vds can ACK or NACK client version messages, but does
4321  * not expect to receive version-message ACKs or NACKs (and will treat such
4322  * messages as invalid).
4323  */
4324 static int
4325 vd_process_ver_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
4326 {
4327         vio_ver_msg_t   *ver_msg = (vio_ver_msg_t *)msg;
4328 
4329 
4330         ASSERT(msglen >= sizeof (msg->tag));
4331 
4332         if (!vd_msgtype(&msg->tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO,
4333             VIO_VER_INFO)) {
4334                 return (ENOMSG);        /* not a version message */
4335         }
4336 
4337         if (msglen != sizeof (*ver_msg)) {
4338                 PR0("Expected %lu-byte version message; "
4339                     "received %lu bytes", sizeof (*ver_msg), msglen);
4340                 return (EBADMSG);
4341         }
4342 
4343         if (ver_msg->dev_class != VDEV_DISK) {
4344                 PR0("Expected device class %u (disk); received %u",
4345                     VDEV_DISK, ver_msg->dev_class);
4346                 return (EBADMSG);
4347         }
4348 
4349         /*
4350          * We're talking to the expected kind of client; set our device class
4351          * for "ack/nack" back to the client
4352          */
4353         ver_msg->dev_class = VDEV_DISK_SERVER;
4354 
4355         /*
4356          * Check whether the (valid) version message specifies a version
4357          * supported by this server.  If the version is not supported, return
4358          * EBADMSG so the message will get "nack"ed; vds_supported_version()
4359          * will have updated the message with a supported version for the
4360          * client to consider
4361          */
4362         if (!vds_supported_version(ver_msg))
4363                 return (EBADMSG);
4364 
4365 
4366         /*
4367          * A version has been agreed upon; use the client's SID for
4368          * communication on this channel now
4369          */
4370         ASSERT(!(vd->initialized & VD_SID));
4371         vd->sid = ver_msg->tag.vio_sid;
4372         vd->initialized |= VD_SID;
4373 
4374         /*
4375          * Store the negotiated major and minor version values in the "vd" data
4376          * structure so that we can check if certain operations are supported
4377          * by the client.
4378          */
4379         vd->version.major = ver_msg->ver_major;
4380         vd->version.minor = ver_msg->ver_minor;
4381 
4382         PR0("Using major version %u, minor version %u",
4383             ver_msg->ver_major, ver_msg->ver_minor);
4384         return (0);
4385 }
4386 
4387 static void
4388 vd_set_exported_operations(vd_t *vd)
4389 {
4390         vd->operations = 0;  /* clear field */
4391 
4392         /*
4393          * We need to check from the highest version supported to the
4394          * lowest because versions with a higher minor number implicitly
4395          * support versions with a lower minor number.
4396          */
4397         if (vio_ver_is_supported(vd->version, 1, 1)) {
4398                 ASSERT(vd->open_flags & FREAD);
4399                 vd->operations |= VD_OP_MASK_READ | (1 << VD_OP_GET_CAPACITY);
4400 
4401                 if (vd->open_flags & FWRITE)
4402                         vd->operations |= VD_OP_MASK_WRITE;
4403 
4404                 if (vd->scsi)
4405                         vd->operations |= VD_OP_MASK_SCSI;
4406 
4407                 if (VD_DSKIMG(vd) && vd_dskimg_is_iso_image(vd)) {
4408                         /*
4409                          * can't write to ISO images, make sure that write
4410                          * support is not set in case administrator did not
4411                          * use "options=ro" when doing an ldm add-vdsdev
4412                          */
4413                         vd->operations &= ~VD_OP_MASK_WRITE;
4414                 }
4415         } else if (vio_ver_is_supported(vd->version, 1, 0)) {
4416                 vd->operations = VD_OP_MASK_READ | VD_OP_MASK_WRITE;
4417         }
4418 
4419         /* we should have already agreed on a version */
4420         ASSERT(vd->operations != 0);
4421 }
4422 
4423 static int
4424 vd_process_attr_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
4425 {
4426         vd_attr_msg_t   *attr_msg = (vd_attr_msg_t *)msg;
4427         int             status, retry = 0;
4428 
4429 
4430         ASSERT(msglen >= sizeof (msg->tag));
4431 
4432         if (!vd_msgtype(&msg->tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO,
4433             VIO_ATTR_INFO)) {
4434                 PR0("Message is not an attribute message");
4435                 return (ENOMSG);
4436         }
4437 
4438         if (msglen != sizeof (*attr_msg)) {
4439                 PR0("Expected %lu-byte attribute message; "
4440                     "received %lu bytes", sizeof (*attr_msg), msglen);
4441                 return (EBADMSG);
4442         }
4443 
4444         if (attr_msg->max_xfer_sz == 0) {
4445                 PR0("Received maximum transfer size of 0 from client");
4446                 return (EBADMSG);
4447         }
4448 
4449         if ((attr_msg->xfer_mode != VIO_DESC_MODE) &&
4450             (attr_msg->xfer_mode != VIO_DRING_MODE_V1_0)) {
4451                 PR0("Client requested unsupported transfer mode");
4452                 return (EBADMSG);
4453         }
4454 
4455         /*
4456          * check if the underlying disk is ready, if not try accessing
4457          * the device again. Open the vdisk device and extract info
4458          * about it, as this is needed to respond to the attr info msg
4459          */
4460         if ((vd->initialized & VD_DISK_READY) == 0) {
4461                 PR0("Retry setting up disk (%s)", vd->device_path);
4462                 do {
4463                         status = vd_setup_vd(vd);
4464                         if (status != EAGAIN || ++retry > vds_dev_retries)
4465                                 break;
4466 
4467                         /* incremental delay */
4468                         delay(drv_usectohz(vds_dev_delay));
4469 
4470                         /* if vdisk is no longer enabled - return error */
4471                         if (!vd_enabled(vd))
4472                                 return (ENXIO);
4473 
4474                 } while (status == EAGAIN);
4475 
4476                 if (status)
4477                         return (ENXIO);
4478 
4479                 vd->initialized |= VD_DISK_READY;
4480                 ASSERT(vd->nslices > 0 && vd->nslices <= V_NUMPAR);
4481                 PR0("vdisk_type = %s, volume = %s, file = %s, nslices = %u",
4482                     ((vd->vdisk_type == VD_DISK_TYPE_DISK) ? "disk" : "slice"),
4483                     (vd->volume ? "yes" : "no"),
4484                     (vd->file ? "yes" : "no"),
4485                     vd->nslices);
4486         }
4487 
4488         /* Success:  valid message and transfer mode */
4489         vd->xfer_mode = attr_msg->xfer_mode;
4490 
4491         if (vd->xfer_mode == VIO_DESC_MODE) {
4492 
4493                 /*
4494                  * The vd_dring_inband_msg_t contains one cookie; need room
4495                  * for up to n-1 more cookies, where "n" is the number of full
4496                  * pages plus possibly one partial page required to cover
4497                  * "max_xfer_sz".  Add room for one more cookie if
4498                  * "max_xfer_sz" isn't an integral multiple of the page size.
4499                  * Must first get the maximum transfer size in bytes.
4500                  */
4501                 size_t  max_xfer_bytes = attr_msg->vdisk_block_size ?
4502                     attr_msg->vdisk_block_size * attr_msg->max_xfer_sz :
4503                     attr_msg->max_xfer_sz;
4504                 size_t  max_inband_msglen =
4505                     sizeof (vd_dring_inband_msg_t) +
4506                     ((max_xfer_bytes/PAGESIZE +
4507                     ((max_xfer_bytes % PAGESIZE) ? 1 : 0))*
4508                     (sizeof (ldc_mem_cookie_t)));
4509 
4510                 /*
4511                  * Set the maximum expected message length to
4512                  * accommodate in-band-descriptor messages with all
4513                  * their cookies
4514                  */
4515                 vd->max_msglen = MAX(vd->max_msglen, max_inband_msglen);
4516 
4517                 /*
4518                  * Initialize the data structure for processing in-band I/O
4519                  * request descriptors
4520                  */
4521                 vd->inband_task.vd   = vd;
4522                 vd->inband_task.msg  = kmem_alloc(vd->max_msglen, KM_SLEEP);
4523                 vd->inband_task.index        = 0;
4524                 vd->inband_task.type = VD_FINAL_RANGE_TASK;  /* range == 1 */
4525         }
4526 
4527         /* Return the device's block size and max transfer size to the client */
4528         attr_msg->vdisk_block_size   = vd->vdisk_bsize;
4529         attr_msg->max_xfer_sz                = vd->max_xfer_sz;
4530 
4531         attr_msg->vdisk_size = vd->vdisk_size;
4532         attr_msg->vdisk_type = (vd_slice_single_slice)? vd->vdisk_type :
4533             VD_DISK_TYPE_DISK;
4534         attr_msg->vdisk_media = vd->vdisk_media;
4535 
4536         /* Discover and save the list of supported VD_OP_XXX operations */
4537         vd_set_exported_operations(vd);
4538         attr_msg->operations = vd->operations;
4539 
4540         PR0("%s", VD_CLIENT(vd));
4541 
4542         ASSERT(vd->dring_task == NULL);
4543 
4544         return (0);
4545 }
4546 
4547 static int
4548 vd_process_dring_reg_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
4549 {
4550         int                     status;
4551         size_t                  expected;
4552         ldc_mem_info_t          dring_minfo;
4553         uint8_t                 mtype;
4554         vio_dring_reg_msg_t     *reg_msg = (vio_dring_reg_msg_t *)msg;
4555 
4556 
4557         ASSERT(msglen >= sizeof (msg->tag));
4558 
4559         if (!vd_msgtype(&msg->tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO,
4560             VIO_DRING_REG)) {
4561                 PR0("Message is not a register-dring message");
4562                 return (ENOMSG);
4563         }
4564 
4565         if (msglen < sizeof (*reg_msg)) {
4566                 PR0("Expected at least %lu-byte register-dring message; "
4567                     "received %lu bytes", sizeof (*reg_msg), msglen);
4568                 return (EBADMSG);
4569         }
4570 
4571         expected = sizeof (*reg_msg) +
4572             (reg_msg->ncookies - 1)*(sizeof (reg_msg->cookie[0]));
4573         if (msglen != expected) {
4574                 PR0("Expected %lu-byte register-dring message; "
4575                     "received %lu bytes", expected, msglen);
4576                 return (EBADMSG);
4577         }
4578 
4579         if (vd->initialized & VD_DRING) {
4580                 PR0("A dring was previously registered; only support one");
4581                 return (EBADMSG);
4582         }
4583 
4584         if (reg_msg->num_descriptors > INT32_MAX) {
4585                 PR0("reg_msg->num_descriptors = %u; must be <= %u (%s)",
4586                     reg_msg->ncookies, INT32_MAX, STRINGIZE(INT32_MAX));
4587                 return (EBADMSG);
4588         }
4589 
4590         if (reg_msg->ncookies != 1) {
4591                 /*
4592                  * In addition to fixing the assertion in the success case
4593                  * below, supporting drings which require more than one
4594                  * "cookie" requires increasing the value of vd->max_msglen
4595                  * somewhere in the code path prior to receiving the message
4596                  * which results in calling this function.  Note that without
4597                  * making this change, the larger message size required to
4598                  * accommodate multiple cookies cannot be successfully
4599                  * received, so this function will not even get called.
4600                  * Gracefully accommodating more dring cookies might
4601                  * reasonably demand exchanging an additional attribute or
4602                  * making a minor protocol adjustment
4603                  */
4604                 PR0("reg_msg->ncookies = %u != 1", reg_msg->ncookies);
4605                 return (EBADMSG);
4606         }
4607 
4608         if (vd_direct_mapped_drings)
4609                 mtype = LDC_DIRECT_MAP;
4610         else
4611                 mtype = LDC_SHADOW_MAP;
4612 
4613         status = ldc_mem_dring_map(vd->ldc_handle, reg_msg->cookie,
4614             reg_msg->ncookies, reg_msg->num_descriptors,
4615             reg_msg->descriptor_size, mtype, &vd->dring_handle);
4616         if (status != 0) {
4617                 PR0("ldc_mem_dring_map() returned errno %d", status);
4618                 return (status);
4619         }
4620 
4621         /*
4622          * To remove the need for this assertion, must call
4623          * ldc_mem_dring_nextcookie() successfully ncookies-1 times after a
4624          * successful call to ldc_mem_dring_map()
4625          */
4626         ASSERT(reg_msg->ncookies == 1);
4627 
4628         if ((status =
4629             ldc_mem_dring_info(vd->dring_handle, &dring_minfo)) != 0) {
4630                 PR0("ldc_mem_dring_info() returned errno %d", status);
4631                 if ((status = ldc_mem_dring_unmap(vd->dring_handle)) != 0)
4632                         PR0("ldc_mem_dring_unmap() returned errno %d", status);
4633                 return (status);
4634         }
4635 
4636         if (dring_minfo.vaddr == NULL) {
4637                 PR0("Descriptor ring virtual address is NULL");
4638                 return (ENXIO);
4639         }
4640 
4641 
4642         /* Initialize for valid message and mapped dring */
4643         vd->initialized |= VD_DRING;
4644         vd->dring_ident = 1; /* "There Can Be Only One" */
4645         vd->dring = dring_minfo.vaddr;
4646         vd->descriptor_size = reg_msg->descriptor_size;
4647         vd->dring_len = reg_msg->num_descriptors;
4648         vd->dring_mtype = dring_minfo.mtype;
4649         reg_msg->dring_ident = vd->dring_ident;
4650         PR1("descriptor size = %u, dring length = %u",
4651             vd->descriptor_size, vd->dring_len);
4652 
4653         /*
4654          * Allocate and initialize a "shadow" array of data structures for
4655          * tasks to process I/O requests in dring elements
4656          */
4657         vd->dring_task =
4658             kmem_zalloc((sizeof (*vd->dring_task)) * vd->dring_len, KM_SLEEP);
4659         for (int i = 0; i < vd->dring_len; i++) {
4660                 vd->dring_task[i].vd         = vd;
4661                 vd->dring_task[i].index              = i;
4662 
4663                 status = ldc_mem_alloc_handle(vd->ldc_handle,
4664                     &(vd->dring_task[i].mhdl));
4665                 if (status) {
4666                         PR0("ldc_mem_alloc_handle() returned err %d ", status);
4667                         return (ENXIO);
4668                 }
4669 
4670                 /*
4671                  * The descriptor payload varies in length. Calculate its
4672                  * size by subtracting the header size from the total
4673                  * descriptor size.
4674                  */
4675                 vd->dring_task[i].request = kmem_zalloc((vd->descriptor_size -
4676                     sizeof (vio_dring_entry_hdr_t)), KM_SLEEP);
4677                 vd->dring_task[i].msg = kmem_alloc(vd->max_msglen, KM_SLEEP);
4678         }
4679 
4680         if (vd->file || vd->zvol) {
4681                 vd->write_queue =
4682                     kmem_zalloc(sizeof (buf_t *) * vd->dring_len, KM_SLEEP);
4683         }
4684 
4685         return (0);
4686 }
4687 
4688 static int
4689 vd_process_dring_unreg_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
4690 {
4691         vio_dring_unreg_msg_t   *unreg_msg = (vio_dring_unreg_msg_t *)msg;
4692 
4693 
4694         ASSERT(msglen >= sizeof (msg->tag));
4695 
4696         if (!vd_msgtype(&msg->tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO,
4697             VIO_DRING_UNREG)) {
4698                 PR0("Message is not an unregister-dring message");
4699                 return (ENOMSG);
4700         }
4701 
4702         if (msglen != sizeof (*unreg_msg)) {
4703                 PR0("Expected %lu-byte unregister-dring message; "
4704                     "received %lu bytes", sizeof (*unreg_msg), msglen);
4705                 return (EBADMSG);
4706         }
4707 
4708         if (unreg_msg->dring_ident != vd->dring_ident) {
4709                 PR0("Expected dring ident %lu; received %lu",
4710                     vd->dring_ident, unreg_msg->dring_ident);
4711                 return (EBADMSG);
4712         }
4713 
4714         return (0);
4715 }
4716 
4717 static int
4718 process_rdx_msg(vio_msg_t *msg, size_t msglen)
4719 {
4720         ASSERT(msglen >= sizeof (msg->tag));
4721 
4722         if (!vd_msgtype(&msg->tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_RDX)) {
4723                 PR0("Message is not an RDX message");
4724                 return (ENOMSG);
4725         }
4726 
4727         if (msglen != sizeof (vio_rdx_msg_t)) {
4728                 PR0("Expected %lu-byte RDX message; received %lu bytes",
4729                     sizeof (vio_rdx_msg_t), msglen);
4730                 return (EBADMSG);
4731         }
4732 
4733         PR0("Valid RDX message");
4734         return (0);
4735 }
4736 
4737 static int
4738 vd_check_seq_num(vd_t *vd, uint64_t seq_num)
4739 {
4740         if ((vd->initialized & VD_SEQ_NUM) && (seq_num != vd->seq_num + 1)) {
4741                 PR0("Received seq_num %lu; expected %lu",
4742                     seq_num, (vd->seq_num + 1));
4743                 PR0("initiating soft reset");
4744                 vd_need_reset(vd, B_FALSE);
4745                 return (1);
4746         }
4747 
4748         vd->seq_num = seq_num;
4749         vd->initialized |= VD_SEQ_NUM;       /* superfluous after first time... */
4750         return (0);
4751 }
4752 
4753 /*
4754  * Return the expected size of an inband-descriptor message with all the
4755  * cookies it claims to include
4756  */
4757 static size_t
4758 expected_inband_size(vd_dring_inband_msg_t *msg)
4759 {
4760         return ((sizeof (*msg)) +
4761             (msg->payload.ncookies - 1)*(sizeof (msg->payload.cookie[0])));
4762 }
4763 
4764 /*
4765  * Process an in-band descriptor message:  used with clients like OBP, with
4766  * which vds exchanges descriptors within VIO message payloads, rather than
4767  * operating on them within a descriptor ring
4768  */
4769 static int
4770 vd_process_desc_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
4771 {
4772         size_t                  expected;
4773         vd_dring_inband_msg_t   *desc_msg = (vd_dring_inband_msg_t *)msg;
4774 
4775 
4776         ASSERT(msglen >= sizeof (msg->tag));
4777 
4778         if (!vd_msgtype(&msg->tag, VIO_TYPE_DATA, VIO_SUBTYPE_INFO,
4779             VIO_DESC_DATA)) {
4780                 PR1("Message is not an in-band-descriptor message");
4781                 return (ENOMSG);
4782         }
4783 
4784         if (msglen < sizeof (*desc_msg)) {
4785                 PR0("Expected at least %lu-byte descriptor message; "
4786                     "received %lu bytes", sizeof (*desc_msg), msglen);
4787                 return (EBADMSG);
4788         }
4789 
4790         if (msglen != (expected = expected_inband_size(desc_msg))) {
4791                 PR0("Expected %lu-byte descriptor message; "
4792                     "received %lu bytes", expected, msglen);
4793                 return (EBADMSG);
4794         }
4795 
4796         if (vd_check_seq_num(vd, desc_msg->hdr.seq_num) != 0)
4797                 return (EBADMSG);
4798 
4799         /*
4800          * Valid message:  Set up the in-band descriptor task and process the
4801          * request.  Arrange to acknowledge the client's message, unless an
4802          * error processing the descriptor task results in setting
4803          * VIO_SUBTYPE_NACK
4804          */
4805         PR1("Valid in-band-descriptor message");
4806         msg->tag.vio_subtype = VIO_SUBTYPE_ACK;
4807 
4808         ASSERT(vd->inband_task.msg != NULL);
4809 
4810         bcopy(msg, vd->inband_task.msg, msglen);
4811         vd->inband_task.msglen       = msglen;
4812 
4813         /*
4814          * The task request is now the payload of the message
4815          * that was just copied into the body of the task.
4816          */
4817         desc_msg = (vd_dring_inband_msg_t *)vd->inband_task.msg;
4818         vd->inband_task.request      = &desc_msg->payload;
4819 
4820         return (vd_process_task(&vd->inband_task));
4821 }
4822 
4823 static int
4824 vd_process_element(vd_t *vd, vd_task_type_t type, uint32_t idx,
4825     vio_msg_t *msg, size_t msglen)
4826 {
4827         int                     status;
4828         boolean_t               ready;
4829         on_trap_data_t          otd;
4830         vd_dring_entry_t        *elem = VD_DRING_ELEM(idx);
4831 
4832         /* Accept the updated dring element */
4833         if ((status = VIO_DRING_ACQUIRE(&otd, vd->dring_mtype,
4834             vd->dring_handle, idx, idx)) != 0) {
4835                 return (status);
4836         }
4837         ready = (elem->hdr.dstate == VIO_DESC_READY);
4838         if (ready) {
4839                 elem->hdr.dstate = VIO_DESC_ACCEPTED;
4840                 bcopy(&elem->payload, vd->dring_task[idx].request,
4841                     (vd->descriptor_size - sizeof (vio_dring_entry_hdr_t)));
4842         } else {
4843                 PR0("descriptor %u not ready", idx);
4844                 VD_DUMP_DRING_ELEM(elem);
4845         }
4846         if ((status = VIO_DRING_RELEASE(vd->dring_mtype,
4847             vd->dring_handle, idx, idx)) != 0) {
4848                 PR0("VIO_DRING_RELEASE() returned errno %d", status);
4849                 return (status);
4850         }
4851         if (!ready)
4852                 return (EBUSY);
4853 
4854 
4855         /* Initialize a task and process the accepted element */
4856         PR1("Processing dring element %u", idx);
4857         vd->dring_task[idx].type     = type;
4858 
4859         /* duplicate msg buf for cookies etc. */
4860         bcopy(msg, vd->dring_task[idx].msg, msglen);
4861 
4862         vd->dring_task[idx].msglen   = msglen;
4863         return (vd_process_task(&vd->dring_task[idx]));
4864 }
4865 
4866 static int
4867 vd_process_element_range(vd_t *vd, int start, int end,
4868     vio_msg_t *msg, size_t msglen)
4869 {
4870         int             i, n, nelem, status = 0;
4871         boolean_t       inprogress = B_FALSE;
4872         vd_task_type_t  type;
4873 
4874 
4875         ASSERT(start >= 0);
4876         ASSERT(end >= 0);
4877 
4878         /*
4879          * Arrange to acknowledge the client's message, unless an error
4880          * processing one of the dring elements results in setting
4881          * VIO_SUBTYPE_NACK
4882          */
4883         msg->tag.vio_subtype = VIO_SUBTYPE_ACK;
4884 
4885         /*
4886          * Process the dring elements in the range
4887          */
4888         nelem = ((end < start) ? end + vd->dring_len : end) - start + 1;
4889         for (i = start, n = nelem; n > 0; i = (i + 1) % vd->dring_len, n--) {
4890                 ((vio_dring_msg_t *)msg)->end_idx = i;
4891                 type = (n == 1) ? VD_FINAL_RANGE_TASK : VD_NONFINAL_RANGE_TASK;
4892                 status = vd_process_element(vd, type, i, msg, msglen);
4893                 if (status == EINPROGRESS)
4894                         inprogress = B_TRUE;
4895                 else if (status != 0)
4896                         break;
4897         }
4898 
4899         /*
4900          * If some, but not all, operations of a multi-element range are in
4901          * progress, wait for other operations to complete before returning
4902          * (which will result in "ack" or "nack" of the message).  Note that
4903          * all outstanding operations will need to complete, not just the ones
4904          * corresponding to the current range of dring elements; howevever, as
4905          * this situation is an error case, performance is less critical.
4906          */
4907         if ((nelem > 1) && (status != EINPROGRESS) && inprogress) {
4908                 if (vd->ioq != NULL)
4909                         ddi_taskq_wait(vd->ioq);
4910                 ddi_taskq_wait(vd->completionq);
4911         }
4912 
4913         return (status);
4914 }
4915 
4916 static int
4917 vd_process_dring_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
4918 {
4919         vio_dring_msg_t *dring_msg = (vio_dring_msg_t *)msg;
4920 
4921 
4922         ASSERT(msglen >= sizeof (msg->tag));
4923 
4924         if (!vd_msgtype(&msg->tag, VIO_TYPE_DATA, VIO_SUBTYPE_INFO,
4925             VIO_DRING_DATA)) {
4926                 PR1("Message is not a dring-data message");
4927                 return (ENOMSG);
4928         }
4929 
4930         if (msglen != sizeof (*dring_msg)) {
4931                 PR0("Expected %lu-byte dring message; received %lu bytes",
4932                     sizeof (*dring_msg), msglen);
4933                 return (EBADMSG);
4934         }
4935 
4936         if (vd_check_seq_num(vd, dring_msg->seq_num) != 0)
4937                 return (EBADMSG);
4938 
4939         if (dring_msg->dring_ident != vd->dring_ident) {
4940                 PR0("Expected dring ident %lu; received ident %lu",
4941                     vd->dring_ident, dring_msg->dring_ident);
4942                 return (EBADMSG);
4943         }
4944 
4945         if (dring_msg->start_idx >= vd->dring_len) {
4946                 PR0("\"start_idx\" = %u; must be less than %u",
4947                     dring_msg->start_idx, vd->dring_len);
4948                 return (EBADMSG);
4949         }
4950 
4951         if ((dring_msg->end_idx < 0) ||
4952             (dring_msg->end_idx >= vd->dring_len)) {
4953                 PR0("\"end_idx\" = %u; must be >= 0 and less than %u",
4954                     dring_msg->end_idx, vd->dring_len);
4955                 return (EBADMSG);
4956         }
4957 
4958         /* Valid message; process range of updated dring elements */
4959         PR1("Processing descriptor range, start = %u, end = %u",
4960             dring_msg->start_idx, dring_msg->end_idx);
4961         return (vd_process_element_range(vd, dring_msg->start_idx,
4962             dring_msg->end_idx, msg, msglen));
4963 }
4964 
4965 static int
4966 recv_msg(ldc_handle_t ldc_handle, void *msg, size_t *nbytes)
4967 {
4968         int     retry, status;
4969         size_t  size = *nbytes;
4970 
4971 
4972         for (retry = 0, status = ETIMEDOUT;
4973             retry < vds_ldc_retries && status == ETIMEDOUT;
4974             retry++) {
4975                 PR1("ldc_read() attempt %d", (retry + 1));
4976                 *nbytes = size;
4977                 status = ldc_read(ldc_handle, msg, nbytes);
4978         }
4979 
4980         if (status) {
4981                 PR0("ldc_read() returned errno %d", status);
4982                 if (status != ECONNRESET)
4983                         return (ENOMSG);
4984                 return (status);
4985         } else if (*nbytes == 0) {
4986                 PR1("ldc_read() returned 0 and no message read");
4987                 return (ENOMSG);
4988         }
4989 
4990         PR1("RCVD %lu-byte message", *nbytes);
4991         return (0);
4992 }
4993 
4994 static int
4995 vd_do_process_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
4996 {
4997         int             status;
4998 
4999 
5000         PR1("Processing (%x/%x/%x) message", msg->tag.vio_msgtype,
5001             msg->tag.vio_subtype, msg->tag.vio_subtype_env);
5002 #ifdef  DEBUG
5003         vd_decode_tag(msg);
5004 #endif
5005 
5006         /*
5007          * Validate session ID up front, since it applies to all messages
5008          * once set
5009          */
5010         if ((msg->tag.vio_sid != vd->sid) && (vd->initialized & VD_SID)) {
5011                 PR0("Expected SID %u, received %u", vd->sid,
5012                     msg->tag.vio_sid);
5013                 return (EBADMSG);
5014         }
5015 
5016         PR1("\tWhile in state %d (%s)", vd->state, vd_decode_state(vd->state));
5017 
5018         /*
5019          * Process the received message based on connection state
5020          */
5021         switch (vd->state) {
5022         case VD_STATE_INIT:     /* expect version message */
5023                 if ((status = vd_process_ver_msg(vd, msg, msglen)) != 0)
5024                         return (status);
5025 
5026                 /* Version negotiated, move to that state */
5027                 vd->state = VD_STATE_VER;
5028                 return (0);
5029 
5030         case VD_STATE_VER:      /* expect attribute message */
5031                 if ((status = vd_process_attr_msg(vd, msg, msglen)) != 0)
5032                         return (status);
5033 
5034                 /* Attributes exchanged, move to that state */
5035                 vd->state = VD_STATE_ATTR;
5036                 return (0);
5037 
5038         case VD_STATE_ATTR:
5039                 switch (vd->xfer_mode) {
5040                 case VIO_DESC_MODE:     /* expect RDX message */
5041                         if ((status = process_rdx_msg(msg, msglen)) != 0)
5042                                 return (status);
5043 
5044                         /* Ready to receive in-band descriptors */
5045                         vd->state = VD_STATE_DATA;
5046                         return (0);
5047 
5048                 case VIO_DRING_MODE_V1_0:  /* expect register-dring message */
5049                         if ((status =
5050                             vd_process_dring_reg_msg(vd, msg, msglen)) != 0)
5051                                 return (status);
5052 
5053                         /* One dring negotiated, move to that state */
5054                         vd->state = VD_STATE_DRING;
5055                         return (0);
5056 
5057                 default:
5058                         ASSERT("Unsupported transfer mode");
5059                         PR0("Unsupported transfer mode");
5060                         return (ENOTSUP);
5061                 }
5062 
5063         case VD_STATE_DRING:    /* expect RDX, register-dring, or unreg-dring */
5064                 if ((status = process_rdx_msg(msg, msglen)) == 0) {
5065                         /* Ready to receive data */
5066                         vd->state = VD_STATE_DATA;
5067                         return (0);
5068                 } else if (status != ENOMSG) {
5069                         return (status);
5070                 }
5071 
5072 
5073                 /*
5074                  * If another register-dring message is received, stay in
5075                  * dring state in case the client sends RDX; although the
5076                  * protocol allows multiple drings, this server does not
5077                  * support using more than one
5078                  */
5079                 if ((status =
5080                     vd_process_dring_reg_msg(vd, msg, msglen)) != ENOMSG)
5081                         return (status);
5082 
5083                 /*
5084                  * Acknowledge an unregister-dring message, but reset the
5085                  * connection anyway:  Although the protocol allows
5086                  * unregistering drings, this server cannot serve a vdisk
5087                  * without its only dring
5088                  */
5089                 status = vd_process_dring_unreg_msg(vd, msg, msglen);
5090                 return ((status == 0) ? ENOTSUP : status);
5091 
5092         case VD_STATE_DATA:
5093                 switch (vd->xfer_mode) {
5094                 case VIO_DESC_MODE:     /* expect in-band-descriptor message */
5095                         return (vd_process_desc_msg(vd, msg, msglen));
5096 
5097                 case VIO_DRING_MODE_V1_0: /* expect dring-data or unreg-dring */
5098                         /*
5099                          * Typically expect dring-data messages, so handle
5100                          * them first
5101                          */
5102                         if ((status = vd_process_dring_msg(vd, msg,
5103                             msglen)) != ENOMSG)
5104                                 return (status);
5105 
5106                         /*
5107                          * Acknowledge an unregister-dring message, but reset
5108                          * the connection anyway:  Although the protocol
5109                          * allows unregistering drings, this server cannot
5110                          * serve a vdisk without its only dring
5111                          */
5112                         status = vd_process_dring_unreg_msg(vd, msg, msglen);
5113                         return ((status == 0) ? ENOTSUP : status);
5114 
5115                 default:
5116                         ASSERT("Unsupported transfer mode");
5117                         PR0("Unsupported transfer mode");
5118                         return (ENOTSUP);
5119                 }
5120 
5121         default:
5122                 ASSERT("Invalid client connection state");
5123                 PR0("Invalid client connection state");
5124                 return (ENOTSUP);
5125         }
5126 }
5127 
5128 static int
5129 vd_process_msg(vd_t *vd, vio_msg_t *msg, size_t msglen)
5130 {
5131         int             status;
5132         boolean_t       reset_ldc = B_FALSE;
5133         vd_task_t       task;
5134 
5135         /*
5136          * Check that the message is at least big enough for a "tag", so that
5137          * message processing can proceed based on tag-specified message type
5138          */
5139         if (msglen < sizeof (vio_msg_tag_t)) {
5140                 PR0("Received short (%lu-byte) message", msglen);
5141                 /* Can't "nack" short message, so drop the big hammer */
5142                 PR0("initiating full reset");
5143                 vd_need_reset(vd, B_TRUE);
5144                 return (EBADMSG);
5145         }
5146 
5147         /*
5148          * Process the message
5149          */
5150         switch (status = vd_do_process_msg(vd, msg, msglen)) {
5151         case 0:
5152                 /* "ack" valid, successfully-processed messages */
5153                 msg->tag.vio_subtype = VIO_SUBTYPE_ACK;
5154                 break;
5155 
5156         case EINPROGRESS:
5157                 /* The completion handler will "ack" or "nack" the message */
5158                 return (EINPROGRESS);
5159         case ENOMSG:
5160                 PR0("Received unexpected message");
5161                 _NOTE(FALLTHROUGH);
5162         case EBADMSG:
5163         case ENOTSUP:
5164                 /* "transport" error will cause NACK of invalid messages */
5165                 msg->tag.vio_subtype = VIO_SUBTYPE_NACK;
5166                 break;
5167 
5168         default:
5169                 /* "transport" error will cause NACK of invalid messages */
5170                 msg->tag.vio_subtype = VIO_SUBTYPE_NACK;
5171                 /* An LDC error probably occurred, so try resetting it */
5172                 reset_ldc = B_TRUE;
5173                 break;
5174         }
5175 
5176         PR1("\tResulting in state %d (%s)", vd->state,
5177             vd_decode_state(vd->state));
5178 
5179         /* populate the task so we can dispatch it on the taskq */
5180         task.vd = vd;
5181         task.msg = msg;
5182         task.msglen = msglen;
5183 
5184         /*
5185          * Queue a task to send the notification that the operation completed.
5186          * We need to ensure that requests are responded to in the correct
5187          * order and since the taskq is processed serially this ordering
5188          * is maintained.
5189          */
5190         (void) ddi_taskq_dispatch(vd->completionq, vd_serial_notify,
5191             &task, DDI_SLEEP);
5192 
5193         /*
5194          * To ensure handshake negotiations do not happen out of order, such
5195          * requests that come through this path should not be done in parallel
5196          * so we need to wait here until the response is sent to the client.
5197          */
5198         ddi_taskq_wait(vd->completionq);
5199 
5200         /* Arrange to reset the connection for nack'ed or failed messages */
5201         if ((status != 0) || reset_ldc) {
5202                 PR0("initiating %s reset",
5203                     (reset_ldc) ? "full" : "soft");
5204                 vd_need_reset(vd, reset_ldc);
5205         }
5206 
5207         return (status);
5208 }
5209 
5210 static boolean_t
5211 vd_enabled(vd_t *vd)
5212 {
5213         boolean_t       enabled;
5214 
5215         mutex_enter(&vd->lock);
5216         enabled = vd->enabled;
5217         mutex_exit(&vd->lock);
5218         return (enabled);
5219 }
5220 
5221 static void
5222 vd_recv_msg(void *arg)
5223 {
5224         vd_t    *vd = (vd_t *)arg;
5225         int     rv = 0, status = 0;
5226 
5227         ASSERT(vd != NULL);
5228 
5229         PR2("New task to receive incoming message(s)");
5230 
5231 
5232         while (vd_enabled(vd) && status == 0) {
5233                 size_t          msglen, msgsize;
5234                 ldc_status_t    lstatus;
5235 
5236                 /*
5237                  * Receive and process a message
5238                  */
5239                 vd_reset_if_needed(vd); /* can change vd->max_msglen */
5240 
5241                 /*
5242                  * check if channel is UP - else break out of loop
5243                  */
5244                 status = ldc_status(vd->ldc_handle, &lstatus);
5245                 if (lstatus != LDC_UP) {
5246                         PR0("channel not up (status=%d), exiting recv loop\n",
5247                             lstatus);
5248                         break;
5249                 }
5250 
5251                 ASSERT(vd->max_msglen != 0);
5252 
5253                 msgsize = vd->max_msglen; /* stable copy for alloc/free */
5254                 msglen  = msgsize;        /* actual len after recv_msg() */
5255 
5256                 status = recv_msg(vd->ldc_handle, vd->vio_msgp, &msglen);
5257                 switch (status) {
5258                 case 0:
5259                         rv = vd_process_msg(vd, (void *)vd->vio_msgp, msglen);
5260                         /* check if max_msglen changed */
5261                         if (msgsize != vd->max_msglen) {
5262                                 PR0("max_msglen changed 0x%lx to 0x%lx bytes\n",
5263                                     msgsize, vd->max_msglen);
5264                                 kmem_free(vd->vio_msgp, msgsize);
5265                                 vd->vio_msgp =
5266                                     kmem_alloc(vd->max_msglen, KM_SLEEP);
5267                         }
5268                         if (rv == EINPROGRESS)
5269                                 continue;
5270                         break;
5271 
5272                 case ENOMSG:
5273                         break;
5274 
5275                 case ECONNRESET:
5276                         PR0("initiating soft reset (ECONNRESET)\n");
5277                         vd_need_reset(vd, B_FALSE);
5278                         status = 0;
5279                         break;
5280 
5281                 default:
5282                         /* Probably an LDC failure; arrange to reset it */
5283                         PR0("initiating full reset (status=0x%x)", status);
5284                         vd_need_reset(vd, B_TRUE);
5285                         break;
5286                 }
5287         }
5288 
5289         PR2("Task finished");
5290 }
5291 
5292 static uint_t
5293 vd_handle_ldc_events(uint64_t event, caddr_t arg)
5294 {
5295         vd_t    *vd = (vd_t *)(void *)arg;
5296         int     status;
5297 
5298         ASSERT(vd != NULL);
5299 
5300         if (!vd_enabled(vd))
5301                 return (LDC_SUCCESS);
5302 
5303         if (event & LDC_EVT_DOWN) {
5304                 PR0("LDC_EVT_DOWN: LDC channel went down");
5305 
5306                 vd_need_reset(vd, B_TRUE);
5307                 status = ddi_taskq_dispatch(vd->startq, vd_recv_msg, vd,
5308                     DDI_SLEEP);
5309                 if (status == DDI_FAILURE) {
5310                         PR0("cannot schedule task to recv msg\n");
5311                         vd_need_reset(vd, B_TRUE);
5312                 }
5313         }
5314 
5315         if (event & LDC_EVT_RESET) {
5316                 PR0("LDC_EVT_RESET: LDC channel was reset");
5317 
5318                 if (vd->state != VD_STATE_INIT) {
5319                         PR0("scheduling full reset");
5320                         vd_need_reset(vd, B_FALSE);
5321                         status = ddi_taskq_dispatch(vd->startq, vd_recv_msg,
5322                             vd, DDI_SLEEP);
5323                         if (status == DDI_FAILURE) {
5324                                 PR0("cannot schedule task to recv msg\n");
5325                                 vd_need_reset(vd, B_TRUE);
5326                         }
5327 
5328                 } else {
5329                         PR0("channel already reset, ignoring...\n");
5330                         PR0("doing ldc up...\n");
5331                         (void) ldc_up(vd->ldc_handle);
5332                 }
5333 
5334                 return (LDC_SUCCESS);
5335         }
5336 
5337         if (event & LDC_EVT_UP) {
5338                 PR0("EVT_UP: LDC is up\nResetting client connection state");
5339                 PR0("initiating soft reset");
5340                 vd_need_reset(vd, B_FALSE);
5341                 status = ddi_taskq_dispatch(vd->startq, vd_recv_msg,
5342                     vd, DDI_SLEEP);
5343                 if (status == DDI_FAILURE) {
5344                         PR0("cannot schedule task to recv msg\n");
5345                         vd_need_reset(vd, B_TRUE);
5346                         return (LDC_SUCCESS);
5347                 }
5348         }
5349 
5350         if (event & LDC_EVT_READ) {
5351                 int     status;
5352 
5353                 PR1("New data available");
5354                 /* Queue a task to receive the new data */
5355                 status = ddi_taskq_dispatch(vd->startq, vd_recv_msg, vd,
5356                     DDI_SLEEP);
5357 
5358                 if (status == DDI_FAILURE) {
5359                         PR0("cannot schedule task to recv msg\n");
5360                         vd_need_reset(vd, B_TRUE);
5361                 }
5362         }
5363 
5364         return (LDC_SUCCESS);
5365 }
5366 
5367 static uint_t
5368 vds_check_for_vd(mod_hash_key_t key, mod_hash_val_t *val, void *arg)
5369 {
5370         _NOTE(ARGUNUSED(key, val))
5371         (*((uint_t *)arg))++;
5372         return (MH_WALK_TERMINATE);
5373 }
5374 
5375 
5376 static int
5377 vds_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
5378 {
5379         uint_t  vd_present = 0;
5380         minor_t instance;
5381         vds_t   *vds;
5382 
5383 
5384         switch (cmd) {
5385         case DDI_DETACH:
5386                 /* the real work happens below */
5387                 break;
5388         case DDI_SUSPEND:
5389                 PR0("No action required for DDI_SUSPEND");
5390                 return (DDI_SUCCESS);
5391         default:
5392                 PR0("Unrecognized \"cmd\"");
5393                 return (DDI_FAILURE);
5394         }
5395 
5396         ASSERT(cmd == DDI_DETACH);
5397         instance = ddi_get_instance(dip);
5398         if ((vds = ddi_get_soft_state(vds_state, instance)) == NULL) {
5399                 PR0("Could not get state for instance %u", instance);
5400                 ddi_soft_state_free(vds_state, instance);
5401                 return (DDI_FAILURE);
5402         }
5403 
5404         /* Do no detach when serving any vdisks */
5405         mod_hash_walk(vds->vd_table, vds_check_for_vd, &vd_present);
5406         if (vd_present) {
5407                 PR0("Not detaching because serving vdisks");
5408                 return (DDI_FAILURE);
5409         }
5410 
5411         PR0("Detaching");
5412         if (vds->initialized & VDS_MDEG) {
5413                 (void) mdeg_unregister(vds->mdeg);
5414                 kmem_free(vds->ispecp->specp, sizeof (vds_prop_template));
5415                 kmem_free(vds->ispecp, sizeof (mdeg_node_spec_t));
5416                 vds->ispecp = NULL;
5417                 vds->mdeg = NULL;
5418         }
5419 
5420         vds_driver_types_free(vds);
5421 
5422         if (vds->initialized & VDS_LDI)
5423                 (void) ldi_ident_release(vds->ldi_ident);
5424         mod_hash_destroy_hash(vds->vd_table);
5425         ddi_soft_state_free(vds_state, instance);
5426         return (DDI_SUCCESS);
5427 }
5428 
5429 /*
5430  * Description:
5431  *      This function checks to see if the disk image being used as a
5432  *      virtual disk is an ISO image. An ISO image is a special case
5433  *      which can be booted/installed from like a CD/DVD.
5434  *
5435  * Parameters:
5436  *      vd              - disk on which the operation is performed.
5437  *
5438  * Return Code:
5439  *      B_TRUE          - The disk image is an ISO 9660 compliant image
5440  *      B_FALSE         - just a regular disk image
5441  */
5442 static boolean_t
5443 vd_dskimg_is_iso_image(vd_t *vd)
5444 {
5445         char    iso_buf[ISO_SECTOR_SIZE];
5446         int     i, rv;
5447         uint_t  sec;
5448 
5449         ASSERT(VD_DSKIMG(vd));
5450 
5451         /*
5452          * If we have already discovered and saved this info we can
5453          * short-circuit the check and avoid reading the disk image.
5454          */
5455         if (vd->vdisk_media == VD_MEDIA_DVD || vd->vdisk_media == VD_MEDIA_CD)
5456                 return (B_TRUE);
5457 
5458         /*
5459          * We wish to read the sector that should contain the 2nd ISO volume
5460          * descriptor. The second field in this descriptor is called the
5461          * Standard Identifier and is set to CD001 for a CD-ROM compliant
5462          * to the ISO 9660 standard.
5463          */
5464         sec = (ISO_VOLDESC_SEC * ISO_SECTOR_SIZE) / vd->vdisk_bsize;
5465         rv = vd_dskimg_rw(vd, VD_SLICE_NONE, VD_OP_BREAD, (caddr_t)iso_buf,
5466             sec, ISO_SECTOR_SIZE);
5467 
5468         if (rv < 0)
5469                 return (B_FALSE);
5470 
5471         for (i = 0; i < ISO_ID_STRLEN; i++) {
5472                 if (ISO_STD_ID(iso_buf)[i] != ISO_ID_STRING[i])
5473                         return (B_FALSE);
5474         }
5475 
5476         return (B_TRUE);
5477 }
5478 
5479 /*
5480  * Description:
5481  *      This function checks to see if the virtual device is an ATAPI
5482  *      device. ATAPI devices use Group 1 Read/Write commands, so
5483  *      any USCSI calls vds makes need to take this into account.
5484  *
5485  * Parameters:
5486  *      vd              - disk on which the operation is performed.
5487  *
5488  * Return Code:
5489  *      B_TRUE          - The virtual disk is backed by an ATAPI device
5490  *      B_FALSE         - not an ATAPI device (presumably SCSI)
5491  */
5492 static boolean_t
5493 vd_is_atapi_device(vd_t *vd)
5494 {
5495         boolean_t       is_atapi = B_FALSE;
5496         char            *variantp;
5497         int             rv;
5498 
5499         ASSERT(vd->ldi_handle[0] != NULL);
5500         ASSERT(!vd->file);
5501 
5502         rv = ldi_prop_lookup_string(vd->ldi_handle[0],
5503             (LDI_DEV_T_ANY | DDI_PROP_DONTPASS), "variant", &variantp);
5504         if (rv == DDI_PROP_SUCCESS) {
5505                 PR0("'variant' property exists for %s", vd->device_path);
5506                 if (strcmp(variantp, "atapi") == 0)
5507                         is_atapi = B_TRUE;
5508                 ddi_prop_free(variantp);
5509         }
5510 
5511         rv = ldi_prop_exists(vd->ldi_handle[0], LDI_DEV_T_ANY, "atapi");
5512         if (rv) {
5513                 PR0("'atapi' property exists for %s", vd->device_path);
5514                 is_atapi = B_TRUE;
5515         }
5516 
5517         return (is_atapi);
5518 }
5519 
5520 static int
5521 vd_setup_full_disk(vd_t *vd)
5522 {
5523         int             status;
5524         major_t         major = getmajor(vd->dev[0]);
5525         minor_t         minor = getminor(vd->dev[0]) - VD_ENTIRE_DISK_SLICE;
5526 
5527         ASSERT(vd->vdisk_type == VD_DISK_TYPE_DISK);
5528 
5529         /* set the disk size, block size and the media type of the disk */
5530         status = vd_backend_check_size(vd);
5531 
5532         if (status != 0) {
5533                 if (!vd->scsi) {
5534                         /* unexpected failure */
5535                         PRN("Check size failed for %s (errno %d)",
5536                             vd->device_path, status);
5537                         return (EIO);
5538                 }
5539 
5540                 /*
5541                  * The function can fail for SCSI disks which are present but
5542                  * reserved by another system. In that case, we don't know the
5543                  * size of the disk and the block size.
5544                  */
5545                 vd->vdisk_size = VD_SIZE_UNKNOWN;
5546                 vd->vdisk_bsize = 0;
5547                 vd->backend_bsize = 0;
5548                 vd->vdisk_media = VD_MEDIA_FIXED;
5549         }
5550 
5551         /* Move dev number and LDI handle to entire-disk-slice array elements */
5552         vd->dev[VD_ENTIRE_DISK_SLICE]                = vd->dev[0];
5553         vd->dev[0]                           = 0;
5554         vd->ldi_handle[VD_ENTIRE_DISK_SLICE] = vd->ldi_handle[0];
5555         vd->ldi_handle[0]                    = NULL;
5556 
5557         /* Initialize device numbers for remaining slices and open them */
5558         for (int slice = 0; slice < vd->nslices; slice++) {
5559                 /*
5560                  * Skip the entire-disk slice, as it's already open and its
5561                  * device known
5562                  */
5563                 if (slice == VD_ENTIRE_DISK_SLICE)
5564                         continue;
5565                 ASSERT(vd->dev[slice] == 0);
5566                 ASSERT(vd->ldi_handle[slice] == NULL);
5567 
5568                 /*
5569                  * Construct the device number for the current slice
5570                  */
5571                 vd->dev[slice] = makedevice(major, (minor + slice));
5572 
5573                 /*
5574                  * Open all slices of the disk to serve them to the client.
5575                  * Slices are opened exclusively to prevent other threads or
5576                  * processes in the service domain from performing I/O to
5577                  * slices being accessed by a client.  Failure to open a slice
5578                  * results in vds not serving this disk, as the client could
5579                  * attempt (and should be able) to access any slice immediately.
5580                  * Any slices successfully opened before a failure will get
5581                  * closed by vds_destroy_vd() as a result of the error returned
5582                  * by this function.
5583                  *
5584                  * We need to do the open with FNDELAY so that opening an empty
5585                  * slice does not fail.
5586                  */
5587                 PR0("Opening device major %u, minor %u = slice %u",
5588                     major, minor, slice);
5589 
5590                 /*
5591                  * Try to open the device. This can fail for example if we are
5592                  * opening an empty slice. So in case of a failure, we try the
5593                  * open again but this time with the FNDELAY flag.
5594                  */
5595                 status = ldi_open_by_dev(&vd->dev[slice], OTYP_BLK,
5596                     vd->open_flags, kcred, &vd->ldi_handle[slice],
5597                     vd->vds->ldi_ident);
5598 
5599                 if (status != 0) {
5600                         status = ldi_open_by_dev(&vd->dev[slice], OTYP_BLK,
5601                             vd->open_flags | FNDELAY, kcred,
5602                             &vd->ldi_handle[slice], vd->vds->ldi_ident);
5603                 }
5604 
5605                 if (status != 0) {
5606                         PRN("ldi_open_by_dev() returned errno %d "
5607                             "for slice %u", status, slice);
5608                         /* vds_destroy_vd() will close any open slices */
5609                         vd->ldi_handle[slice] = NULL;
5610                         return (status);
5611                 }
5612         }
5613 
5614         return (0);
5615 }
5616 
5617 /*
5618  * When a slice or a volume is exported as a single-slice disk, we want
5619  * the disk backend (i.e. the slice or volume) to be entirely mapped as
5620  * a slice without the addition of any metadata.
5621  *
5622  * So when exporting the disk as a VTOC disk, we fake a disk with the following
5623  * layout:
5624  *                flabel +--- flabel_limit
5625  *                 <->   V
5626  *                 0 1   C                          D  E
5627  *                 +-+---+--------------------------+--+
5628  *  virtual disk:  |L|XXX|           slice 0        |AA|
5629  *                 +-+---+--------------------------+--+
5630  *                  ^    :                          :
5631  *                  |    :                          :
5632  *      VTOC LABEL--+    :                          :
5633  *                       +--------------------------+
5634  *  disk backend:        |     slice/volume/file    |
5635  *                       +--------------------------+
5636  *                       0                          N
5637  *
5638  * N is the number of blocks in the slice/volume/file.
5639  *
5640  * We simulate a disk with N+M blocks, where M is the number of blocks
5641  * simluated at the beginning and at the end of the disk (blocks 0-C
5642  * and D-E).
5643  *
5644  * The first blocks (0 to C-1) are emulated and can not be changed. Blocks C
5645  * to D defines slice 0 and are mapped to the backend. Finally we emulate 2
5646  * alternate cylinders at the end of the disk (blocks D-E). In summary we have:
5647  *
5648  * - block 0 (L) returns a fake VTOC label
5649  * - blocks 1 to C-1 (X) are unused and return 0
5650  * - blocks C to D-1 are mapped to the exported slice or volume
5651  * - blocks D and E (A) are blocks defining alternate cylinders (2 cylinders)
5652  *
5653  * Note: because we define a fake disk geometry, it is possible that the length
5654  * of the backend is not a multiple of the size of cylinder, in that case the
5655  * very end of the backend will not map to any block of the virtual disk.
5656  */
5657 static int
5658 vd_setup_partition_vtoc(vd_t *vd)
5659 {
5660         char *device_path = vd->device_path;
5661         char unit;
5662         size_t size, csize;
5663 
5664         /* Initialize dk_geom structure for single-slice device */
5665         if (vd->dk_geom.dkg_nsect == 0) {
5666                 PRN("%s geometry claims 0 sectors per track", device_path);
5667                 return (EIO);
5668         }
5669         if (vd->dk_geom.dkg_nhead == 0) {
5670                 PRN("%s geometry claims 0 heads", device_path);
5671                 return (EIO);
5672         }
5673 
5674         /* size of a cylinder in block */
5675         csize = vd->dk_geom.dkg_nhead * vd->dk_geom.dkg_nsect;
5676 
5677         /*
5678          * Add extra cylinders: we emulate the first cylinder (which contains
5679          * the disk label).
5680          */
5681         vd->dk_geom.dkg_ncyl = vd->vdisk_size / csize + 1;
5682 
5683         /* we emulate 2 alternate cylinders */
5684         vd->dk_geom.dkg_acyl = 2;
5685         vd->dk_geom.dkg_pcyl = vd->dk_geom.dkg_ncyl + vd->dk_geom.dkg_acyl;
5686 
5687 
5688         /* Initialize vtoc structure for single-slice device */
5689         bzero(vd->vtoc.v_part, sizeof (vd->vtoc.v_part));
5690         vd->vtoc.v_part[0].p_tag = V_UNASSIGNED;
5691         vd->vtoc.v_part[0].p_flag = 0;
5692         /*
5693          * Partition 0 starts on cylinder 1 and its size has to be
5694          * a multiple of a number of cylinder.
5695          */
5696         vd->vtoc.v_part[0].p_start = csize; /* start on cylinder 1 */
5697         vd->vtoc.v_part[0].p_size = (vd->vdisk_size / csize) * csize;
5698 
5699         if (vd_slice_single_slice) {
5700                 vd->vtoc.v_nparts = 1;
5701                 bcopy(VD_ASCIILABEL, vd->vtoc.v_asciilabel,
5702                     MIN(sizeof (VD_ASCIILABEL),
5703                     sizeof (vd->vtoc.v_asciilabel)));
5704                 bcopy(VD_VOLUME_NAME, vd->vtoc.v_volume,
5705                     MIN(sizeof (VD_VOLUME_NAME), sizeof (vd->vtoc.v_volume)));
5706         } else {
5707                 /* adjust the number of slices */
5708                 vd->nslices = V_NUMPAR;
5709                 vd->vtoc.v_nparts = V_NUMPAR;
5710 
5711                 /* define slice 2 representing the entire disk */
5712                 vd->vtoc.v_part[VD_ENTIRE_DISK_SLICE].p_tag = V_BACKUP;
5713                 vd->vtoc.v_part[VD_ENTIRE_DISK_SLICE].p_flag = 0;
5714                 vd->vtoc.v_part[VD_ENTIRE_DISK_SLICE].p_start = 0;
5715                 vd->vtoc.v_part[VD_ENTIRE_DISK_SLICE].p_size =
5716                     vd->dk_geom.dkg_ncyl * csize;
5717 
5718                 vd_get_readable_size(vd->vdisk_size * vd->vdisk_bsize,
5719                     &size, &unit);
5720 
5721                 /*
5722                  * Set some attributes of the geometry to what format(1m) uses
5723                  * so that writing a default label using format(1m) does not
5724                  * produce any error.
5725                  */
5726                 vd->dk_geom.dkg_bcyl = 0;
5727                 vd->dk_geom.dkg_intrlv = 1;
5728                 vd->dk_geom.dkg_write_reinstruct = 0;
5729                 vd->dk_geom.dkg_read_reinstruct = 0;
5730 
5731                 /*
5732                  * We must have a correct label name otherwise format(1m) will
5733                  * not recognized the disk as labeled.
5734                  */
5735                 (void) snprintf(vd->vtoc.v_asciilabel, LEN_DKL_ASCII,
5736                     "SUN-DiskSlice-%ld%cB cyl %d alt %d hd %d sec %d",
5737                     size, unit,
5738                     vd->dk_geom.dkg_ncyl, vd->dk_geom.dkg_acyl,
5739                     vd->dk_geom.dkg_nhead, vd->dk_geom.dkg_nsect);
5740                 bzero(vd->vtoc.v_volume, sizeof (vd->vtoc.v_volume));
5741 
5742                 /* create a fake label from the vtoc and geometry */
5743                 vd->flabel_limit = (uint_t)csize;
5744                 vd->flabel_size = VD_LABEL_VTOC_SIZE(vd->vdisk_bsize);
5745                 vd->flabel = kmem_zalloc(vd->flabel_size, KM_SLEEP);
5746                 vd_vtocgeom_to_label(&vd->vtoc, &vd->dk_geom,
5747                     VD_LABEL_VTOC(vd));
5748         }
5749 
5750         /* adjust the vdisk_size, we emulate 3 cylinders */
5751         vd->vdisk_size += csize * 3;
5752 
5753         return (0);
5754 }
5755 
5756 /*
5757  * When a slice, volume or file is exported as a single-slice disk, we want
5758  * the disk backend (i.e. the slice, volume or file) to be entirely mapped
5759  * as a slice without the addition of any metadata.
5760  *
5761  * So when exporting the disk as an EFI disk, we fake a disk with the following
5762  * layout: (assuming the block size is 512 bytes)
5763  *
5764  *                  flabel        +--- flabel_limit
5765  *                 <------>       v
5766  *                 0 1 2  L      34                        34+N      P
5767  *                 +-+-+--+-------+--------------------------+-------+
5768  *  virtual disk:  |X|T|EE|XXXXXXX|           slice 0        |RRRRRRR|
5769  *                 +-+-+--+-------+--------------------------+-------+
5770  *                    ^ ^         :                          :
5771  *                    | |         :                          :
5772  *                GPT-+ +-GPE     :                          :
5773  *                                +--------------------------+
5774  *  disk backend:                 |     slice/volume/file    |
5775  *                                +--------------------------+
5776  *                                0                          N
5777  *
5778  * N is the number of blocks in the slice/volume/file.
5779  *
5780  * We simulate a disk with N+M blocks, where M is the number of blocks
5781  * simluated at the beginning and at the end of the disk (blocks 0-34
5782  * and 34+N-P).
5783  *
5784  * The first 34 blocks (0 to 33) are emulated and can not be changed. Blocks 34
5785  * to 34+N defines slice 0 and are mapped to the exported backend, and we
5786  * emulate some blocks at the end of the disk (blocks 34+N to P) as a the EFI
5787  * reserved partition.
5788  *
5789  * - block 0 (X) is unused and return 0
5790  * - block 1 (T) returns a fake EFI GPT (via DKIOCGETEFI)
5791  * - blocks 2 to L-1 (E) defines a fake EFI GPE (via DKIOCGETEFI)
5792  * - blocks L to 33 (X) are unused and return 0
5793  * - blocks 34 to 34+N are mapped to the exported slice, volume or file
5794  * - blocks 34+N+1 to P define a fake reserved partition and backup label, it
5795  *   returns 0
5796  *
5797  * Note: if the backend size is not a multiple of the vdisk block size then
5798  * the very end of the backend will not map to any block of the virtual disk.
5799  */
5800 static int
5801 vd_setup_partition_efi(vd_t *vd)
5802 {
5803         efi_gpt_t *gpt;
5804         efi_gpe_t *gpe;
5805         struct uuid uuid = EFI_USR;
5806         struct uuid efi_reserved = EFI_RESERVED;
5807         uint32_t crc;
5808         uint64_t s0_start, s0_end, first_u_lba;
5809         size_t bsize;
5810 
5811         ASSERT(vd->vdisk_bsize > 0);
5812 
5813         bsize = vd->vdisk_bsize;
5814         /*
5815          * The minimum size for the label is 16K (EFI_MIN_ARRAY_SIZE)
5816          * for GPEs plus one block for the GPT and one for PMBR.
5817          */
5818         first_u_lba = (EFI_MIN_ARRAY_SIZE / bsize) + 2;
5819         vd->flabel_limit = (uint_t)first_u_lba;
5820         vd->flabel_size = VD_LABEL_EFI_SIZE(bsize);
5821         vd->flabel = kmem_zalloc(vd->flabel_size, KM_SLEEP);
5822         gpt = VD_LABEL_EFI_GPT(vd, bsize);
5823         gpe = VD_LABEL_EFI_GPE(vd, bsize);
5824 
5825         /*
5826          * Adjust the vdisk_size, we emulate the first few blocks
5827          * for the disk label.
5828          */
5829         vd->vdisk_size += first_u_lba;
5830         s0_start = first_u_lba;
5831         s0_end = vd->vdisk_size - 1;
5832 
5833         gpt->efi_gpt_Signature = LE_64(EFI_SIGNATURE);
5834         gpt->efi_gpt_Revision = LE_32(EFI_VERSION_CURRENT);
5835         gpt->efi_gpt_HeaderSize = LE_32(sizeof (efi_gpt_t));
5836         gpt->efi_gpt_FirstUsableLBA = LE_64(first_u_lba);
5837         gpt->efi_gpt_PartitionEntryLBA = LE_64(2ULL);
5838         gpt->efi_gpt_SizeOfPartitionEntry = LE_32(sizeof (efi_gpe_t));
5839 
5840         UUID_LE_CONVERT(gpe[0].efi_gpe_PartitionTypeGUID, uuid);
5841         gpe[0].efi_gpe_StartingLBA = LE_64(s0_start);
5842         gpe[0].efi_gpe_EndingLBA = LE_64(s0_end);
5843 
5844         if (vd_slice_single_slice) {
5845                 gpt->efi_gpt_NumberOfPartitionEntries = LE_32(1);
5846         } else {
5847                 /* adjust the number of slices */
5848                 gpt->efi_gpt_NumberOfPartitionEntries = LE_32(VD_MAXPART);
5849                 vd->nslices = V_NUMPAR;
5850 
5851                 /* define a fake reserved partition */
5852                 UUID_LE_CONVERT(gpe[VD_MAXPART - 1].efi_gpe_PartitionTypeGUID,
5853                     efi_reserved);
5854                 gpe[VD_MAXPART - 1].efi_gpe_StartingLBA =
5855                     LE_64(s0_end + 1);
5856                 gpe[VD_MAXPART - 1].efi_gpe_EndingLBA =
5857                     LE_64(s0_end + EFI_MIN_RESV_SIZE);
5858 
5859                 /* adjust the vdisk_size to include the reserved slice */
5860                 vd->vdisk_size += EFI_MIN_RESV_SIZE;
5861         }
5862 
5863         gpt->efi_gpt_LastUsableLBA = LE_64(vd->vdisk_size - 1);
5864 
5865         /* adjust the vdisk size for the backup GPT and GPE */
5866         vd->vdisk_size += (EFI_MIN_ARRAY_SIZE / bsize) + 1;
5867         gpt->efi_gpt_AlternateLBA = LE_64(vd->vdisk_size - 1);
5868 
5869         CRC32(crc, gpe, sizeof (efi_gpe_t) * VD_MAXPART, -1U, crc32_table);
5870         gpt->efi_gpt_PartitionEntryArrayCRC32 = LE_32(~crc);
5871 
5872         CRC32(crc, gpt, sizeof (efi_gpt_t), -1U, crc32_table);
5873         gpt->efi_gpt_HeaderCRC32 = LE_32(~crc);
5874 
5875         return (0);
5876 }
5877 
5878 /*
5879  * Setup for a virtual disk whose backend is a file (exported as a single slice
5880  * or as a full disk). In that case, the backend is accessed using the vnode
5881  * interface.
5882  */
5883 static int
5884 vd_setup_backend_vnode(vd_t *vd)
5885 {
5886         int             rval, status;
5887         dev_t           dev;
5888         char            *file_path = vd->device_path;
5889         ldi_handle_t    lhandle;
5890         struct dk_cinfo dk_cinfo;
5891 
5892         ASSERT(!vd->volume);
5893 
5894         if ((status = vn_open(file_path, UIO_SYSSPACE, vd->open_flags | FOFFMAX,
5895             0, &vd->file_vnode, 0, 0)) != 0) {
5896                 if ((status == ENXIO || status == ENODEV || status == ENOENT ||
5897                     status == EROFS) && (!(vd->initialized & VD_SETUP_ERROR) &&
5898                     !(DEVI_IS_ATTACHING(vd->vds->dip)))) {
5899                         PRN("vn_open(%s) = errno %d", file_path, status);
5900                 }
5901                 return (status);
5902         }
5903 
5904         /*
5905          * We set vd->file now so that vds_destroy_vd will take care of
5906          * closing the file and releasing the vnode in case of an error.
5907          */
5908         vd->file = B_TRUE;
5909 
5910         vd->max_xfer_sz = maxphys / DEV_BSIZE; /* default transfer size */
5911 
5912         /*
5913          * Get max_xfer_sz from the device where the file is.
5914          */
5915         dev = vd->file_vnode->v_vfsp->vfs_dev;
5916         PR0("underlying device of %s = (%d, %d)\n", file_path,
5917             getmajor(dev), getminor(dev));
5918 
5919         status = ldi_open_by_dev(&dev, OTYP_BLK, FREAD, kcred, &lhandle,
5920             vd->vds->ldi_ident);
5921 
5922         if (status != 0) {
5923                 PR0("ldi_open() returned errno %d for underlying device",
5924                     status);
5925         } else {
5926                 if ((status = ldi_ioctl(lhandle, DKIOCINFO,
5927                     (intptr_t)&dk_cinfo, (vd->open_flags | FKIOCTL), kcred,
5928                     &rval)) != 0) {
5929                         PR0("ldi_ioctl(DKIOCINFO) returned errno %d for "
5930                             "underlying device", status);
5931                 } else {
5932                         /*
5933                          * Store the device's max transfer size for
5934                          * return to the client
5935                          */
5936                         vd->max_xfer_sz = dk_cinfo.dki_maxtransfer;
5937                 }
5938 
5939                 PR0("close the underlying device");
5940                 (void) ldi_close(lhandle, FREAD, kcred);
5941         }
5942 
5943         PR0("using file %s on device (%d, %d), max_xfer = %u blks",
5944             file_path, getmajor(dev), getminor(dev), vd->max_xfer_sz);
5945 
5946         if (vd->vdisk_type == VD_DISK_TYPE_SLICE)
5947                 status = vd_setup_slice_image(vd);
5948         else
5949                 status = vd_setup_disk_image(vd);
5950 
5951         return (status);
5952 }
5953 
5954 static int
5955 vd_setup_slice_image(vd_t *vd)
5956 {
5957         struct dk_label label;
5958         int status;
5959 
5960         if ((status = vd_backend_check_size(vd)) != 0) {
5961                 PRN("Check size failed for %s (errno %d)",
5962                     vd->device_path, status);
5963                 return (EIO);
5964         }
5965 
5966         vd->vdisk_media = VD_MEDIA_FIXED;
5967         vd->vdisk_label = (vd_slice_label == VD_DISK_LABEL_UNK)?
5968             vd_file_slice_label : vd_slice_label;
5969 
5970         if (vd->vdisk_label == VD_DISK_LABEL_EFI ||
5971             vd->dskimg_size >= 2 * ONE_TERABYTE) {
5972                 status = vd_setup_partition_efi(vd);
5973         } else {
5974                 /*
5975                  * We build a default label to get a geometry for
5976                  * the vdisk. Then the partition setup function will
5977                  * adjust the vtoc so that it defines a single-slice
5978                  * disk.
5979                  */
5980                 vd_build_default_label(vd->dskimg_size, vd->vdisk_bsize,
5981                     &label);
5982                 vd_label_to_vtocgeom(&label, &vd->vtoc, &vd->dk_geom);
5983                 status = vd_setup_partition_vtoc(vd);
5984         }
5985 
5986         return (status);
5987 }
5988 
5989 static int
5990 vd_setup_disk_image(vd_t *vd)
5991 {
5992         int status;
5993         char *backend_path = vd->device_path;
5994 
5995         if ((status = vd_backend_check_size(vd)) != 0) {
5996                 PRN("Check size failed for %s (errno %d)",
5997                     backend_path, status);
5998                 return (EIO);
5999         }
6000 
6001         /* size should be at least sizeof(dk_label) */
6002         if (vd->dskimg_size < sizeof (struct dk_label)) {
6003                 PRN("Size of file has to be at least %ld bytes",
6004                     sizeof (struct dk_label));
6005                 return (EIO);
6006         }
6007 
6008         /*
6009          * Find and validate the geometry of a disk image.
6010          */
6011         status = vd_dskimg_validate_geometry(vd);
6012         if (status != 0 && status != EINVAL && status != ENOTSUP) {
6013                 PRN("Failed to read label from %s", backend_path);
6014                 return (EIO);
6015         }
6016 
6017         if (vd_dskimg_is_iso_image(vd)) {
6018                 /*
6019                  * Indicate whether to call this a CD or DVD from the size
6020                  * of the ISO image (images for both drive types are stored
6021                  * in the ISO-9600 format). CDs can store up to just under 1Gb
6022                  */
6023                 if ((vd->vdisk_size * vd->vdisk_bsize) > ONE_GIGABYTE)
6024                         vd->vdisk_media = VD_MEDIA_DVD;
6025                 else
6026                         vd->vdisk_media = VD_MEDIA_CD;
6027         } else {
6028                 vd->vdisk_media = VD_MEDIA_FIXED;
6029         }
6030 
6031         /* Setup devid for the disk image */
6032 
6033         if (vd->vdisk_label != VD_DISK_LABEL_UNK) {
6034 
6035                 status = vd_dskimg_read_devid(vd, &vd->dskimg_devid);
6036 
6037                 if (status == 0) {
6038                         /* a valid devid was found */
6039                         return (0);
6040                 }
6041 
6042                 if (status != EINVAL) {
6043                         /*
6044                          * There was an error while trying to read the devid.
6045                          * So this disk image may have a devid but we are
6046                          * unable to read it.
6047                          */
6048                         PR0("can not read devid for %s", backend_path);
6049                         vd->dskimg_devid = NULL;
6050                         return (0);
6051                 }
6052         }
6053 
6054         /*
6055          * No valid device id was found so we create one. Note that a failure
6056          * to create a device id is not fatal and does not prevent the disk
6057          * image from being attached.
6058          */
6059         PR1("creating devid for %s", backend_path);
6060 
6061         if (ddi_devid_init(vd->vds->dip, DEVID_FAB, NULL, 0,
6062             &vd->dskimg_devid) != DDI_SUCCESS) {
6063                 PR0("fail to create devid for %s", backend_path);
6064                 vd->dskimg_devid = NULL;
6065                 return (0);
6066         }
6067 
6068         /*
6069          * Write devid to the disk image. The devid is stored into the disk
6070          * image if we have a valid label; otherwise the devid will be stored
6071          * when the user writes a valid label.
6072          */
6073         if (vd->vdisk_label != VD_DISK_LABEL_UNK) {
6074                 if (vd_dskimg_write_devid(vd, vd->dskimg_devid) != 0) {
6075                         PR0("fail to write devid for %s", backend_path);
6076                         ddi_devid_free(vd->dskimg_devid);
6077                         vd->dskimg_devid = NULL;
6078                 }
6079         }
6080 
6081         return (0);
6082 }
6083 
6084 
6085 /*
6086  * Description:
6087  *      Open a device using its device path (supplied by ldm(1m))
6088  *
6089  * Parameters:
6090  *      vd      - pointer to structure containing the vDisk info
6091  *      flags   - open flags
6092  *
6093  * Return Value
6094  *      0       - success
6095  *      != 0    - some other non-zero return value from ldi(9F) functions
6096  */
6097 static int
6098 vd_open_using_ldi_by_name(vd_t *vd, int flags)
6099 {
6100         int             status;
6101         char            *device_path = vd->device_path;
6102 
6103         /* Attempt to open device */
6104         status = ldi_open_by_name(device_path, flags, kcred,
6105             &vd->ldi_handle[0], vd->vds->ldi_ident);
6106 
6107         /*
6108          * The open can fail for example if we are opening an empty slice.
6109          * In case of a failure, we try the open again but this time with
6110          * the FNDELAY flag.
6111          */
6112         if (status != 0)
6113                 status = ldi_open_by_name(device_path, flags | FNDELAY,
6114                     kcred, &vd->ldi_handle[0], vd->vds->ldi_ident);
6115 
6116         if (status != 0) {
6117                 PR0("ldi_open_by_name(%s) = errno %d", device_path, status);
6118                 vd->ldi_handle[0] = NULL;
6119                 return (status);
6120         }
6121 
6122         return (0);
6123 }
6124 
6125 /*
6126  * Setup for a virtual disk which backend is a device (a physical disk,
6127  * slice or volume device) exported as a full disk or as a slice. In these
6128  * cases, the backend is accessed using the LDI interface.
6129  */
6130 static int
6131 vd_setup_backend_ldi(vd_t *vd)
6132 {
6133         int             rval, status;
6134         struct dk_cinfo dk_cinfo;
6135         char            *device_path = vd->device_path;
6136 
6137         /* device has been opened by vd_identify_dev() */
6138         ASSERT(vd->ldi_handle[0] != NULL);
6139         ASSERT(vd->dev[0] != NULL);
6140 
6141         vd->file = B_FALSE;
6142 
6143         /* Verify backing device supports dk_cinfo */
6144         if ((status = ldi_ioctl(vd->ldi_handle[0], DKIOCINFO,
6145             (intptr_t)&dk_cinfo, (vd->open_flags | FKIOCTL), kcred,
6146             &rval)) != 0) {
6147                 PRN("ldi_ioctl(DKIOCINFO) returned errno %d for %s",
6148                     status, device_path);
6149                 return (status);
6150         }
6151         if (dk_cinfo.dki_partition >= V_NUMPAR) {
6152                 PRN("slice %u >= maximum slice %u for %s",
6153                     dk_cinfo.dki_partition, V_NUMPAR, device_path);
6154                 return (EIO);
6155         }
6156 
6157         /*
6158          * The device has been opened read-only by vd_identify_dev(), re-open
6159          * it read-write if the write flag is set and we don't have an optical
6160          * device such as a CD-ROM, which, for now, we do not permit writes to
6161          * and thus should not export write operations to the client.
6162          *
6163          * Future: if/when we implement support for guest domains writing to
6164          * optical devices we will need to do further checking of the media type
6165          * to distinguish between read-only and writable discs.
6166          */
6167         if (dk_cinfo.dki_ctype == DKC_CDROM) {
6168 
6169                 vd->open_flags &= ~FWRITE;
6170 
6171         } else if (vd->open_flags & FWRITE) {
6172 
6173                 (void) ldi_close(vd->ldi_handle[0], vd->open_flags & ~FWRITE,
6174                     kcred);
6175                 status = vd_open_using_ldi_by_name(vd, vd->open_flags);
6176                 if (status != 0) {
6177                         PR0("Failed to open (%s) = errno %d",
6178                             device_path, status);
6179                         return (status);
6180                 }
6181         }
6182 
6183         /* Store the device's max transfer size for return to the client */
6184         vd->max_xfer_sz = dk_cinfo.dki_maxtransfer;
6185 
6186         /*
6187          * We need to work out if it's an ATAPI (IDE CD-ROM) or SCSI device so
6188          * that we can use the correct CDB group when sending USCSI commands.
6189          */
6190         vd->is_atapi_dev = vd_is_atapi_device(vd);
6191 
6192         /*
6193          * Export a full disk.
6194          *
6195          * The exported device can be either a volume, a disk or a CD/DVD
6196          * device.  We export a device as a full disk if we have an entire
6197          * disk slice (slice 2) and if this slice is exported as a full disk
6198          * and not as a single slice disk. A CD or DVD device is exported
6199          * as a full disk (even if it isn't s2). A volume is exported as a
6200          * full disk as long as the "slice" option is not specified.
6201          */
6202         if (vd->vdisk_type == VD_DISK_TYPE_DISK) {
6203 
6204                 if (vd->volume) {
6205                         /* setup disk image */
6206                         return (vd_setup_disk_image(vd));
6207                 }
6208 
6209                 if (dk_cinfo.dki_partition == VD_ENTIRE_DISK_SLICE ||
6210                     dk_cinfo.dki_ctype == DKC_CDROM) {
6211                         ASSERT(!vd->volume);
6212                         if (dk_cinfo.dki_ctype == DKC_SCSI_CCS)
6213                                 vd->scsi = B_TRUE;
6214                         return (vd_setup_full_disk(vd));
6215                 }
6216         }
6217 
6218         /*
6219          * Export a single slice disk.
6220          *
6221          * The exported device can be either a volume device or a disk slice. If
6222          * it is a disk slice different from slice 2 then it is always exported
6223          * as a single slice disk even if the "slice" option is not specified.
6224          * If it is disk slice 2 or a volume device then it is exported as a
6225          * single slice disk only if the "slice" option is specified.
6226          */
6227         return (vd_setup_single_slice_disk(vd));
6228 }
6229 
6230 static int
6231 vd_setup_single_slice_disk(vd_t *vd)
6232 {
6233         int status, rval;
6234         struct dk_label label;
6235         char *device_path = vd->device_path;
6236         struct vtoc vtoc;
6237 
6238         vd->vdisk_media = VD_MEDIA_FIXED;
6239 
6240         if (vd->volume) {
6241                 ASSERT(vd->vdisk_type == VD_DISK_TYPE_SLICE);
6242         }
6243 
6244         /*
6245          * We export the slice as a single slice disk even if the "slice"
6246          * option was not specified.
6247          */
6248         vd->vdisk_type  = VD_DISK_TYPE_SLICE;
6249         vd->nslices  = 1;
6250 
6251         /* Get size of backing device */
6252         if ((status = vd_backend_check_size(vd)) != 0) {
6253                 PRN("Check size failed for %s (errno %d)", device_path, status);
6254                 return (EIO);
6255         }
6256 
6257         /*
6258          * When exporting a slice or a device as a single slice disk, we don't
6259          * care about any partitioning exposed by the backend. The goal is just
6260          * to export the backend as a flat storage. We provide a fake partition
6261          * table (either a VTOC or EFI), which presents only one slice, to
6262          * accommodate tools expecting a disk label. The selection of the label
6263          * type (VTOC or EFI) depends on the value of the vd_slice_label
6264          * variable.
6265          */
6266         if (vd_slice_label == VD_DISK_LABEL_EFI ||
6267             vd->vdisk_size >= ONE_TERABYTE / vd->vdisk_bsize) {
6268                 vd->vdisk_label = VD_DISK_LABEL_EFI;
6269         } else {
6270                 status = ldi_ioctl(vd->ldi_handle[0], DKIOCGEXTVTOC,
6271                     (intptr_t)&vd->vtoc, (vd->open_flags | FKIOCTL),
6272                     kcred, &rval);
6273 
6274                 if (status == ENOTTY) {
6275                         /* try with the non-extended vtoc ioctl */
6276                         status = ldi_ioctl(vd->ldi_handle[0], DKIOCGVTOC,
6277                             (intptr_t)&vtoc, (vd->open_flags | FKIOCTL),
6278                             kcred, &rval);
6279                         vtoctoextvtoc(vtoc, vd->vtoc);
6280                 }
6281 
6282                 if (status == 0) {
6283                         status = ldi_ioctl(vd->ldi_handle[0], DKIOCGGEOM,
6284                             (intptr_t)&vd->dk_geom, (vd->open_flags | FKIOCTL),
6285                             kcred, &rval);
6286 
6287                         if (status != 0) {
6288                                 PRN("ldi_ioctl(DKIOCGEOM) returned errno %d "
6289                                     "for %s", status, device_path);
6290                                 return (status);
6291                         }
6292                         vd->vdisk_label = VD_DISK_LABEL_VTOC;
6293 
6294                 } else if (vd_slice_label == VD_DISK_LABEL_VTOC) {
6295 
6296                         vd->vdisk_label = VD_DISK_LABEL_VTOC;
6297                         vd_build_default_label(vd->vdisk_size * vd->vdisk_bsize,
6298                             vd->vdisk_bsize, &label);
6299                         vd_label_to_vtocgeom(&label, &vd->vtoc, &vd->dk_geom);
6300 
6301                 } else {
6302                         vd->vdisk_label = VD_DISK_LABEL_EFI;
6303                 }
6304         }
6305 
6306         if (vd->vdisk_label == VD_DISK_LABEL_VTOC) {
6307                 /* export with a fake VTOC label */
6308                 status = vd_setup_partition_vtoc(vd);
6309 
6310         } else {
6311                 /* export with a fake EFI label */
6312                 status = vd_setup_partition_efi(vd);
6313         }
6314 
6315         return (status);
6316 }
6317 
6318 /*
6319  * This function is invoked when setting up the vdisk backend and to process
6320  * the VD_OP_GET_CAPACITY operation. It checks the backend size and set the
6321  * following attributes of the vd structure:
6322  *
6323  * - vdisk_bsize: block size for the virtual disk used by the VIO protocol. Its
6324  *   value is 512 bytes (DEV_BSIZE) when the backend is a file, a volume or a
6325  *   CD/DVD. When the backend is a disk or a disk slice then it has the value
6326  *   of the logical block size of that disk (as returned by the DKIOCGMEDIAINFO
6327  *   ioctl). This block size is expected to be a power of 2 and a multiple of
6328  *   512.
6329  *
6330  * - vdisk_size: size of the virtual disk expressed as a number of vdisk_bsize
6331  *   blocks.
6332  *
6333  * vdisk_size and vdisk_bsize are sent to the vdisk client during the connection
6334  * handshake and in the result of a VD_OP_GET_CAPACITY operation.
6335  *
6336  * - backend_bsize: block size of the backend device. backend_bsize has the same
6337  *   value as vdisk_bsize except when the backend is a CD/DVD. In that case,
6338  *   vdisk_bsize is set to 512 (DEV_BSIZE) while backend_bsize is set to the
6339  *   effective logical block size of the CD/DVD (usually 2048).
6340  *
6341  * - dskimg_size: size of the backend when the backend is a disk image. This
6342  *   attribute is set only when the backend is a file or a volume, otherwise it
6343  *   is unused.
6344  *
6345  * - vio_bshift: number of bit to shift to convert a VIO block number (which
6346  *   uses a block size of vdisk_bsize) to a buf(9s) block number (which uses a
6347  *   block size of 512 bytes) i.e. we have vdisk_bsize = 512 x 2 ^ vio_bshift
6348  *
6349  * - vdisk_media: media of the virtual disk. This function only sets this
6350  *   attribute for physical disk and CD/DVD. For other backend types, this
6351  *   attribute is set in the setup function of the backend.
6352  */
6353 static int
6354 vd_backend_check_size(vd_t *vd)
6355 {
6356         size_t backend_size, backend_bsize, vdisk_bsize;
6357         size_t old_size, new_size;
6358         struct dk_minfo minfo;
6359         vattr_t vattr;
6360         int rval, rv, media, nshift = 0;
6361         uint32_t n;
6362 
6363         if (vd->file) {
6364 
6365                 /* file (slice or full disk) */
6366                 vattr.va_mask = AT_SIZE;
6367                 rv = VOP_GETATTR(vd->file_vnode, &vattr, 0, kcred, NULL);
6368                 if (rv != 0) {
6369                         PR0("VOP_GETATTR(%s) = errno %d", vd->device_path, rv);
6370                         return (rv);
6371                 }
6372                 backend_size = vattr.va_size;
6373                 backend_bsize = DEV_BSIZE;
6374                 vdisk_bsize = DEV_BSIZE;
6375 
6376         } else if (vd->volume) {
6377 
6378                 /* volume (slice or full disk) */
6379                 rv = ldi_get_size(vd->ldi_handle[0], &backend_size);
6380                 if (rv != DDI_SUCCESS) {
6381                         PR0("ldi_get_size() failed for %s", vd->device_path);
6382                         return (EIO);
6383                 }
6384                 backend_bsize = DEV_BSIZE;
6385                 vdisk_bsize = DEV_BSIZE;
6386 
6387         } else {
6388 
6389                 /* physical disk or slice */
6390                 rv = ldi_ioctl(vd->ldi_handle[0], DKIOCGMEDIAINFO,
6391                     (intptr_t)&minfo, (vd->open_flags | FKIOCTL),
6392                     kcred, &rval);
6393                 if (rv != 0) {
6394                         PR0("DKIOCGMEDIAINFO failed for %s (err=%d)",
6395                             vd->device_path, rv);
6396                         return (rv);
6397                 }
6398 
6399                 if (vd->vdisk_type == VD_DISK_TYPE_SLICE) {
6400                         rv = ldi_get_size(vd->ldi_handle[0], &backend_size);
6401                         if (rv != DDI_SUCCESS) {
6402                                 PR0("ldi_get_size() failed for %s",
6403                                     vd->device_path);
6404                                 return (EIO);
6405                         }
6406                 } else {
6407                         ASSERT(vd->vdisk_type == VD_DISK_TYPE_DISK);
6408                         backend_size = minfo.dki_capacity * minfo.dki_lbsize;
6409                 }
6410 
6411                 backend_bsize = minfo.dki_lbsize;
6412                 media = DK_MEDIATYPE2VD_MEDIATYPE(minfo.dki_media_type);
6413 
6414                 /*
6415                  * If the device is a CD or a DVD then we force the vdisk block
6416                  * size to 512 bytes (DEV_BSIZE). In that case, vdisk_bsize can
6417                  * be different from backend_size.
6418                  */
6419                 if (media == VD_MEDIA_CD || media == VD_MEDIA_DVD)
6420                         vdisk_bsize = DEV_BSIZE;
6421                 else
6422                         vdisk_bsize = backend_bsize;
6423         }
6424 
6425         /* check vdisk block size */
6426         if (vdisk_bsize == 0 || vdisk_bsize % DEV_BSIZE != 0)
6427                 return (EINVAL);
6428 
6429         old_size = vd->vdisk_size;
6430         new_size = backend_size / vdisk_bsize;
6431 
6432         /* check if size has changed */
6433         if (old_size != VD_SIZE_UNKNOWN && old_size == new_size &&
6434             vd->vdisk_bsize == vdisk_bsize)
6435                 return (0);
6436 
6437         /* cache info for blk conversion */
6438         for (n = vdisk_bsize / DEV_BSIZE; n > 1; n >>= 1) {
6439                 if ((n & 0x1) != 0) {
6440                         /* blk_size is not a power of 2 */
6441                         return (EINVAL);
6442                 }
6443                 nshift++;
6444         }
6445 
6446         vd->vio_bshift = nshift;
6447         vd->vdisk_size = new_size;
6448         vd->vdisk_bsize = vdisk_bsize;
6449         vd->backend_bsize = backend_bsize;
6450 
6451         if (vd->file || vd->volume)
6452                 vd->dskimg_size = backend_size;
6453 
6454         /*
6455          * If we are exporting a single-slice disk and the size of the backend
6456          * has changed then we regenerate the partition setup so that the
6457          * partitioning matches with the new disk backend size.
6458          */
6459 
6460         if (vd->vdisk_type == VD_DISK_TYPE_SLICE) {
6461                 /* slice or file or device exported as a slice */
6462                 if (vd->vdisk_label == VD_DISK_LABEL_VTOC) {
6463                         rv = vd_setup_partition_vtoc(vd);
6464                         if (rv != 0) {
6465                                 PR0("vd_setup_partition_vtoc() failed for %s "
6466                                     "(err = %d)", vd->device_path, rv);
6467                                 return (rv);
6468                         }
6469                 } else {
6470                         rv = vd_setup_partition_efi(vd);
6471                         if (rv != 0) {
6472                                 PR0("vd_setup_partition_efi() failed for %s "
6473                                     "(err = %d)", vd->device_path, rv);
6474                                 return (rv);
6475                         }
6476                 }
6477 
6478         } else if (!vd->file && !vd->volume) {
6479                 /* physical disk */
6480                 ASSERT(vd->vdisk_type == VD_DISK_TYPE_DISK);
6481                 vd->vdisk_media = media;
6482         }
6483 
6484         return (0);
6485 }
6486 
6487 /*
6488  * Description:
6489  *      Open a device using its device path and identify if this is
6490  *      a disk device or a volume device.
6491  *
6492  * Parameters:
6493  *      vd      - pointer to structure containing the vDisk info
6494  *      dtype   - return the driver type of the device
6495  *
6496  * Return Value
6497  *      0       - success
6498  *      != 0    - some other non-zero return value from ldi(9F) functions
6499  */
6500 static int
6501 vd_identify_dev(vd_t *vd, int *dtype)
6502 {
6503         int status, i;
6504         char *device_path = vd->device_path;
6505         char *drv_name;
6506         int drv_type;
6507         vds_t *vds = vd->vds;
6508 
6509         status = vd_open_using_ldi_by_name(vd, vd->open_flags & ~FWRITE);
6510         if (status != 0) {
6511                 PR0("Failed to open (%s) = errno %d", device_path, status);
6512                 return (status);
6513         }
6514 
6515         /* Get device number of backing device */
6516         if ((status = ldi_get_dev(vd->ldi_handle[0], &vd->dev[0])) != 0) {
6517                 PRN("ldi_get_dev() returned errno %d for %s",
6518                     status, device_path);
6519                 return (status);
6520         }
6521 
6522         /*
6523          * We start by looking if the driver is in the list from vds.conf
6524          * so that we can override the built-in list using vds.conf.
6525          */
6526         drv_name = ddi_major_to_name(getmajor(vd->dev[0]));
6527         drv_type = VD_DRIVER_UNKNOWN;
6528 
6529         /* check vds.conf list */
6530         for (i = 0; i < vds->num_drivers; i++) {
6531                 if (vds->driver_types[i].type == VD_DRIVER_UNKNOWN) {
6532                         /* ignore invalid entries */
6533                         continue;
6534                 }
6535                 if (strcmp(drv_name, vds->driver_types[i].name) == 0) {
6536                         drv_type = vds->driver_types[i].type;
6537                         goto done;
6538                 }
6539         }
6540 
6541         /* check built-in list */
6542         for (i = 0; i < VDS_NUM_DRIVERS; i++) {
6543                 if (strcmp(drv_name, vds_driver_types[i].name) == 0) {
6544                         drv_type = vds_driver_types[i].type;
6545                         goto done;
6546                 }
6547         }
6548 
6549 done:
6550         PR0("driver %s identified as %s", drv_name,
6551             (drv_type == VD_DRIVER_DISK)? "DISK" :
6552             (drv_type == VD_DRIVER_VOLUME)? "VOLUME" : "UNKNOWN");
6553 
6554         if (strcmp(drv_name, "zfs") == 0)
6555                 vd->zvol = B_TRUE;
6556 
6557         *dtype = drv_type;
6558 
6559         return (0);
6560 }
6561 
6562 static int
6563 vd_setup_vd(vd_t *vd)
6564 {
6565         int             status, drv_type, pseudo;
6566         dev_info_t      *dip;
6567         vnode_t         *vnp;
6568         char            *path = vd->device_path;
6569         char            tq_name[TASKQ_NAMELEN];
6570 
6571         /* make sure the vdisk backend is valid */
6572         if ((status = lookupname(path, UIO_SYSSPACE,
6573             FOLLOW, NULLVPP, &vnp)) != 0) {
6574                 PR0("Cannot lookup %s errno %d", path, status);
6575                 goto done;
6576         }
6577 
6578         switch (vnp->v_type) {
6579         case VREG:
6580                 /*
6581                  * Backend is a file so it is exported as a full disk or as a
6582                  * single slice disk using the vnode interface.
6583                  */
6584                 VN_RELE(vnp);
6585                 vd->volume = B_FALSE;
6586                 status = vd_setup_backend_vnode(vd);
6587                 break;
6588 
6589         case VBLK:
6590         case VCHR:
6591                 /*
6592                  * Backend is a device. In that case, it is exported using the
6593                  * LDI interface, and it is exported either as a single-slice
6594                  * disk or as a full disk depending on the "slice" option and
6595                  * on the type of device.
6596                  *
6597                  * - A volume device is exported as a single-slice disk if the
6598                  *   "slice" is specified, otherwise it is exported as a full
6599                  *   disk.
6600                  *
6601                  * - A disk slice (different from slice 2) is always exported
6602                  *   as a single slice disk using the LDI interface.
6603                  *
6604                  * - The slice 2 of a disk is exported as a single slice disk
6605                  *   if the "slice" option is specified, otherwise the entire
6606                  *   disk will be exported.
6607                  *
6608                  * - The slice of a CD or DVD is exported as single slice disk
6609                  *   if the "slice" option is specified, otherwise the entire
6610                  *   disk will be exported.
6611                  */
6612 
6613                 /* check if this is a pseudo device */
6614                 if ((dip = ddi_hold_devi_by_instance(getmajor(vnp->v_rdev),
6615                     dev_to_instance(vnp->v_rdev), 0))  == NULL) {
6616                         PRN("%s is no longer accessible", path);
6617                         VN_RELE(vnp);
6618                         status = EIO;
6619                         break;
6620                 }
6621                 pseudo = is_pseudo_device(dip);
6622                 ddi_release_devi(dip);
6623                 VN_RELE(vnp);
6624 
6625                 if ((status = vd_identify_dev(vd, &drv_type)) != 0) {
6626                         if (status != ENODEV && status != ENXIO &&
6627                             status != ENOENT && status != EROFS) {
6628                                 PRN("%s identification failed with status %d",
6629                                     path, status);
6630                                 status = EIO;
6631                         }
6632                         break;
6633                 }
6634 
6635                 /*
6636                  * If the driver hasn't been identified then we consider that
6637                  * pseudo devices are volumes and other devices are disks.
6638                  */
6639                 if (drv_type == VD_DRIVER_VOLUME ||
6640                     (drv_type == VD_DRIVER_UNKNOWN && pseudo)) {
6641                         vd->volume = B_TRUE;
6642                 }
6643 
6644                 /*
6645                  * If this is a volume device then its usage depends if the
6646                  * "slice" option is set or not. If the "slice" option is set
6647                  * then the volume device will be exported as a single slice,
6648                  * otherwise it will be exported as a full disk.
6649                  *
6650                  * For backward compatibility, if vd_volume_force_slice is set
6651                  * then we always export volume devices as slices.
6652                  */
6653                 if (vd->volume && vd_volume_force_slice) {
6654                         vd->vdisk_type = VD_DISK_TYPE_SLICE;
6655                         vd->nslices = 1;
6656                 }
6657 
6658                 status = vd_setup_backend_ldi(vd);
6659                 break;
6660 
6661         default:
6662                 PRN("Unsupported vdisk backend %s", path);
6663                 VN_RELE(vnp);
6664                 status = EBADF;
6665         }
6666 
6667 done:
6668         if (status != 0) {
6669                 /*
6670                  * If the error is retryable print an error message only
6671                  * during the first try.
6672                  */
6673                 if (status == ENXIO || status == ENODEV ||
6674                     status == ENOENT || status == EROFS) {
6675                         if (!(vd->initialized & VD_SETUP_ERROR) &&
6676                             !(DEVI_IS_ATTACHING(vd->vds->dip))) {
6677                                 PRN("%s is currently inaccessible (error %d)",
6678                                     path, status);
6679                         }
6680                         status = EAGAIN;
6681                 } else {
6682                         PRN("%s can not be exported as a virtual disk "
6683                             "(error %d)", path, status);
6684                 }
6685                 vd->initialized |= VD_SETUP_ERROR;
6686 
6687         } else if (vd->initialized & VD_SETUP_ERROR) {
6688                 /* print a message only if we previously had an error */
6689                 PRN("%s is now online", path);
6690                 vd->initialized &= ~VD_SETUP_ERROR;
6691         }
6692 
6693         /*
6694          * For file or ZFS volume we also need an I/O queue.
6695          *
6696          * The I/O task queue is initialized here and not in vds_do_init_vd()
6697          * (as the start and completion queues) because vd_setup_vd() will be
6698          * call again if the backend is not available, and we need to know if
6699          * the backend is a ZFS volume or a file.
6700          */
6701         if ((vd->file || vd->zvol) && vd->ioq == NULL) {
6702                 (void) snprintf(tq_name, sizeof (tq_name), "vd_ioq%lu", vd->id);
6703 
6704                 if ((vd->ioq = ddi_taskq_create(vd->vds->dip, tq_name,
6705                     vd_ioq_nthreads, TASKQ_DEFAULTPRI, 0)) == NULL) {
6706                         PRN("Could not create io task queue");
6707                         return (EIO);
6708                 }
6709         }
6710 
6711         return (status);
6712 }
6713 
6714 static int
6715 vds_do_init_vd(vds_t *vds, uint64_t id, char *device_path, uint64_t options,
6716     uint64_t ldc_id, vd_t **vdp)
6717 {
6718         char                    tq_name[TASKQ_NAMELEN];
6719         int                     status;
6720         ddi_iblock_cookie_t     iblock = NULL;
6721         ldc_attr_t              ldc_attr;
6722         vd_t                    *vd;
6723 
6724 
6725         ASSERT(vds != NULL);
6726         ASSERT(device_path != NULL);
6727         ASSERT(vdp != NULL);
6728         PR0("Adding vdisk for %s", device_path);
6729 
6730         if ((vd = kmem_zalloc(sizeof (*vd), KM_NOSLEEP)) == NULL) {
6731                 PRN("No memory for virtual disk");
6732                 return (EAGAIN);
6733         }
6734         *vdp = vd;      /* assign here so vds_destroy_vd() can cleanup later */
6735         vd->id = id;
6736         vd->vds = vds;
6737         (void) strncpy(vd->device_path, device_path, MAXPATHLEN);
6738 
6739         /* Setup open flags */
6740         vd->open_flags = FREAD;
6741 
6742         if (!(options & VD_OPT_RDONLY))
6743                 vd->open_flags |= FWRITE;
6744 
6745         if (options & VD_OPT_EXCLUSIVE)
6746                 vd->open_flags |= FEXCL;
6747 
6748         /* Setup disk type */
6749         if (options & VD_OPT_SLICE) {
6750                 vd->vdisk_type = VD_DISK_TYPE_SLICE;
6751                 vd->nslices = 1;
6752         } else {
6753                 vd->vdisk_type = VD_DISK_TYPE_DISK;
6754                 vd->nslices = V_NUMPAR;
6755         }
6756 
6757         /* default disk label */
6758         vd->vdisk_label = VD_DISK_LABEL_UNK;
6759 
6760         /* Open vdisk and initialize parameters */
6761         if ((status = vd_setup_vd(vd)) == 0) {
6762                 vd->initialized |= VD_DISK_READY;
6763 
6764                 ASSERT(vd->nslices > 0 && vd->nslices <= V_NUMPAR);
6765                 PR0("vdisk_type = %s, volume = %s, file = %s, nslices = %u",
6766                     ((vd->vdisk_type == VD_DISK_TYPE_DISK) ? "disk" : "slice"),
6767                     (vd->volume ? "yes" : "no"), (vd->file ? "yes" : "no"),
6768                     vd->nslices);
6769         } else {
6770                 if (status != EAGAIN)
6771                         return (status);
6772         }
6773 
6774         /* Initialize locking */
6775         if (ddi_get_soft_iblock_cookie(vds->dip, DDI_SOFTINT_MED,
6776             &iblock) != DDI_SUCCESS) {
6777                 PRN("Could not get iblock cookie.");
6778                 return (EIO);
6779         }
6780 
6781         mutex_init(&vd->lock, NULL, MUTEX_DRIVER, iblock);
6782         vd->initialized |= VD_LOCKING;
6783 
6784 
6785         /* Create start and completion task queues for the vdisk */
6786         (void) snprintf(tq_name, sizeof (tq_name), "vd_startq%lu", id);
6787         PR1("tq_name = %s", tq_name);
6788         if ((vd->startq = ddi_taskq_create(vds->dip, tq_name, 1,
6789             TASKQ_DEFAULTPRI, 0)) == NULL) {
6790                 PRN("Could not create task queue");
6791                 return (EIO);
6792         }
6793         (void) snprintf(tq_name, sizeof (tq_name), "vd_completionq%lu", id);
6794         PR1("tq_name = %s", tq_name);
6795         if ((vd->completionq = ddi_taskq_create(vds->dip, tq_name, 1,
6796             TASKQ_DEFAULTPRI, 0)) == NULL) {
6797                 PRN("Could not create task queue");
6798                 return (EIO);
6799         }
6800 
6801         /* Allocate the staging buffer */
6802         vd->max_msglen = sizeof (vio_msg_t); /* baseline vio message size */
6803         vd->vio_msgp = kmem_alloc(vd->max_msglen, KM_SLEEP);
6804 
6805         vd->enabled = 1;     /* before callback can dispatch to startq */
6806 
6807 
6808         /* Bring up LDC */
6809         ldc_attr.devclass       = LDC_DEV_BLK_SVC;
6810         ldc_attr.instance       = ddi_get_instance(vds->dip);
6811         ldc_attr.mode           = LDC_MODE_UNRELIABLE;
6812         ldc_attr.mtu            = VD_LDC_MTU;
6813         if ((status = ldc_init(ldc_id, &ldc_attr, &vd->ldc_handle)) != 0) {
6814                 PRN("Could not initialize LDC channel %lx, "
6815                     "init failed with error %d", ldc_id, status);
6816                 return (status);
6817         }
6818         vd->initialized |= VD_LDC;
6819 
6820         if ((status = ldc_reg_callback(vd->ldc_handle, vd_handle_ldc_events,
6821             (caddr_t)vd)) != 0) {
6822                 PRN("Could not initialize LDC channel %lu,"
6823                     "reg_callback failed with error %d", ldc_id, status);
6824                 return (status);
6825         }
6826 
6827         if ((status = ldc_open(vd->ldc_handle)) != 0) {
6828                 PRN("Could not initialize LDC channel %lu,"
6829                     "open failed with error %d", ldc_id, status);
6830                 return (status);
6831         }
6832 
6833         if ((status = ldc_up(vd->ldc_handle)) != 0) {
6834                 PR0("ldc_up() returned errno %d", status);
6835         }
6836 
6837         /* Allocate the inband task memory handle */
6838         status = ldc_mem_alloc_handle(vd->ldc_handle, &(vd->inband_task.mhdl));
6839         if (status) {
6840                 PRN("Could not initialize LDC channel %lu,"
6841                     "alloc_handle failed with error %d", ldc_id, status);
6842                 return (ENXIO);
6843         }
6844 
6845         /* Add the successfully-initialized vdisk to the server's table */
6846         if (mod_hash_insert(vds->vd_table, (mod_hash_key_t)id, vd) != 0) {
6847                 PRN("Error adding vdisk ID %lu to table", id);
6848                 return (EIO);
6849         }
6850 
6851         /* store initial state */
6852         vd->state = VD_STATE_INIT;
6853 
6854         return (0);
6855 }
6856 
6857 static void
6858 vd_free_dring_task(vd_t *vdp)
6859 {
6860         if (vdp->dring_task != NULL) {
6861                 ASSERT(vdp->dring_len != 0);
6862                 /* Free all dring_task memory handles */
6863                 for (int i = 0; i < vdp->dring_len; i++) {
6864                         (void) ldc_mem_free_handle(vdp->dring_task[i].mhdl);
6865                         kmem_free(vdp->dring_task[i].request,
6866                             (vdp->descriptor_size -
6867                             sizeof (vio_dring_entry_hdr_t)));
6868                         vdp->dring_task[i].request = NULL;
6869                         kmem_free(vdp->dring_task[i].msg, vdp->max_msglen);
6870                         vdp->dring_task[i].msg = NULL;
6871                 }
6872                 kmem_free(vdp->dring_task,
6873                     (sizeof (*vdp->dring_task)) * vdp->dring_len);
6874                 vdp->dring_task = NULL;
6875         }
6876 
6877         if (vdp->write_queue != NULL) {
6878                 kmem_free(vdp->write_queue, sizeof (buf_t *) * vdp->dring_len);
6879                 vdp->write_queue = NULL;
6880         }
6881 }
6882 
6883 /*
6884  * Destroy the state associated with a virtual disk
6885  */
6886 static void
6887 vds_destroy_vd(void *arg)
6888 {
6889         vd_t    *vd = (vd_t *)arg;
6890         int     retry = 0, rv;
6891 
6892         if (vd == NULL)
6893                 return;
6894 
6895         PR0("Destroying vdisk state");
6896 
6897         /* Disable queuing requests for the vdisk */
6898         if (vd->initialized & VD_LOCKING) {
6899                 mutex_enter(&vd->lock);
6900                 vd->enabled = 0;
6901                 mutex_exit(&vd->lock);
6902         }
6903 
6904         /* Drain and destroy start queue (*before* destroying ioq) */
6905         if (vd->startq != NULL)
6906                 ddi_taskq_destroy(vd->startq);       /* waits for queued tasks */
6907 
6908         /* Drain and destroy the I/O queue (*before* destroying completionq) */
6909         if (vd->ioq != NULL)
6910                 ddi_taskq_destroy(vd->ioq);
6911 
6912         /* Drain and destroy completion queue (*before* shutting down LDC) */
6913         if (vd->completionq != NULL)
6914                 ddi_taskq_destroy(vd->completionq);  /* waits for tasks */
6915 
6916         vd_free_dring_task(vd);
6917 
6918         /* Free the inband task memory handle */
6919         (void) ldc_mem_free_handle(vd->inband_task.mhdl);
6920 
6921         /* Shut down LDC */
6922         if (vd->initialized & VD_LDC) {
6923                 /* unmap the dring */
6924                 if (vd->initialized & VD_DRING)
6925                         (void) ldc_mem_dring_unmap(vd->dring_handle);
6926 
6927                 /* close LDC channel - retry on EAGAIN */
6928                 while ((rv = ldc_close(vd->ldc_handle)) == EAGAIN) {
6929                         if (++retry > vds_ldc_retries) {
6930                                 PR0("Timed out closing channel");
6931                                 break;
6932                         }
6933                         drv_usecwait(vds_ldc_delay);
6934                 }
6935                 if (rv == 0) {
6936                         (void) ldc_unreg_callback(vd->ldc_handle);
6937                         (void) ldc_fini(vd->ldc_handle);
6938                 } else {
6939                         /*
6940                          * Closing the LDC channel has failed. Ideally we should
6941                          * fail here but there is no Zeus level infrastructure
6942                          * to handle this. The MD has already been changed and
6943                          * we have to do the close. So we try to do as much
6944                          * clean up as we can.
6945                          */
6946                         (void) ldc_set_cb_mode(vd->ldc_handle, LDC_CB_DISABLE);
6947                         while (ldc_unreg_callback(vd->ldc_handle) == EAGAIN)
6948                                 drv_usecwait(vds_ldc_delay);
6949                 }
6950         }
6951 
6952         /* Free the staging buffer for msgs */
6953         if (vd->vio_msgp != NULL) {
6954                 kmem_free(vd->vio_msgp, vd->max_msglen);
6955                 vd->vio_msgp = NULL;
6956         }
6957 
6958         /* Free the inband message buffer */
6959         if (vd->inband_task.msg != NULL) {
6960                 kmem_free(vd->inband_task.msg, vd->max_msglen);
6961                 vd->inband_task.msg = NULL;
6962         }
6963 
6964         if (vd->file) {
6965                 /* Close file */
6966                 (void) VOP_CLOSE(vd->file_vnode, vd->open_flags, 1,
6967                     0, kcred, NULL);
6968                 VN_RELE(vd->file_vnode);
6969         } else {
6970                 /* Close any open backing-device slices */
6971                 for (uint_t slice = 0; slice < V_NUMPAR; slice++) {
6972                         if (vd->ldi_handle[slice] != NULL) {
6973                                 PR0("Closing slice %u", slice);
6974                                 (void) ldi_close(vd->ldi_handle[slice],
6975                                     vd->open_flags, kcred);
6976                         }
6977                 }
6978         }
6979 
6980         /* Free disk image devid */
6981         if (vd->dskimg_devid != NULL)
6982                 ddi_devid_free(vd->dskimg_devid);
6983 
6984         /* Free any fake label */
6985         if (vd->flabel) {
6986                 kmem_free(vd->flabel, vd->flabel_size);
6987                 vd->flabel = NULL;
6988                 vd->flabel_size = 0;
6989         }
6990 
6991         /* Free lock */
6992         if (vd->initialized & VD_LOCKING)
6993                 mutex_destroy(&vd->lock);
6994 
6995         /* Finally, free the vdisk structure itself */
6996         kmem_free(vd, sizeof (*vd));
6997 }
6998 
6999 static int
7000 vds_init_vd(vds_t *vds, uint64_t id, char *device_path, uint64_t options,
7001     uint64_t ldc_id)
7002 {
7003         int     status;
7004         vd_t    *vd = NULL;
7005 
7006 
7007         if ((status = vds_do_init_vd(vds, id, device_path, options,
7008             ldc_id, &vd)) != 0)
7009                 vds_destroy_vd(vd);
7010 
7011         return (status);
7012 }
7013 
7014 static int
7015 vds_do_get_ldc_id(md_t *md, mde_cookie_t vd_node, mde_cookie_t *channel,
7016     uint64_t *ldc_id)
7017 {
7018         int     num_channels;
7019 
7020 
7021         /* Look for channel endpoint child(ren) of the vdisk MD node */
7022         if ((num_channels = md_scan_dag(md, vd_node,
7023             md_find_name(md, VD_CHANNEL_ENDPOINT),
7024             md_find_name(md, "fwd"), channel)) <= 0) {
7025                 PRN("No \"%s\" found for virtual disk", VD_CHANNEL_ENDPOINT);
7026                 return (-1);
7027         }
7028 
7029         /* Get the "id" value for the first channel endpoint node */
7030         if (md_get_prop_val(md, channel[0], VD_ID_PROP, ldc_id) != 0) {
7031                 PRN("No \"%s\" property found for \"%s\" of vdisk",
7032                     VD_ID_PROP, VD_CHANNEL_ENDPOINT);
7033                 return (-1);
7034         }
7035 
7036         if (num_channels > 1) {
7037                 PRN("Using ID of first of multiple channels for this vdisk");
7038         }
7039 
7040         return (0);
7041 }
7042 
7043 static int
7044 vds_get_ldc_id(md_t *md, mde_cookie_t vd_node, uint64_t *ldc_id)
7045 {
7046         int             num_nodes, status;
7047         size_t          size;
7048         mde_cookie_t    *channel;
7049 
7050 
7051         if ((num_nodes = md_node_count(md)) <= 0) {
7052                 PRN("Invalid node count in Machine Description subtree");
7053                 return (-1);
7054         }
7055         size = num_nodes*(sizeof (*channel));
7056         channel = kmem_zalloc(size, KM_SLEEP);
7057         status = vds_do_get_ldc_id(md, vd_node, channel, ldc_id);
7058         kmem_free(channel, size);
7059 
7060         return (status);
7061 }
7062 
7063 /*
7064  * Function:
7065  *      vds_get_options
7066  *
7067  * Description:
7068  *      Parse the options of a vds node. Options are defined as an array
7069  *      of strings in the vds-block-device-opts property of the vds node
7070  *      in the machine description. Options are returned as a bitmask. The
7071  *      mapping between the bitmask options and the options strings from the
7072  *      machine description is defined in the vd_bdev_options[] array.
7073  *
7074  *      The vds-block-device-opts property is optional. If a vds has no such
7075  *      property then no option is defined.
7076  *
7077  * Parameters:
7078  *      md              - machine description.
7079  *      vd_node         - vds node in the machine description for which
7080  *                        options have to be parsed.
7081  *      options         - the returned options.
7082  *
7083  * Return Code:
7084  *      none.
7085  */
7086 static void
7087 vds_get_options(md_t *md, mde_cookie_t vd_node, uint64_t *options)
7088 {
7089         char    *optstr, *opt;
7090         int     len, n, i;
7091 
7092         *options = 0;
7093 
7094         if (md_get_prop_data(md, vd_node, VD_BLOCK_DEVICE_OPTS,
7095             (uint8_t **)&optstr, &len) != 0) {
7096                 PR0("No options found");
7097                 return;
7098         }
7099 
7100         /* parse options */
7101         opt = optstr;
7102         n = sizeof (vd_bdev_options) / sizeof (vd_option_t);
7103 
7104         while (opt < optstr + len) {
7105                 for (i = 0; i < n; i++) {
7106                         if (strncmp(vd_bdev_options[i].vdo_name,
7107                             opt, VD_OPTION_NLEN) == 0) {
7108                                 *options |= vd_bdev_options[i].vdo_value;
7109                                 break;
7110                         }
7111                 }
7112 
7113                 if (i < n) {
7114                         PR0("option: %s", opt);
7115                 } else {
7116                         PRN("option %s is unknown or unsupported", opt);
7117                 }
7118 
7119                 opt += strlen(opt) + 1;
7120         }
7121 }
7122 
7123 static void
7124 vds_driver_types_free(vds_t *vds)
7125 {
7126         if (vds->driver_types != NULL) {
7127                 kmem_free(vds->driver_types, sizeof (vd_driver_type_t) *
7128                     vds->num_drivers);
7129                 vds->driver_types = NULL;
7130                 vds->num_drivers = 0;
7131         }
7132 }
7133 
7134 /*
7135  * Update the driver type list with information from vds.conf.
7136  */
7137 static void
7138 vds_driver_types_update(vds_t *vds)
7139 {
7140         char **list, *s;
7141         uint_t i, num, count = 0, len;
7142 
7143         if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, vds->dip,
7144             DDI_PROP_DONTPASS, "driver-type-list", &list, &num) !=
7145             DDI_PROP_SUCCESS)
7146                 return;
7147 
7148         /*
7149          * We create a driver_types list with as many as entries as there
7150          * is in the driver-type-list from vds.conf. However only valid
7151          * entries will be populated (i.e. entries from driver-type-list
7152          * with a valid syntax). Invalid entries will be left blank so
7153          * they will have no driver name and the driver type will be
7154          * VD_DRIVER_UNKNOWN (= 0).
7155          */
7156         vds->num_drivers = num;
7157         vds->driver_types = kmem_zalloc(sizeof (vd_driver_type_t) * num,
7158             KM_SLEEP);
7159 
7160         for (i = 0; i < num; i++) {
7161 
7162                 s = strchr(list[i], ':');
7163 
7164                 if (s == NULL) {
7165                         PRN("vds.conf: driver-type-list, entry %d (%s): "
7166                             "a colon is expected in the entry",
7167                             i, list[i]);
7168                         continue;
7169                 }
7170 
7171                 len = (uintptr_t)s - (uintptr_t)list[i];
7172 
7173                 if (len == 0) {
7174                         PRN("vds.conf: driver-type-list, entry %d (%s): "
7175                             "the driver name is empty",
7176                             i, list[i]);
7177                         continue;
7178                 }
7179 
7180                 if (len >= VD_DRIVER_NAME_LEN) {
7181                         PRN("vds.conf: driver-type-list, entry %d (%s): "
7182                             "the driver name is too long",
7183                             i, list[i]);
7184                         continue;
7185                 }
7186 
7187                 if (strcmp(s + 1, "disk") == 0) {
7188 
7189                         vds->driver_types[i].type = VD_DRIVER_DISK;
7190 
7191                 } else if (strcmp(s + 1, "volume") == 0) {
7192 
7193                         vds->driver_types[i].type = VD_DRIVER_VOLUME;
7194 
7195                 } else {
7196                         PRN("vds.conf: driver-type-list, entry %d (%s): "
7197                             "the driver type is invalid",
7198                             i, list[i]);
7199                         continue;
7200                 }
7201 
7202                 (void) strncpy(vds->driver_types[i].name, list[i], len);
7203 
7204                 PR0("driver-type-list, entry %d (%s) added",
7205                     i, list[i]);
7206 
7207                 count++;
7208         }
7209 
7210         ddi_prop_free(list);
7211 
7212         if (count == 0) {
7213                 /* nothing was added, clean up */
7214                 vds_driver_types_free(vds);
7215         }
7216 }
7217 
7218 static void
7219 vds_add_vd(vds_t *vds, md_t *md, mde_cookie_t vd_node)
7220 {
7221         char            *device_path = NULL;
7222         uint64_t        id = 0, ldc_id = 0, options = 0;
7223 
7224         if (md_get_prop_val(md, vd_node, VD_ID_PROP, &id) != 0) {
7225                 PRN("Error getting vdisk \"%s\"", VD_ID_PROP);
7226                 return;
7227         }
7228         PR0("Adding vdisk ID %lu", id);
7229         if (md_get_prop_str(md, vd_node, VD_BLOCK_DEVICE_PROP,
7230             &device_path) != 0) {
7231                 PRN("Error getting vdisk \"%s\"", VD_BLOCK_DEVICE_PROP);
7232                 return;
7233         }
7234 
7235         vds_get_options(md, vd_node, &options);
7236 
7237         if (vds_get_ldc_id(md, vd_node, &ldc_id) != 0) {
7238                 PRN("Error getting LDC ID for vdisk %lu", id);
7239                 return;
7240         }
7241 
7242         if (vds_init_vd(vds, id, device_path, options, ldc_id) != 0) {
7243                 PRN("Failed to add vdisk ID %lu", id);
7244                 if (mod_hash_destroy(vds->vd_table, (mod_hash_key_t)id) != 0)
7245                         PRN("No vDisk entry found for vdisk ID %lu", id);
7246                 return;
7247         }
7248 }
7249 
7250 static void
7251 vds_remove_vd(vds_t *vds, md_t *md, mde_cookie_t vd_node)
7252 {
7253         uint64_t        id = 0;
7254 
7255 
7256         if (md_get_prop_val(md, vd_node, VD_ID_PROP, &id) != 0) {
7257                 PRN("Unable to get \"%s\" property from vdisk's MD node",
7258                     VD_ID_PROP);
7259                 return;
7260         }
7261         PR0("Removing vdisk ID %lu", id);
7262         if (mod_hash_destroy(vds->vd_table, (mod_hash_key_t)id) != 0)
7263                 PRN("No vdisk entry found for vdisk ID %lu", id);
7264 }
7265 
7266 static void
7267 vds_change_vd(vds_t *vds, md_t *prev_md, mde_cookie_t prev_vd_node,
7268     md_t *curr_md, mde_cookie_t curr_vd_node)
7269 {
7270         char            *curr_dev, *prev_dev;
7271         uint64_t        curr_id = 0, curr_ldc_id = 0, curr_options = 0;
7272         uint64_t        prev_id = 0, prev_ldc_id = 0, prev_options = 0;
7273         size_t          len;
7274 
7275 
7276         /* Validate that vdisk ID has not changed */
7277         if (md_get_prop_val(prev_md, prev_vd_node, VD_ID_PROP, &prev_id) != 0) {
7278                 PRN("Error getting previous vdisk \"%s\" property",
7279                     VD_ID_PROP);
7280                 return;
7281         }
7282         if (md_get_prop_val(curr_md, curr_vd_node, VD_ID_PROP, &curr_id) != 0) {
7283                 PRN("Error getting current vdisk \"%s\" property", VD_ID_PROP);
7284                 return;
7285         }
7286         if (curr_id != prev_id) {
7287                 PRN("Not changing vdisk:  ID changed from %lu to %lu",
7288                     prev_id, curr_id);
7289                 return;
7290         }
7291 
7292         /* Validate that LDC ID has not changed */
7293         if (vds_get_ldc_id(prev_md, prev_vd_node, &prev_ldc_id) != 0) {
7294                 PRN("Error getting LDC ID for vdisk %lu", prev_id);
7295                 return;
7296         }
7297 
7298         if (vds_get_ldc_id(curr_md, curr_vd_node, &curr_ldc_id) != 0) {
7299                 PRN("Error getting LDC ID for vdisk %lu", curr_id);
7300                 return;
7301         }
7302         if (curr_ldc_id != prev_ldc_id) {
7303                 _NOTE(NOTREACHED);      /* lint is confused */
7304                 PRN("Not changing vdisk:  "
7305                     "LDC ID changed from %lu to %lu", prev_ldc_id, curr_ldc_id);
7306                 return;
7307         }
7308 
7309         /* Determine whether device path has changed */
7310         if (md_get_prop_str(prev_md, prev_vd_node, VD_BLOCK_DEVICE_PROP,
7311             &prev_dev) != 0) {
7312                 PRN("Error getting previous vdisk \"%s\"",
7313                     VD_BLOCK_DEVICE_PROP);
7314                 return;
7315         }
7316         if (md_get_prop_str(curr_md, curr_vd_node, VD_BLOCK_DEVICE_PROP,
7317             &curr_dev) != 0) {
7318                 PRN("Error getting current vdisk \"%s\"", VD_BLOCK_DEVICE_PROP);
7319                 return;
7320         }
7321         if (((len = strlen(curr_dev)) == strlen(prev_dev)) &&
7322             (strncmp(curr_dev, prev_dev, len) == 0))
7323                 return; /* no relevant (supported) change */
7324 
7325         /* Validate that options have not changed */
7326         vds_get_options(prev_md, prev_vd_node, &prev_options);
7327         vds_get_options(curr_md, curr_vd_node, &curr_options);
7328         if (prev_options != curr_options) {
7329                 PRN("Not changing vdisk:  options changed from %lx to %lx",
7330                     prev_options, curr_options);
7331                 return;
7332         }
7333 
7334         PR0("Changing vdisk ID %lu", prev_id);
7335 
7336         /* Remove old state, which will close vdisk and reset */
7337         if (mod_hash_destroy(vds->vd_table, (mod_hash_key_t)prev_id) != 0)
7338                 PRN("No entry found for vdisk ID %lu", prev_id);
7339 
7340         /* Re-initialize vdisk with new state */
7341         if (vds_init_vd(vds, curr_id, curr_dev, curr_options,
7342             curr_ldc_id) != 0) {
7343                 PRN("Failed to change vdisk ID %lu", curr_id);
7344                 return;
7345         }
7346 }
7347 
7348 static int
7349 vds_process_md(void *arg, mdeg_result_t *md)
7350 {
7351         int     i;
7352         vds_t   *vds = arg;
7353 
7354 
7355         if (md == NULL)
7356                 return (MDEG_FAILURE);
7357         ASSERT(vds != NULL);
7358 
7359         for (i = 0; i < md->removed.nelem; i++)
7360                 vds_remove_vd(vds, md->removed.mdp, md->removed.mdep[i]);
7361         for (i = 0; i < md->match_curr.nelem; i++)
7362                 vds_change_vd(vds, md->match_prev.mdp, md->match_prev.mdep[i],
7363                     md->match_curr.mdp, md->match_curr.mdep[i]);
7364         for (i = 0; i < md->added.nelem; i++)
7365                 vds_add_vd(vds, md->added.mdp, md->added.mdep[i]);
7366 
7367         return (MDEG_SUCCESS);
7368 }
7369 
7370 
7371 static int
7372 vds_do_attach(dev_info_t *dip)
7373 {
7374         int                     status, sz;
7375         int                     cfg_handle;
7376         minor_t                 instance = ddi_get_instance(dip);
7377         vds_t                   *vds;
7378         mdeg_prop_spec_t        *pspecp;
7379         mdeg_node_spec_t        *ispecp;
7380 
7381         /*
7382          * The "cfg-handle" property of a vds node in an MD contains the MD's
7383          * notion of "instance", or unique identifier, for that node; OBP
7384          * stores the value of the "cfg-handle" MD property as the value of
7385          * the "reg" property on the node in the device tree it builds from
7386          * the MD and passes to Solaris.  Thus, we look up the devinfo node's
7387          * "reg" property value to uniquely identify this device instance when
7388          * registering with the MD event-generation framework.  If the "reg"
7389          * property cannot be found, the device tree state is presumably so
7390          * broken that there is no point in continuing.
7391          */
7392         if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
7393             VD_REG_PROP)) {
7394                 PRN("vds \"%s\" property does not exist", VD_REG_PROP);
7395                 return (DDI_FAILURE);
7396         }
7397 
7398         /* Get the MD instance for later MDEG registration */
7399         cfg_handle = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
7400             VD_REG_PROP, -1);
7401 
7402         if (ddi_soft_state_zalloc(vds_state, instance) != DDI_SUCCESS) {
7403                 PRN("Could not allocate state for instance %u", instance);
7404                 return (DDI_FAILURE);
7405         }
7406 
7407         if ((vds = ddi_get_soft_state(vds_state, instance)) == NULL) {
7408                 PRN("Could not get state for instance %u", instance);
7409                 ddi_soft_state_free(vds_state, instance);
7410                 return (DDI_FAILURE);
7411         }
7412 
7413         vds->dip     = dip;
7414         vds->vd_table        = mod_hash_create_ptrhash("vds_vd_table", VDS_NCHAINS,
7415             vds_destroy_vd, sizeof (void *));
7416 
7417         ASSERT(vds->vd_table != NULL);
7418 
7419         if ((status = ldi_ident_from_dip(dip, &vds->ldi_ident)) != 0) {
7420                 PRN("ldi_ident_from_dip() returned errno %d", status);
7421                 return (DDI_FAILURE);
7422         }
7423         vds->initialized |= VDS_LDI;
7424 
7425         /* Register for MD updates */
7426         sz = sizeof (vds_prop_template);
7427         pspecp = kmem_alloc(sz, KM_SLEEP);
7428         bcopy(vds_prop_template, pspecp, sz);
7429 
7430         VDS_SET_MDEG_PROP_INST(pspecp, cfg_handle);
7431 
7432         /* initialize the complete prop spec structure */
7433         ispecp = kmem_zalloc(sizeof (mdeg_node_spec_t), KM_SLEEP);
7434         ispecp->namep = "virtual-device";
7435         ispecp->specp = pspecp;
7436 
7437         if (mdeg_register(ispecp, &vd_match, vds_process_md, vds,
7438             &vds->mdeg) != MDEG_SUCCESS) {
7439                 PRN("Unable to register for MD updates");
7440                 kmem_free(ispecp, sizeof (mdeg_node_spec_t));
7441                 kmem_free(pspecp, sz);
7442                 return (DDI_FAILURE);
7443         }
7444 
7445         vds->ispecp = ispecp;
7446         vds->initialized |= VDS_MDEG;
7447 
7448         /* Prevent auto-detaching so driver is available whenever MD changes */
7449         if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, DDI_NO_AUTODETACH, 1) !=
7450             DDI_PROP_SUCCESS) {
7451                 PRN("failed to set \"%s\" property for instance %u",
7452                     DDI_NO_AUTODETACH, instance);
7453         }
7454 
7455         /* read any user defined driver types from conf file and update list */
7456         vds_driver_types_update(vds);
7457 
7458         ddi_report_dev(dip);
7459         return (DDI_SUCCESS);
7460 }
7461 
7462 static int
7463 vds_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
7464 {
7465         int     status;
7466 
7467         switch (cmd) {
7468         case DDI_ATTACH:
7469                 PR0("Attaching");
7470                 if ((status = vds_do_attach(dip)) != DDI_SUCCESS)
7471                         (void) vds_detach(dip, DDI_DETACH);
7472                 return (status);
7473         case DDI_RESUME:
7474                 PR0("No action required for DDI_RESUME");
7475                 return (DDI_SUCCESS);
7476         default:
7477                 return (DDI_FAILURE);
7478         }
7479 }
7480 
7481 static struct dev_ops vds_ops = {
7482         DEVO_REV,       /* devo_rev */
7483         0,              /* devo_refcnt */
7484         ddi_no_info,    /* devo_getinfo */
7485         nulldev,        /* devo_identify */
7486         nulldev,        /* devo_probe */
7487         vds_attach,     /* devo_attach */
7488         vds_detach,     /* devo_detach */
7489         nodev,          /* devo_reset */
7490         NULL,           /* devo_cb_ops */
7491         NULL,           /* devo_bus_ops */
7492         nulldev,        /* devo_power */
7493         ddi_quiesce_not_needed, /* devo_quiesce */
7494 };
7495 
7496 static struct modldrv modldrv = {
7497         &mod_driverops,
7498         "virtual disk server",
7499         &vds_ops,
7500 };
7501 
7502 static struct modlinkage modlinkage = {
7503         MODREV_1,
7504         &modldrv,
7505         NULL
7506 };
7507 
7508 
7509 int
7510 _init(void)
7511 {
7512         int             status;
7513 
7514         if ((status = ddi_soft_state_init(&vds_state, sizeof (vds_t), 1)) != 0)
7515                 return (status);
7516 
7517         if ((status = mod_install(&modlinkage)) != 0) {
7518                 ddi_soft_state_fini(&vds_state);
7519                 return (status);
7520         }
7521 
7522         return (0);
7523 }
7524 
7525 int
7526 _info(struct modinfo *modinfop)
7527 {
7528         return (mod_info(&modlinkage, modinfop));
7529 }
7530 
7531 int
7532 _fini(void)
7533 {
7534         int     status;
7535 
7536         if ((status = mod_remove(&modlinkage)) != 0)
7537                 return (status);
7538         ddi_soft_state_fini(&vds_state);
7539         return (0);
7540 }