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  * LDoms virtual disk client (vdc) device driver
  28  *
  29  * This driver runs on a guest logical domain and communicates with the virtual
  30  * disk server (vds) driver running on the service domain which is exporting
  31  * virtualized "disks" to the guest logical domain.
  32  *
  33  * The driver can be divided into four sections:
  34  *
  35  * 1) generic device driver housekeeping
  36  *      _init, _fini, attach, detach, ops structures, etc.
  37  *
  38  * 2) communication channel setup
  39  *      Setup the communications link over the LDC channel that vdc uses to
  40  *      talk to the vDisk server. Initialise the descriptor ring which
  41  *      allows the LDC clients to transfer data via memory mappings.
  42  *
  43  * 3) Support exported to upper layers (filesystems, etc)
  44  *      The upper layers call into vdc via strategy(9E) and DKIO(7I)
  45  *      ioctl calls. vdc will copy the data to be written to the descriptor
  46  *      ring or maps the buffer to store the data read by the vDisk
  47  *      server into the descriptor ring. It then sends a message to the
  48  *      vDisk server requesting it to complete the operation.
  49  *
  50  * 4) Handling responses from vDisk server.
  51  *      The vDisk server will ACK some or all of the messages vdc sends to it
  52  *      (this is configured during the handshake). Upon receipt of an ACK
  53  *      vdc will check the descriptor ring and signal to the upper layer
  54  *      code waiting on the IO.
  55  */
  56 
  57 #include <sys/atomic.h>
  58 #include <sys/conf.h>
  59 #include <sys/disp.h>
  60 #include <sys/ddi.h>
  61 #include <sys/dkio.h>
  62 #include <sys/efi_partition.h>
  63 #include <sys/fcntl.h>
  64 #include <sys/file.h>
  65 #include <sys/kstat.h>
  66 #include <sys/mach_descrip.h>
  67 #include <sys/modctl.h>
  68 #include <sys/mdeg.h>
  69 #include <sys/note.h>
  70 #include <sys/open.h>
  71 #include <sys/random.h>
  72 #include <sys/sdt.h>
  73 #include <sys/stat.h>
  74 #include <sys/sunddi.h>
  75 #include <sys/types.h>
  76 #include <sys/promif.h>
  77 #include <sys/var.h>
  78 #include <sys/vtoc.h>
  79 #include <sys/archsystm.h>
  80 #include <sys/sysmacros.h>
  81 
  82 #include <sys/cdio.h>
  83 #include <sys/dktp/fdisk.h>
  84 #include <sys/dktp/dadkio.h>
  85 #include <sys/fs/dv_node.h>
  86 #include <sys/mhd.h>
  87 #include <sys/scsi/generic/sense.h>
  88 #include <sys/scsi/impl/uscsi.h>
  89 #include <sys/scsi/impl/services.h>
  90 #include <sys/scsi/targets/sddef.h>
  91 
  92 #include <sys/ldoms.h>
  93 #include <sys/ldc.h>
  94 #include <sys/vio_common.h>
  95 #include <sys/vio_mailbox.h>
  96 #include <sys/vio_util.h>
  97 #include <sys/vdsk_common.h>
  98 #include <sys/vdsk_mailbox.h>
  99 #include <sys/vdc.h>
 100 
 101 #define VD_OLDVTOC_LIMIT        0x7fffffff
 102 
 103 /*
 104  * function prototypes
 105  */
 106 
 107 /* standard driver functions */
 108 static int      vdc_open(dev_t *dev, int flag, int otyp, cred_t *cred);
 109 static int      vdc_close(dev_t dev, int flag, int otyp, cred_t *cred);
 110 static int      vdc_strategy(struct buf *buf);
 111 static int      vdc_print(dev_t dev, char *str);
 112 static int      vdc_dump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk);
 113 static int      vdc_read(dev_t dev, struct uio *uio, cred_t *cred);
 114 static int      vdc_write(dev_t dev, struct uio *uio, cred_t *cred);
 115 static int      vdc_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
 116                         cred_t *credp, int *rvalp);
 117 static int      vdc_aread(dev_t dev, struct aio_req *aio, cred_t *cred);
 118 static int      vdc_awrite(dev_t dev, struct aio_req *aio, cred_t *cred);
 119 
 120 static int      vdc_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd,
 121                         void *arg, void **resultp);
 122 static int      vdc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
 123 static int      vdc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
 124 static int      vdc_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
 125                     int mod_flags, char *name, caddr_t valuep, int *lengthp);
 126 
 127 /* setup */
 128 static void     vdc_min(struct buf *bufp);
 129 static int      vdc_send(vdc_t *vdc, caddr_t pkt, size_t *msglen);
 130 static int      vdc_do_ldc_init(vdc_t *vdc, vdc_server_t *srvr);
 131 static int      vdc_start_ldc_connection(vdc_t *vdc);
 132 static int      vdc_create_device_nodes(vdc_t *vdc);
 133 static int      vdc_create_device_nodes_efi(vdc_t *vdc);
 134 static int      vdc_create_device_nodes_vtoc(vdc_t *vdc);
 135 static void     vdc_create_io_kstats(vdc_t *vdc);
 136 static void     vdc_create_err_kstats(vdc_t *vdc);
 137 static void     vdc_set_err_kstats(vdc_t *vdc);
 138 static int      vdc_get_md_node(dev_info_t *dip, md_t **mdpp,
 139                     mde_cookie_t *vd_nodep);
 140 static int      vdc_init_ports(vdc_t *vdc, md_t *mdp, mde_cookie_t vd_nodep);
 141 static void     vdc_fini_ports(vdc_t *vdc);
 142 static void     vdc_switch_server(vdc_t *vdcp);
 143 static int      vdc_do_ldc_up(vdc_t *vdc);
 144 static void     vdc_terminate_ldc(vdc_t *vdc, vdc_server_t *srvr);
 145 static int      vdc_init_descriptor_ring(vdc_t *vdc);
 146 static void     vdc_destroy_descriptor_ring(vdc_t *vdc);
 147 static int      vdc_setup_devid(vdc_t *vdc);
 148 static void     vdc_store_label_efi(vdc_t *, efi_gpt_t *, efi_gpe_t *);
 149 static void     vdc_store_label_vtoc(vdc_t *, struct dk_geom *,
 150                     struct extvtoc *);
 151 static void     vdc_store_label_unk(vdc_t *vdc);
 152 static boolean_t vdc_is_opened(vdc_t *vdc);
 153 static void     vdc_update_size(vdc_t *vdc, size_t, size_t, size_t);
 154 static int      vdc_update_vio_bsize(vdc_t *vdc, uint32_t);
 155 
 156 /* handshake with vds */
 157 static int              vdc_init_ver_negotiation(vdc_t *vdc, vio_ver_t ver);
 158 static int              vdc_ver_negotiation(vdc_t *vdcp);
 159 static int              vdc_init_attr_negotiation(vdc_t *vdc);
 160 static int              vdc_attr_negotiation(vdc_t *vdcp);
 161 static int              vdc_init_dring_negotiate(vdc_t *vdc);
 162 static int              vdc_dring_negotiation(vdc_t *vdcp);
 163 static int              vdc_send_rdx(vdc_t *vdcp);
 164 static int              vdc_rdx_exchange(vdc_t *vdcp);
 165 static boolean_t        vdc_is_supported_version(vio_ver_msg_t *ver_msg);
 166 
 167 /* processing incoming messages from vDisk server */
 168 static void     vdc_process_msg_thread(vdc_t *vdc);
 169 static int      vdc_recv(vdc_t *vdc, vio_msg_t *msgp, size_t *nbytesp);
 170 
 171 static uint_t   vdc_handle_cb(uint64_t event, caddr_t arg);
 172 static int      vdc_process_data_msg(vdc_t *vdc, vio_msg_t *msg);
 173 static int      vdc_handle_ver_msg(vdc_t *vdc, vio_ver_msg_t *ver_msg);
 174 static int      vdc_handle_attr_msg(vdc_t *vdc, vd_attr_msg_t *attr_msg);
 175 static int      vdc_handle_dring_reg_msg(vdc_t *vdc, vio_dring_reg_msg_t *msg);
 176 static int      vdc_send_request(vdc_t *vdcp, int operation,
 177                     caddr_t addr, size_t nbytes, int slice, diskaddr_t offset,
 178                     buf_t *bufp, vio_desc_direction_t dir, int flags);
 179 static int      vdc_map_to_shared_dring(vdc_t *vdcp, int idx);
 180 static int      vdc_populate_descriptor(vdc_t *vdcp, int operation,
 181                     caddr_t addr, size_t nbytes, int slice, diskaddr_t offset,
 182                     buf_t *bufp, vio_desc_direction_t dir, int flags);
 183 static int      vdc_do_sync_op(vdc_t *vdcp, int operation, caddr_t addr,
 184                     size_t nbytes, int slice, diskaddr_t offset,
 185                     vio_desc_direction_t dir, boolean_t);
 186 static int      vdc_do_op(vdc_t *vdc, int op, caddr_t addr, size_t nbytes,
 187                     int slice, diskaddr_t offset, struct buf *bufp,
 188                     vio_desc_direction_t dir, int flags);
 189 
 190 static int      vdc_wait_for_response(vdc_t *vdcp, vio_msg_t *msgp);
 191 static int      vdc_drain_response(vdc_t *vdcp, struct buf *buf);
 192 static int      vdc_depopulate_descriptor(vdc_t *vdc, uint_t idx);
 193 static int      vdc_populate_mem_hdl(vdc_t *vdcp, vdc_local_desc_t *ldep);
 194 static int      vdc_verify_seq_num(vdc_t *vdc, vio_dring_msg_t *dring_msg);
 195 
 196 /* dkio */
 197 static int      vd_process_ioctl(dev_t dev, int cmd, caddr_t arg, int mode,
 198                     int *rvalp);
 199 static int      vd_process_efi_ioctl(void *vdisk, int cmd, uintptr_t arg);
 200 static void     vdc_create_fake_geometry(vdc_t *vdc);
 201 static int      vdc_validate_geometry(vdc_t *vdc);
 202 static void     vdc_validate(vdc_t *vdc);
 203 static void     vdc_validate_task(void *arg);
 204 static int      vdc_null_copy_func(vdc_t *vdc, void *from, void *to,
 205                     int mode, int dir);
 206 static int      vdc_get_wce_convert(vdc_t *vdc, void *from, void *to,
 207                     int mode, int dir);
 208 static int      vdc_set_wce_convert(vdc_t *vdc, void *from, void *to,
 209                     int mode, int dir);
 210 static int      vdc_get_vtoc_convert(vdc_t *vdc, void *from, void *to,
 211                     int mode, int dir);
 212 static int      vdc_set_vtoc_convert(vdc_t *vdc, void *from, void *to,
 213                     int mode, int dir);
 214 static int      vdc_get_extvtoc_convert(vdc_t *vdc, void *from, void *to,
 215                     int mode, int dir);
 216 static int      vdc_set_extvtoc_convert(vdc_t *vdc, void *from, void *to,
 217                     int mode, int dir);
 218 static int      vdc_get_geom_convert(vdc_t *vdc, void *from, void *to,
 219                     int mode, int dir);
 220 static int      vdc_set_geom_convert(vdc_t *vdc, void *from, void *to,
 221                     int mode, int dir);
 222 static int      vdc_get_efi_convert(vdc_t *vdc, void *from, void *to,
 223                     int mode, int dir);
 224 static int      vdc_set_efi_convert(vdc_t *vdc, void *from, void *to,
 225                     int mode, int dir);
 226 
 227 static void     vdc_ownership_update(vdc_t *vdc, int ownership_flags);
 228 static int      vdc_access_set(vdc_t *vdc, uint64_t flags);
 229 static vdc_io_t *vdc_eio_queue(vdc_t *vdc, int index);
 230 static void     vdc_eio_unqueue(vdc_t *vdc, clock_t deadline,
 231                     boolean_t complete_io);
 232 static int      vdc_eio_check(vdc_t *vdc, int flags);
 233 static void     vdc_eio_thread(void *arg);
 234 
 235 /*
 236  * Module variables
 237  */
 238 
 239 /*
 240  * Number of handshake retries with the current server before switching to
 241  * a different server. These retries are done so that we stick with the same
 242  * server if vdc receives a LDC reset event during the initiation of the
 243  * handshake. This can happen if vdc reset the LDC channel and then immediately
 244  * retry a connexion before it has received the LDC reset event.
 245  *
 246  * If there is only one server then we "switch" to the same server. We also
 247  * switch if the handshake has reached the attribute negotiate step whatever
 248  * the number of handshake retries might be.
 249  */
 250 static uint_t vdc_hshake_retries = VDC_HSHAKE_RETRIES;
 251 
 252 /*
 253  * If the handshake done during the attach fails then the two following
 254  * variables will also be used to control the number of retries for the
 255  * next handshakes. In that case, when a handshake is done after the
 256  * attach (i.e. the vdc lifecycle is VDC_ONLINE_PENDING) then the handshake
 257  * will be retried until we have done an attribution negotiation with each
 258  * server, with a specified minimum total number of negotations (the value
 259  * of the vdc_hattr_min_initial or vdc_hattr_min variable).
 260  *
 261  * This prevents new I/Os on a newly used vdisk to block forever if the
 262  * attribute negotiations can not be done, and to limit the amount of time
 263  * before I/Os will fail. Basically, attribute negotiations will fail when
 264  * the service is up but the backend does not exist. In that case, vds will
 265  * typically retry to access the backend during 50 seconds. So I/Os will fail
 266  * after the following amount of time:
 267  *
 268  *      50 seconds x max(number of servers, vdc->hattr_min)
 269  *
 270  * After that the handshake done during the attach has failed then the next
 271  * handshake will use vdc_attr_min_initial. This handshake will correspond to
 272  * the very first I/O to the device. If this handshake also fails then
 273  * vdc_hattr_min will be used for subsequent handshakes. We typically allow
 274  * more retries for the first handshake (VDC_HATTR_MIN_INITIAL = 3) to give more
 275  * time for the backend to become available (50s x VDC_HATTR_MIN_INITIAL = 150s)
 276  * in case this is a critical vdisk (e.g. vdisk access during boot). Then we use
 277  * a smaller value (VDC_HATTR_MIN = 1) to avoid waiting too long for each I/O.
 278  */
 279 static uint_t vdc_hattr_min_initial = VDC_HATTR_MIN_INITIAL;
 280 static uint_t vdc_hattr_min = VDC_HATTR_MIN;
 281 
 282 /*
 283  * Tunable variables to control how long vdc waits before timing out on
 284  * various operations
 285  */
 286 static int      vdc_timeout = 0; /* units: seconds */
 287 static int      vdc_ldcup_timeout = 1; /* units: seconds */
 288 
 289 static uint64_t vdc_hz_min_ldc_delay;
 290 static uint64_t vdc_min_timeout_ldc = 1 * MILLISEC;
 291 static uint64_t vdc_hz_max_ldc_delay;
 292 static uint64_t vdc_max_timeout_ldc = 100 * MILLISEC;
 293 
 294 static uint64_t vdc_ldc_read_init_delay = 1 * MILLISEC;
 295 static uint64_t vdc_ldc_read_max_delay = 100 * MILLISEC;
 296 
 297 /* values for dumping - need to run in a tighter loop */
 298 static uint64_t vdc_usec_timeout_dump = 100 * MILLISEC; /* 0.1s units: ns */
 299 static int      vdc_dump_retries = 100;
 300 
 301 static uint16_t vdc_scsi_timeout = 60;  /* 60s units: seconds  */
 302 
 303 static uint64_t vdc_ownership_delay = 6 * MICROSEC; /* 6s units: usec */
 304 
 305 /* Count of the number of vdc instances attached */
 306 static volatile uint32_t        vdc_instance_count = 0;
 307 
 308 /* Tunable to log all SCSI errors */
 309 static boolean_t vdc_scsi_log_error = B_FALSE;
 310 
 311 /* Soft state pointer */
 312 static void     *vdc_state;
 313 
 314 /*
 315  * Controlling the verbosity of the error/debug messages
 316  *
 317  * vdc_msglevel - controls level of messages
 318  * vdc_matchinst - 64-bit variable where each bit corresponds
 319  *                 to the vdc instance the vdc_msglevel applies.
 320  */
 321 int             vdc_msglevel = 0x0;
 322 uint64_t        vdc_matchinst = 0ull;
 323 
 324 /*
 325  * Supported vDisk protocol version pairs.
 326  *
 327  * The first array entry is the latest and preferred version.
 328  */
 329 static const vio_ver_t  vdc_version[] = {{1, 1}};
 330 
 331 static struct cb_ops vdc_cb_ops = {
 332         vdc_open,       /* cb_open */
 333         vdc_close,      /* cb_close */
 334         vdc_strategy,   /* cb_strategy */
 335         vdc_print,      /* cb_print */
 336         vdc_dump,       /* cb_dump */
 337         vdc_read,       /* cb_read */
 338         vdc_write,      /* cb_write */
 339         vdc_ioctl,      /* cb_ioctl */
 340         nodev,          /* cb_devmap */
 341         nodev,          /* cb_mmap */
 342         nodev,          /* cb_segmap */
 343         nochpoll,       /* cb_chpoll */
 344         vdc_prop_op,    /* cb_prop_op */
 345         NULL,           /* cb_str */
 346         D_MP | D_64BIT, /* cb_flag */
 347         CB_REV,         /* cb_rev */
 348         vdc_aread,      /* cb_aread */
 349         vdc_awrite      /* cb_awrite */
 350 };
 351 
 352 static struct dev_ops vdc_ops = {
 353         DEVO_REV,       /* devo_rev */
 354         0,              /* devo_refcnt */
 355         vdc_getinfo,    /* devo_getinfo */
 356         nulldev,        /* devo_identify */
 357         nulldev,        /* devo_probe */
 358         vdc_attach,     /* devo_attach */
 359         vdc_detach,     /* devo_detach */
 360         nodev,          /* devo_reset */
 361         &vdc_cb_ops,        /* devo_cb_ops */
 362         NULL,           /* devo_bus_ops */
 363         nulldev,        /* devo_power */
 364         ddi_quiesce_not_needed, /* devo_quiesce */
 365 };
 366 
 367 static struct modldrv modldrv = {
 368         &mod_driverops,
 369         "virtual disk client",
 370         &vdc_ops,
 371 };
 372 
 373 static struct modlinkage modlinkage = {
 374         MODREV_1,
 375         &modldrv,
 376         NULL
 377 };
 378 
 379 /* -------------------------------------------------------------------------- */
 380 
 381 /*
 382  * Device Driver housekeeping and setup
 383  */
 384 
 385 int
 386 _init(void)
 387 {
 388         int     status;
 389 
 390         if ((status = ddi_soft_state_init(&vdc_state, sizeof (vdc_t), 1)) != 0)
 391                 return (status);
 392         if ((status = mod_install(&modlinkage)) != 0)
 393                 ddi_soft_state_fini(&vdc_state);
 394         return (status);
 395 }
 396 
 397 int
 398 _info(struct modinfo *modinfop)
 399 {
 400         return (mod_info(&modlinkage, modinfop));
 401 }
 402 
 403 int
 404 _fini(void)
 405 {
 406         int     status;
 407 
 408         if ((status = mod_remove(&modlinkage)) != 0)
 409                 return (status);
 410         ddi_soft_state_fini(&vdc_state);
 411         return (0);
 412 }
 413 
 414 static int
 415 vdc_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd,  void *arg, void **resultp)
 416 {
 417         _NOTE(ARGUNUSED(dip))
 418 
 419         int     instance = VDCUNIT((dev_t)arg);
 420         vdc_t   *vdc = NULL;
 421 
 422         switch (cmd) {
 423         case DDI_INFO_DEVT2DEVINFO:
 424                 if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
 425                         *resultp = NULL;
 426                         return (DDI_FAILURE);
 427                 }
 428                 *resultp = vdc->dip;
 429                 return (DDI_SUCCESS);
 430         case DDI_INFO_DEVT2INSTANCE:
 431                 *resultp = (void *)(uintptr_t)instance;
 432                 return (DDI_SUCCESS);
 433         default:
 434                 *resultp = NULL;
 435                 return (DDI_FAILURE);
 436         }
 437 }
 438 
 439 static int
 440 vdc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
 441 {
 442         kt_did_t eio_tid, ownership_tid;
 443         int     instance;
 444         int     rv;
 445         vdc_server_t *srvr;
 446         vdc_t   *vdc = NULL;
 447 
 448         switch (cmd) {
 449         case DDI_DETACH:
 450                 /* the real work happens below */
 451                 break;
 452         case DDI_SUSPEND:
 453                 /* nothing to do for this non-device */
 454                 return (DDI_SUCCESS);
 455         default:
 456                 return (DDI_FAILURE);
 457         }
 458 
 459         ASSERT(cmd == DDI_DETACH);
 460         instance = ddi_get_instance(dip);
 461         DMSGX(1, "[%d] Entered\n", instance);
 462 
 463         if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
 464                 cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
 465                 return (DDI_FAILURE);
 466         }
 467 
 468         if (vdc_is_opened(vdc)) {
 469                 DMSG(vdc, 0, "[%d] Cannot detach: device is open", instance);
 470                 return (DDI_FAILURE);
 471         }
 472 
 473         if (vdc->dkio_flush_pending) {
 474                 DMSG(vdc, 0,
 475                     "[%d] Cannot detach: %d outstanding DKIO flushes\n",
 476                     instance, vdc->dkio_flush_pending);
 477                 return (DDI_FAILURE);
 478         }
 479 
 480         if (vdc->validate_pending) {
 481                 DMSG(vdc, 0,
 482                     "[%d] Cannot detach: %d outstanding validate request\n",
 483                     instance, vdc->validate_pending);
 484                 return (DDI_FAILURE);
 485         }
 486 
 487         DMSG(vdc, 0, "[%d] proceeding...\n", instance);
 488 
 489         /* If we took ownership, release ownership */
 490         mutex_enter(&vdc->ownership_lock);
 491         if (vdc->ownership & VDC_OWNERSHIP_GRANTED) {
 492                 rv = vdc_access_set(vdc, VD_ACCESS_SET_CLEAR);
 493                 if (rv == 0) {
 494                         vdc_ownership_update(vdc, VDC_OWNERSHIP_NONE);
 495                 }
 496         }
 497         mutex_exit(&vdc->ownership_lock);
 498 
 499         /* mark instance as detaching */
 500         mutex_enter(&vdc->lock);
 501         vdc->lifecycle       = VDC_LC_DETACHING;
 502         mutex_exit(&vdc->lock);
 503 
 504         /*
 505          * Try and disable callbacks to prevent another handshake. We have to
 506          * disable callbacks for all servers.
 507          */
 508         for (srvr = vdc->server_list; srvr != NULL; srvr = srvr->next) {
 509                 rv = ldc_set_cb_mode(srvr->ldc_handle, LDC_CB_DISABLE);
 510                 DMSG(vdc, 0, "callback disabled (ldc=%lu, rv=%d)\n",
 511                     srvr->ldc_id, rv);
 512         }
 513 
 514         if (vdc->initialized & VDC_THREAD) {
 515                 mutex_enter(&vdc->read_lock);
 516                 if ((vdc->read_state == VDC_READ_WAITING) ||
 517                     (vdc->read_state == VDC_READ_RESET)) {
 518                         vdc->read_state = VDC_READ_RESET;
 519                         cv_signal(&vdc->read_cv);
 520                 }
 521 
 522                 mutex_exit(&vdc->read_lock);
 523 
 524                 /* wake up any thread waiting for connection to come online */
 525                 mutex_enter(&vdc->lock);
 526                 if (vdc->state == VDC_STATE_INIT_WAITING) {
 527                         DMSG(vdc, 0,
 528                             "[%d] write reset - move to resetting state...\n",
 529                             instance);
 530                         vdc->state = VDC_STATE_RESETTING;
 531                         cv_signal(&vdc->initwait_cv);
 532                 } else if (vdc->state == VDC_STATE_FAILED) {
 533                         vdc->io_pending = B_TRUE;
 534                         cv_signal(&vdc->io_pending_cv);
 535                 }
 536                 mutex_exit(&vdc->lock);
 537 
 538                 /* now wait until state transitions to VDC_STATE_DETACH */
 539                 thread_join(vdc->msg_proc_thr->t_did);
 540                 ASSERT(vdc->state == VDC_STATE_DETACH);
 541                 DMSG(vdc, 0, "[%d] Reset thread exit and join ..\n",
 542                     vdc->instance);
 543         }
 544 
 545         mutex_enter(&vdc->lock);
 546 
 547         if (vdc->initialized & VDC_DRING)
 548                 vdc_destroy_descriptor_ring(vdc);
 549 
 550         vdc_fini_ports(vdc);
 551 
 552         if (vdc->eio_thread) {
 553                 eio_tid = vdc->eio_thread->t_did;
 554                 vdc->failfast_interval = 0;
 555                 ASSERT(vdc->num_servers == 0);
 556                 cv_signal(&vdc->eio_cv);
 557         } else {
 558                 eio_tid = 0;
 559         }
 560 
 561         if (vdc->ownership & VDC_OWNERSHIP_WANTED) {
 562                 ownership_tid = vdc->ownership_thread->t_did;
 563                 vdc->ownership = VDC_OWNERSHIP_NONE;
 564                 cv_signal(&vdc->ownership_cv);
 565         } else {
 566                 ownership_tid = 0;
 567         }
 568 
 569         mutex_exit(&vdc->lock);
 570 
 571         if (eio_tid != 0)
 572                 thread_join(eio_tid);
 573 
 574         if (ownership_tid != 0)
 575                 thread_join(ownership_tid);
 576 
 577         if (vdc->initialized & VDC_MINOR)
 578                 ddi_remove_minor_node(dip, NULL);
 579 
 580         if (vdc->io_stats) {
 581                 kstat_delete(vdc->io_stats);
 582                 vdc->io_stats = NULL;
 583         }
 584 
 585         if (vdc->err_stats) {
 586                 kstat_delete(vdc->err_stats);
 587                 vdc->err_stats = NULL;
 588         }
 589 
 590         if (vdc->initialized & VDC_LOCKS) {
 591                 mutex_destroy(&vdc->lock);
 592                 mutex_destroy(&vdc->read_lock);
 593                 mutex_destroy(&vdc->ownership_lock);
 594                 cv_destroy(&vdc->initwait_cv);
 595                 cv_destroy(&vdc->dring_free_cv);
 596                 cv_destroy(&vdc->membind_cv);
 597                 cv_destroy(&vdc->sync_blocked_cv);
 598                 cv_destroy(&vdc->read_cv);
 599                 cv_destroy(&vdc->running_cv);
 600                 cv_destroy(&vdc->io_pending_cv);
 601                 cv_destroy(&vdc->ownership_cv);
 602                 cv_destroy(&vdc->eio_cv);
 603         }
 604 
 605         if (vdc->minfo)
 606                 kmem_free(vdc->minfo, sizeof (struct dk_minfo));
 607 
 608         if (vdc->cinfo)
 609                 kmem_free(vdc->cinfo, sizeof (struct dk_cinfo));
 610 
 611         if (vdc->vtoc)
 612                 kmem_free(vdc->vtoc, sizeof (struct extvtoc));
 613 
 614         if (vdc->geom)
 615                 kmem_free(vdc->geom, sizeof (struct dk_geom));
 616 
 617         if (vdc->devid) {
 618                 ddi_devid_unregister(dip);
 619                 ddi_devid_free(vdc->devid);
 620         }
 621 
 622         if (vdc->initialized & VDC_SOFT_STATE)
 623                 ddi_soft_state_free(vdc_state, instance);
 624 
 625         DMSG(vdc, 0, "[%d] End %p\n", instance, (void *)vdc);
 626 
 627         return (DDI_SUCCESS);
 628 }
 629 
 630 
 631 static int
 632 vdc_do_attach(dev_info_t *dip)
 633 {
 634         int             instance;
 635         vdc_t           *vdc = NULL;
 636         int             status;
 637         md_t            *mdp;
 638         mde_cookie_t    vd_node;
 639 
 640         ASSERT(dip != NULL);
 641 
 642         instance = ddi_get_instance(dip);
 643         if (ddi_soft_state_zalloc(vdc_state, instance) != DDI_SUCCESS) {
 644                 cmn_err(CE_NOTE, "[%d] Couldn't alloc state structure",
 645                     instance);
 646                 return (DDI_FAILURE);
 647         }
 648 
 649         if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
 650                 cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
 651                 return (DDI_FAILURE);
 652         }
 653 
 654         /*
 655          * We assign the value to initialized in this case to zero out the
 656          * variable and then set bits in it to indicate what has been done
 657          */
 658         vdc->initialized = VDC_SOFT_STATE;
 659 
 660         vdc_hz_min_ldc_delay = drv_usectohz(vdc_min_timeout_ldc);
 661         vdc_hz_max_ldc_delay = drv_usectohz(vdc_max_timeout_ldc);
 662 
 663         vdc->dip     = dip;
 664         vdc->instance        = instance;
 665         vdc->vdisk_type      = VD_DISK_TYPE_UNK;
 666         vdc->vdisk_label = VD_DISK_LABEL_UNK;
 667         vdc->state   = VDC_STATE_INIT;
 668         vdc->lifecycle       = VDC_LC_ATTACHING;
 669         vdc->session_id = 0;
 670         vdc->vdisk_bsize = DEV_BSIZE;
 671         vdc->vio_bmask = 0;
 672         vdc->vio_bshift = 0;
 673         vdc->max_xfer_sz = maxphys / vdc->vdisk_bsize;
 674 
 675         /*
 676          * We assume, for now, that the vDisk server will export 'read'
 677          * operations to us at a minimum (this is needed because of checks
 678          * in vdc for supported operations early in the handshake process).
 679          * The vDisk server will return ENOTSUP if this is not the case.
 680          * The value will be overwritten during the attribute exchange with
 681          * the bitmask of operations exported by server.
 682          */
 683         vdc->operations = VD_OP_MASK_READ;
 684 
 685         vdc->vtoc = NULL;
 686         vdc->geom = NULL;
 687         vdc->cinfo = NULL;
 688         vdc->minfo = NULL;
 689 
 690         mutex_init(&vdc->lock, NULL, MUTEX_DRIVER, NULL);
 691         cv_init(&vdc->initwait_cv, NULL, CV_DRIVER, NULL);
 692         cv_init(&vdc->dring_free_cv, NULL, CV_DRIVER, NULL);
 693         cv_init(&vdc->membind_cv, NULL, CV_DRIVER, NULL);
 694         cv_init(&vdc->running_cv, NULL, CV_DRIVER, NULL);
 695         cv_init(&vdc->io_pending_cv, NULL, CV_DRIVER, NULL);
 696 
 697         vdc->io_pending = B_FALSE;
 698         vdc->threads_pending = 0;
 699         vdc->sync_op_blocked = B_FALSE;
 700         cv_init(&vdc->sync_blocked_cv, NULL, CV_DRIVER, NULL);
 701 
 702         mutex_init(&vdc->ownership_lock, NULL, MUTEX_DRIVER, NULL);
 703         cv_init(&vdc->ownership_cv, NULL, CV_DRIVER, NULL);
 704         cv_init(&vdc->eio_cv, NULL, CV_DRIVER, NULL);
 705 
 706         /* init blocking msg read functionality */
 707         mutex_init(&vdc->read_lock, NULL, MUTEX_DRIVER, NULL);
 708         cv_init(&vdc->read_cv, NULL, CV_DRIVER, NULL);
 709         vdc->read_state = VDC_READ_IDLE;
 710 
 711         vdc->initialized |= VDC_LOCKS;
 712 
 713         /* get device and port MD node for this disk instance */
 714         if (vdc_get_md_node(dip, &mdp, &vd_node) != 0) {
 715                 cmn_err(CE_NOTE, "[%d] Could not get machine description node",
 716                     instance);
 717                 return (DDI_FAILURE);
 718         }
 719 
 720         if (vdc_init_ports(vdc, mdp, vd_node) != 0) {
 721                 cmn_err(CE_NOTE, "[%d] Error initialising ports", instance);
 722                 return (DDI_FAILURE);
 723         }
 724 
 725         (void) md_fini_handle(mdp);
 726 
 727         /* Create the kstats for saving the I/O statistics used by iostat(1M) */
 728         vdc_create_io_kstats(vdc);
 729         vdc_create_err_kstats(vdc);
 730 
 731         /* Initialize remaining structures before starting the msg thread */
 732         vdc->vdisk_label = VD_DISK_LABEL_UNK;
 733         vdc->vtoc = kmem_zalloc(sizeof (struct extvtoc), KM_SLEEP);
 734         vdc->geom = kmem_zalloc(sizeof (struct dk_geom), KM_SLEEP);
 735         vdc->minfo = kmem_zalloc(sizeof (struct dk_minfo), KM_SLEEP);
 736 
 737         /* initialize the thread responsible for managing state with server */
 738         vdc->msg_proc_thr = thread_create(NULL, 0, vdc_process_msg_thread,
 739             vdc, 0, &p0, TS_RUN, minclsyspri);
 740         if (vdc->msg_proc_thr == NULL) {
 741                 cmn_err(CE_NOTE, "[%d] Failed to create msg processing thread",
 742                     instance);
 743                 return (DDI_FAILURE);
 744         }
 745 
 746         /*
 747          * If there are multiple servers then start the eio thread.
 748          */
 749         if (vdc->num_servers > 1) {
 750                 vdc->eio_thread = thread_create(NULL, 0, vdc_eio_thread, vdc, 0,
 751                     &p0, TS_RUN, v.v_maxsyspri - 2);
 752                 if (vdc->eio_thread == NULL) {
 753                         cmn_err(CE_NOTE, "[%d] Failed to create error "
 754                             "I/O thread", instance);
 755                         return (DDI_FAILURE);
 756                 }
 757         }
 758 
 759         vdc->initialized |= VDC_THREAD;
 760 
 761         atomic_inc_32(&vdc_instance_count);
 762 
 763         /*
 764          * Check the disk label. This will send requests and do the handshake.
 765          * We don't really care about the disk label now. What we really need is
 766          * the handshake do be done so that we know the type of the disk (slice
 767          * or full disk) and the appropriate device nodes can be created.
 768          */
 769 
 770         mutex_enter(&vdc->lock);
 771         (void) vdc_validate_geometry(vdc);
 772         mutex_exit(&vdc->lock);
 773 
 774         /*
 775          * Now that we have the device info we can create the device nodes
 776          */
 777         status = vdc_create_device_nodes(vdc);
 778         if (status) {
 779                 DMSG(vdc, 0, "[%d] Failed to create device nodes",
 780                     instance);
 781                 goto return_status;
 782         }
 783 
 784         /*
 785          * Fill in the fields of the error statistics kstat that were not
 786          * available when creating the kstat
 787          */
 788         vdc_set_err_kstats(vdc);
 789         ddi_report_dev(dip);
 790         ASSERT(vdc->lifecycle == VDC_LC_ONLINE ||
 791             vdc->lifecycle == VDC_LC_ONLINE_PENDING);
 792         DMSG(vdc, 0, "[%d] Attach tasks successful\n", instance);
 793 
 794 return_status:
 795         DMSG(vdc, 0, "[%d] Attach completed\n", instance);
 796         return (status);
 797 }
 798 
 799 static int
 800 vdc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
 801 {
 802         int     status;
 803 
 804         switch (cmd) {
 805         case DDI_ATTACH:
 806                 if ((status = vdc_do_attach(dip)) != 0)
 807                         (void) vdc_detach(dip, DDI_DETACH);
 808                 return (status);
 809         case DDI_RESUME:
 810                 /* nothing to do for this non-device */
 811                 return (DDI_SUCCESS);
 812         default:
 813                 return (DDI_FAILURE);
 814         }
 815 }
 816 
 817 static int
 818 vdc_do_ldc_init(vdc_t *vdc, vdc_server_t *srvr)
 819 {
 820         int                     status = 0;
 821         ldc_status_t            ldc_state;
 822         ldc_attr_t              ldc_attr;
 823 
 824         ASSERT(vdc != NULL);
 825         ASSERT(srvr != NULL);
 826 
 827         ldc_attr.devclass = LDC_DEV_BLK;
 828         ldc_attr.instance = vdc->instance;
 829         ldc_attr.mode = LDC_MODE_UNRELIABLE;    /* unreliable transport */
 830         ldc_attr.mtu = VD_LDC_MTU;
 831 
 832         if ((srvr->state & VDC_LDC_INIT) == 0) {
 833                 status = ldc_init(srvr->ldc_id, &ldc_attr,
 834                     &srvr->ldc_handle);
 835                 if (status != 0) {
 836                         DMSG(vdc, 0, "[%d] ldc_init(chan %ld) returned %d",
 837                             vdc->instance, srvr->ldc_id, status);
 838                         return (status);
 839                 }
 840                 srvr->state |= VDC_LDC_INIT;
 841         }
 842         status = ldc_status(srvr->ldc_handle, &ldc_state);
 843         if (status != 0) {
 844                 DMSG(vdc, 0, "[%d] Cannot discover LDC status [err=%d]",
 845                     vdc->instance, status);
 846                 goto init_exit;
 847         }
 848         srvr->ldc_state = ldc_state;
 849 
 850         if ((srvr->state & VDC_LDC_CB) == 0) {
 851                 status = ldc_reg_callback(srvr->ldc_handle, vdc_handle_cb,
 852                     (caddr_t)srvr);
 853                 if (status != 0) {
 854                         DMSG(vdc, 0, "[%d] LDC callback reg. failed (%d)",
 855                             vdc->instance, status);
 856                         goto init_exit;
 857                 }
 858                 srvr->state |= VDC_LDC_CB;
 859         }
 860 
 861         /*
 862          * At this stage we have initialised LDC, we will now try and open
 863          * the connection.
 864          */
 865         if (srvr->ldc_state == LDC_INIT) {
 866                 status = ldc_open(srvr->ldc_handle);
 867                 if (status != 0) {
 868                         DMSG(vdc, 0, "[%d] ldc_open(chan %ld) returned %d",
 869                             vdc->instance, srvr->ldc_id, status);
 870                         goto init_exit;
 871                 }
 872                 srvr->state |= VDC_LDC_OPEN;
 873         }
 874 
 875 init_exit:
 876         if (status) {
 877                 vdc_terminate_ldc(vdc, srvr);
 878         }
 879 
 880         return (status);
 881 }
 882 
 883 static int
 884 vdc_start_ldc_connection(vdc_t *vdc)
 885 {
 886         int             status = 0;
 887 
 888         ASSERT(vdc != NULL);
 889 
 890         ASSERT(MUTEX_HELD(&vdc->lock));
 891 
 892         status = vdc_do_ldc_up(vdc);
 893 
 894         DMSG(vdc, 0, "[%d] Finished bringing up LDC\n", vdc->instance);
 895 
 896         return (status);
 897 }
 898 
 899 static int
 900 vdc_stop_ldc_connection(vdc_t *vdcp)
 901 {
 902         int     status;
 903 
 904         ASSERT(vdcp != NULL);
 905 
 906         ASSERT(MUTEX_HELD(&vdcp->lock));
 907 
 908         DMSG(vdcp, 0, ": Resetting connection to vDisk server : state %d\n",
 909             vdcp->state);
 910 
 911         status = ldc_down(vdcp->curr_server->ldc_handle);
 912         DMSG(vdcp, 0, "ldc_down() = %d\n", status);
 913 
 914         vdcp->initialized &= ~VDC_HANDSHAKE;
 915         DMSG(vdcp, 0, "initialized=%x\n", vdcp->initialized);
 916 
 917         return (status);
 918 }
 919 
 920 static void
 921 vdc_create_io_kstats(vdc_t *vdc)
 922 {
 923         if (vdc->io_stats != NULL) {
 924                 DMSG(vdc, 0, "[%d] I/O kstat already exists\n", vdc->instance);
 925                 return;
 926         }
 927 
 928         vdc->io_stats = kstat_create(VDC_DRIVER_NAME, vdc->instance, NULL,
 929             "disk", KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT);
 930         if (vdc->io_stats != NULL) {
 931                 vdc->io_stats->ks_lock = &vdc->lock;
 932                 kstat_install(vdc->io_stats);
 933         } else {
 934                 cmn_err(CE_NOTE, "[%d] Failed to create kstat: I/O statistics"
 935                     " will not be gathered", vdc->instance);
 936         }
 937 }
 938 
 939 static void
 940 vdc_create_err_kstats(vdc_t *vdc)
 941 {
 942         vd_err_stats_t  *stp;
 943         char    kstatmodule_err[KSTAT_STRLEN];
 944         char    kstatname[KSTAT_STRLEN];
 945         int     ndata = (sizeof (vd_err_stats_t) / sizeof (kstat_named_t));
 946         int     instance = vdc->instance;
 947 
 948         if (vdc->err_stats != NULL) {
 949                 DMSG(vdc, 0, "[%d] ERR kstat already exists\n", vdc->instance);
 950                 return;
 951         }
 952 
 953         (void) snprintf(kstatmodule_err, sizeof (kstatmodule_err),
 954             "%serr", VDC_DRIVER_NAME);
 955         (void) snprintf(kstatname, sizeof (kstatname),
 956             "%s%d,err", VDC_DRIVER_NAME, instance);
 957 
 958         vdc->err_stats = kstat_create(kstatmodule_err, instance, kstatname,
 959             "device_error", KSTAT_TYPE_NAMED, ndata, KSTAT_FLAG_PERSISTENT);
 960 
 961         if (vdc->err_stats == NULL) {
 962                 cmn_err(CE_NOTE, "[%d] Failed to create kstat: Error statistics"
 963                     " will not be gathered", instance);
 964                 return;
 965         }
 966 
 967         stp = (vd_err_stats_t *)vdc->err_stats->ks_data;
 968         kstat_named_init(&stp->vd_softerrs,      "Soft Errors",
 969             KSTAT_DATA_UINT32);
 970         kstat_named_init(&stp->vd_transerrs,     "Transport Errors",
 971             KSTAT_DATA_UINT32);
 972         kstat_named_init(&stp->vd_protoerrs,     "Protocol Errors",
 973             KSTAT_DATA_UINT32);
 974         kstat_named_init(&stp->vd_vid,           "Vendor",
 975             KSTAT_DATA_CHAR);
 976         kstat_named_init(&stp->vd_pid,           "Product",
 977             KSTAT_DATA_CHAR);
 978         kstat_named_init(&stp->vd_capacity,      "Size",
 979             KSTAT_DATA_ULONGLONG);
 980 
 981         vdc->err_stats->ks_update  = nulldev;
 982 
 983         kstat_install(vdc->err_stats);
 984 }
 985 
 986 static void
 987 vdc_set_err_kstats(vdc_t *vdc)
 988 {
 989         vd_err_stats_t  *stp;
 990 
 991         if (vdc->err_stats == NULL)
 992                 return;
 993 
 994         mutex_enter(&vdc->lock);
 995 
 996         stp = (vd_err_stats_t *)vdc->err_stats->ks_data;
 997         ASSERT(stp != NULL);
 998 
 999         stp->vd_capacity.value.ui64 = vdc->vdisk_size * vdc->vdisk_bsize;
1000         (void) strcpy(stp->vd_vid.value.c, "SUN");
1001         (void) strcpy(stp->vd_pid.value.c, "VDSK");
1002 
1003         mutex_exit(&vdc->lock);
1004 }
1005 
1006 static int
1007 vdc_create_device_nodes_efi(vdc_t *vdc)
1008 {
1009         ddi_remove_minor_node(vdc->dip, "h");
1010         ddi_remove_minor_node(vdc->dip, "h,raw");
1011 
1012         if (ddi_create_minor_node(vdc->dip, "wd", S_IFBLK,
1013             VD_MAKE_DEV(vdc->instance, VD_EFI_WD_SLICE),
1014             DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
1015                 cmn_err(CE_NOTE, "[%d] Couldn't add block node 'wd'",
1016                     vdc->instance);
1017                 return (EIO);
1018         }
1019 
1020         /* if any device node is created we set this flag */
1021         vdc->initialized |= VDC_MINOR;
1022 
1023         if (ddi_create_minor_node(vdc->dip, "wd,raw", S_IFCHR,
1024             VD_MAKE_DEV(vdc->instance, VD_EFI_WD_SLICE),
1025             DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
1026                 cmn_err(CE_NOTE, "[%d] Couldn't add block node 'wd,raw'",
1027                     vdc->instance);
1028                 return (EIO);
1029         }
1030 
1031         return (0);
1032 }
1033 
1034 static int
1035 vdc_create_device_nodes_vtoc(vdc_t *vdc)
1036 {
1037         ddi_remove_minor_node(vdc->dip, "wd");
1038         ddi_remove_minor_node(vdc->dip, "wd,raw");
1039 
1040         if (ddi_create_minor_node(vdc->dip, "h", S_IFBLK,
1041             VD_MAKE_DEV(vdc->instance, VD_EFI_WD_SLICE),
1042             DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
1043                 cmn_err(CE_NOTE, "[%d] Couldn't add block node 'h'",
1044                     vdc->instance);
1045                 return (EIO);
1046         }
1047 
1048         /* if any device node is created we set this flag */
1049         vdc->initialized |= VDC_MINOR;
1050 
1051         if (ddi_create_minor_node(vdc->dip, "h,raw", S_IFCHR,
1052             VD_MAKE_DEV(vdc->instance, VD_EFI_WD_SLICE),
1053             DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
1054                 cmn_err(CE_NOTE, "[%d] Couldn't add block node 'h,raw'",
1055                     vdc->instance);
1056                 return (EIO);
1057         }
1058 
1059         return (0);
1060 }
1061 
1062 /*
1063  * Function:
1064  *      vdc_create_device_nodes
1065  *
1066  * Description:
1067  *      This function creates the block and character device nodes under
1068  *      /devices. It is called as part of the attach(9E) of the instance
1069  *      during the handshake with vds after vds has sent the attributes
1070  *      to vdc.
1071  *
1072  *      If the device is of type VD_DISK_TYPE_SLICE then the minor node
1073  *      of 2 is used in keeping with the Solaris convention that slice 2
1074  *      refers to a whole disk. Slices start at 'a'
1075  *
1076  * Parameters:
1077  *      vdc             - soft state pointer
1078  *
1079  * Return Values
1080  *      0               - Success
1081  *      EIO             - Failed to create node
1082  */
1083 static int
1084 vdc_create_device_nodes(vdc_t *vdc)
1085 {
1086         char            name[sizeof ("s,raw")];
1087         dev_info_t      *dip = NULL;
1088         int             instance, status;
1089         int             num_slices = 1;
1090         int             i;
1091 
1092         ASSERT(vdc != NULL);
1093 
1094         instance = vdc->instance;
1095         dip = vdc->dip;
1096 
1097         switch (vdc->vdisk_type) {
1098         case VD_DISK_TYPE_DISK:
1099         case VD_DISK_TYPE_UNK:
1100                 num_slices = V_NUMPAR;
1101                 break;
1102         case VD_DISK_TYPE_SLICE:
1103                 num_slices = 1;
1104                 break;
1105         default:
1106                 ASSERT(0);
1107         }
1108 
1109         /*
1110          * Minor nodes are different for EFI disks: EFI disks do not have
1111          * a minor node 'g' for the minor number corresponding to slice
1112          * VD_EFI_WD_SLICE (slice 7) instead they have a minor node 'wd'
1113          * representing the whole disk.
1114          */
1115         for (i = 0; i < num_slices; i++) {
1116 
1117                 if (i == VD_EFI_WD_SLICE) {
1118                         if (vdc->vdisk_label == VD_DISK_LABEL_EFI)
1119                                 status = vdc_create_device_nodes_efi(vdc);
1120                         else
1121                                 status = vdc_create_device_nodes_vtoc(vdc);
1122                         if (status != 0)
1123                                 return (status);
1124                         continue;
1125                 }
1126 
1127                 (void) snprintf(name, sizeof (name), "%c", 'a' + i);
1128                 if (ddi_create_minor_node(dip, name, S_IFBLK,
1129                     VD_MAKE_DEV(instance, i), DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
1130                         cmn_err(CE_NOTE, "[%d] Couldn't add block node '%s'",
1131                             instance, name);
1132                         return (EIO);
1133                 }
1134 
1135                 /* if any device node is created we set this flag */
1136                 vdc->initialized |= VDC_MINOR;
1137 
1138                 (void) snprintf(name, sizeof (name), "%c%s", 'a' + i, ",raw");
1139 
1140                 if (ddi_create_minor_node(dip, name, S_IFCHR,
1141                     VD_MAKE_DEV(instance, i), DDI_NT_BLOCK, 0) != DDI_SUCCESS) {
1142                         cmn_err(CE_NOTE, "[%d] Couldn't add raw node '%s'",
1143                             instance, name);
1144                         return (EIO);
1145                 }
1146         }
1147 
1148         return (0);
1149 }
1150 
1151 /*
1152  * Driver prop_op(9e) entry point function. Return the number of blocks for
1153  * the partition in question or forward the request to the property facilities.
1154  */
1155 static int
1156 vdc_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
1157     char *name, caddr_t valuep, int *lengthp)
1158 {
1159         int instance = ddi_get_instance(dip);
1160         vdc_t *vdc;
1161         uint64_t nblocks;
1162         uint_t blksize;
1163 
1164         vdc = ddi_get_soft_state(vdc_state, instance);
1165 
1166         if (dev == DDI_DEV_T_ANY || vdc == NULL) {
1167                 return (ddi_prop_op(dev, dip, prop_op, mod_flags,
1168                     name, valuep, lengthp));
1169         }
1170 
1171         mutex_enter(&vdc->lock);
1172         (void) vdc_validate_geometry(vdc);
1173         if (vdc->vdisk_label == VD_DISK_LABEL_UNK) {
1174                 mutex_exit(&vdc->lock);
1175                 return (ddi_prop_op(dev, dip, prop_op, mod_flags,
1176                     name, valuep, lengthp));
1177         }
1178         nblocks = vdc->slice[VDCPART(dev)].nblocks;
1179         blksize = vdc->vdisk_bsize;
1180         mutex_exit(&vdc->lock);
1181 
1182         return (ddi_prop_op_nblocks_blksize(dev, dip, prop_op, mod_flags,
1183             name, valuep, lengthp, nblocks, blksize));
1184 }
1185 
1186 /*
1187  * Function:
1188  *      vdc_is_opened
1189  *
1190  * Description:
1191  *      This function checks if any slice of a given virtual disk is
1192  *      currently opened.
1193  *
1194  * Parameters:
1195  *      vdc             - soft state pointer
1196  *
1197  * Return Values
1198  *      B_TRUE          - at least one slice is opened.
1199  *      B_FALSE         - no slice is opened.
1200  */
1201 static boolean_t
1202 vdc_is_opened(vdc_t *vdc)
1203 {
1204         int i;
1205 
1206         /* check if there's any layered open */
1207         for (i = 0; i < V_NUMPAR; i++) {
1208                 if (vdc->open_lyr[i] > 0)
1209                         return (B_TRUE);
1210         }
1211 
1212         /* check if there is any other kind of open */
1213         for (i = 0; i < OTYPCNT; i++) {
1214                 if (vdc->open[i] != 0)
1215                         return (B_TRUE);
1216         }
1217 
1218         return (B_FALSE);
1219 }
1220 
1221 static int
1222 vdc_mark_opened(vdc_t *vdc, int slice, int flag, int otyp)
1223 {
1224         uint8_t slicemask;
1225         int i;
1226 
1227         ASSERT(otyp < OTYPCNT);
1228         ASSERT(slice < V_NUMPAR);
1229         ASSERT(MUTEX_HELD(&vdc->lock));
1230 
1231         slicemask = 1 << slice;
1232 
1233         /*
1234          * If we have a single-slice disk which was unavailable during the
1235          * attach then a device was created for each 8 slices. Now that
1236          * the type is known, we prevent opening any slice other than 0
1237          * even if a device still exists.
1238          */
1239         if (vdc->vdisk_type == VD_DISK_TYPE_SLICE && slice != 0)
1240                 return (EIO);
1241 
1242         /* check if slice is already exclusively opened */
1243         if (vdc->open_excl & slicemask)
1244                 return (EBUSY);
1245 
1246         /* if open exclusive, check if slice is already opened */
1247         if (flag & FEXCL) {
1248                 if (vdc->open_lyr[slice] > 0)
1249                         return (EBUSY);
1250                 for (i = 0; i < OTYPCNT; i++) {
1251                         if (vdc->open[i] & slicemask)
1252                                 return (EBUSY);
1253                 }
1254                 vdc->open_excl |= slicemask;
1255         }
1256 
1257         /* mark slice as opened */
1258         if (otyp == OTYP_LYR) {
1259                 vdc->open_lyr[slice]++;
1260         } else {
1261                 vdc->open[otyp] |= slicemask;
1262         }
1263 
1264         return (0);
1265 }
1266 
1267 static void
1268 vdc_mark_closed(vdc_t *vdc, int slice, int flag, int otyp)
1269 {
1270         uint8_t slicemask;
1271 
1272         ASSERT(otyp < OTYPCNT);
1273         ASSERT(slice < V_NUMPAR);
1274         ASSERT(MUTEX_HELD(&vdc->lock));
1275 
1276         slicemask = 1 << slice;
1277 
1278         if (otyp == OTYP_LYR) {
1279                 ASSERT(vdc->open_lyr[slice] > 0);
1280                 vdc->open_lyr[slice]--;
1281         } else {
1282                 vdc->open[otyp] &= ~slicemask;
1283         }
1284 
1285         if (flag & FEXCL)
1286                 vdc->open_excl &= ~slicemask;
1287 }
1288 
1289 static int
1290 vdc_open(dev_t *dev, int flag, int otyp, cred_t *cred)
1291 {
1292         _NOTE(ARGUNUSED(cred))
1293 
1294         int     instance, nodelay;
1295         int     slice, status = 0;
1296         vdc_t   *vdc;
1297 
1298         ASSERT(dev != NULL);
1299         instance = VDCUNIT(*dev);
1300 
1301         if (otyp >= OTYPCNT)
1302                 return (EINVAL);
1303 
1304         if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
1305                 cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
1306                 return (ENXIO);
1307         }
1308 
1309         DMSG(vdc, 0, "minor = %d flag = %x, otyp = %x\n",
1310             getminor(*dev), flag, otyp);
1311 
1312         slice = VDCPART(*dev);
1313 
1314         nodelay = flag & (FNDELAY | FNONBLOCK);
1315 
1316         if ((flag & FWRITE) && (!nodelay) &&
1317             !(VD_OP_SUPPORTED(vdc->operations, VD_OP_BWRITE))) {
1318                 return (EROFS);
1319         }
1320 
1321         mutex_enter(&vdc->lock);
1322 
1323         status = vdc_mark_opened(vdc, slice, flag, otyp);
1324 
1325         if (status != 0) {
1326                 mutex_exit(&vdc->lock);
1327                 return (status);
1328         }
1329 
1330         /*
1331          * If the disk type is unknown then we have to wait for the
1332          * handshake to complete because we don't know if the slice
1333          * device we are opening effectively exists.
1334          */
1335         if (vdc->vdisk_type != VD_DISK_TYPE_UNK && nodelay) {
1336 
1337                 /* don't resubmit a validate request if there's already one */
1338                 if (vdc->validate_pending > 0) {
1339                         mutex_exit(&vdc->lock);
1340                         return (0);
1341                 }
1342 
1343                 /* call vdc_validate() asynchronously to avoid blocking */
1344                 if (taskq_dispatch(system_taskq, vdc_validate_task,
1345                     (void *)vdc, TQ_NOSLEEP) == NULL) {
1346                         vdc_mark_closed(vdc, slice, flag, otyp);
1347                         mutex_exit(&vdc->lock);
1348                         return (ENXIO);
1349                 }
1350 
1351                 vdc->validate_pending++;
1352                 mutex_exit(&vdc->lock);
1353                 return (0);
1354         }
1355 
1356         mutex_exit(&vdc->lock);
1357 
1358         vdc_validate(vdc);
1359 
1360         mutex_enter(&vdc->lock);
1361 
1362         if (vdc->vdisk_type == VD_DISK_TYPE_UNK ||
1363             (vdc->vdisk_type == VD_DISK_TYPE_SLICE && slice != 0) ||
1364             (!nodelay && (vdc->vdisk_label == VD_DISK_LABEL_UNK ||
1365             vdc->slice[slice].nblocks == 0))) {
1366                 vdc_mark_closed(vdc, slice, flag, otyp);
1367                 status = EIO;
1368         }
1369 
1370         mutex_exit(&vdc->lock);
1371 
1372         return (status);
1373 }
1374 
1375 static int
1376 vdc_close(dev_t dev, int flag, int otyp, cred_t *cred)
1377 {
1378         _NOTE(ARGUNUSED(cred))
1379 
1380         int     instance;
1381         int     slice;
1382         int     rv, rval;
1383         vdc_t   *vdc;
1384 
1385         instance = VDCUNIT(dev);
1386 
1387         if (otyp >= OTYPCNT)
1388                 return (EINVAL);
1389 
1390         if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
1391                 cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
1392                 return (ENXIO);
1393         }
1394 
1395         DMSG(vdc, 0, "[%d] flag = %x, otyp = %x\n", instance, flag, otyp);
1396 
1397         slice = VDCPART(dev);
1398 
1399         /*
1400          * Attempt to flush the W$ on a close operation. If this is
1401          * not a supported IOCTL command or the backing device is read-only
1402          * do not fail the close operation.
1403          */
1404         rv = vd_process_ioctl(dev, DKIOCFLUSHWRITECACHE, NULL, FKIOCTL, &rval);
1405 
1406         if (rv != 0 && rv != ENOTSUP && rv != ENOTTY && rv != EROFS) {
1407                 DMSG(vdc, 0, "[%d] flush failed with error %d on close\n",
1408                     instance, rv);
1409                 return (EIO);
1410         }
1411 
1412         mutex_enter(&vdc->lock);
1413         vdc_mark_closed(vdc, slice, flag, otyp);
1414         mutex_exit(&vdc->lock);
1415 
1416         return (0);
1417 }
1418 
1419 static int
1420 vdc_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, int *rvalp)
1421 {
1422         _NOTE(ARGUNUSED(credp))
1423 
1424         return (vd_process_ioctl(dev, cmd, (caddr_t)arg, mode, rvalp));
1425 }
1426 
1427 static int
1428 vdc_print(dev_t dev, char *str)
1429 {
1430         cmn_err(CE_NOTE, "vdc%d:  %s", VDCUNIT(dev), str);
1431         return (0);
1432 }
1433 
1434 static int
1435 vdc_dump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk)
1436 {
1437         int     rv, flags;
1438         size_t  nbytes = nblk * DEV_BSIZE;
1439         int     instance = VDCUNIT(dev);
1440         vdc_t   *vdc = NULL;
1441         diskaddr_t vio_blkno;
1442 
1443         if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
1444                 cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
1445                 return (ENXIO);
1446         }
1447 
1448         DMSG(vdc, 2, "[%d] dump %ld bytes at block 0x%lx : addr=0x%p\n",
1449             instance, nbytes, blkno, (void *)addr);
1450 
1451         /* convert logical block to vio block */
1452         if ((blkno & vdc->vio_bmask) != 0) {
1453                 DMSG(vdc, 0, "Misaligned block number (%lu)\n", blkno);
1454                 return (EINVAL);
1455         }
1456         vio_blkno = blkno >> vdc->vio_bshift;
1457 
1458         /*
1459          * If we are panicking, we need the state to be "running" so that we
1460          * can submit I/Os, but we don't want to check for any backend error.
1461          */
1462         flags = (ddi_in_panic())? VDC_OP_STATE_RUNNING : VDC_OP_NORMAL;
1463 
1464         rv = vdc_do_op(vdc, VD_OP_BWRITE, addr, nbytes, VDCPART(dev),
1465             vio_blkno, NULL, VIO_write_dir, flags);
1466 
1467         if (rv) {
1468                 DMSG(vdc, 0, "Failed to do a disk dump (err=%d)\n", rv);
1469                 return (rv);
1470         }
1471 
1472         DMSG(vdc, 0, "[%d] End\n", instance);
1473 
1474         return (0);
1475 }
1476 
1477 /* -------------------------------------------------------------------------- */
1478 
1479 /*
1480  * Disk access routines
1481  *
1482  */
1483 
1484 /*
1485  * vdc_strategy()
1486  *
1487  * Return Value:
1488  *      0:      As per strategy(9E), the strategy() function must return 0
1489  *              [ bioerror(9f) sets b_flags to the proper error code ]
1490  */
1491 static int
1492 vdc_strategy(struct buf *buf)
1493 {
1494         diskaddr_t vio_blkno;
1495         vdc_t   *vdc = NULL;
1496         int     instance = VDCUNIT(buf->b_edev);
1497         int     op = (buf->b_flags & B_READ) ? VD_OP_BREAD : VD_OP_BWRITE;
1498         int     slice;
1499 
1500         if ((vdc = ddi_get_soft_state(vdc_state, instance)) == NULL) {
1501                 cmn_err(CE_NOTE, "[%d] Couldn't get state structure", instance);
1502                 bioerror(buf, ENXIO);
1503                 biodone(buf);
1504                 return (0);
1505         }
1506 
1507         DMSG(vdc, 2, "[%d] %s %ld bytes at block %llx : b_addr=0x%p\n",
1508             instance, (buf->b_flags & B_READ) ? "Read" : "Write",
1509             buf->b_bcount, buf->b_lblkno, (void *)buf->b_un.b_addr);
1510 
1511         bp_mapin(buf);
1512 
1513         if ((long)buf->b_private == VD_SLICE_NONE) {
1514                 /* I/O using an absolute disk offset */
1515                 slice = VD_SLICE_NONE;
1516         } else {
1517                 slice = VDCPART(buf->b_edev);
1518         }
1519 
1520         /*
1521          * In the buf structure, b_lblkno represents a logical block number
1522          * using a block size of 512 bytes. For the VIO request, this block
1523          * number has to be converted to be represented with the block size
1524          * used by the VIO protocol.
1525          */
1526         if ((buf->b_lblkno & vdc->vio_bmask) != 0) {
1527                 bioerror(buf, EINVAL);
1528                 biodone(buf);
1529                 return (0);
1530         }
1531         vio_blkno = buf->b_lblkno >> vdc->vio_bshift;
1532 
1533         /* submit the I/O, any error will be reported in the buf structure */
1534         (void) vdc_do_op(vdc, op, (caddr_t)buf->b_un.b_addr,
1535             buf->b_bcount, slice, vio_blkno,
1536             buf, (op == VD_OP_BREAD) ? VIO_read_dir : VIO_write_dir,
1537             VDC_OP_NORMAL);
1538 
1539         return (0);
1540 }
1541 
1542 /*
1543  * Function:
1544  *      vdc_min
1545  *
1546  * Description:
1547  *      Routine to limit the size of a data transfer. Used in
1548  *      conjunction with physio(9F).
1549  *
1550  * Arguments:
1551  *      bp - pointer to the indicated buf(9S) struct.
1552  *
1553  */
1554 static void
1555 vdc_min(struct buf *bufp)
1556 {
1557         vdc_t   *vdc = NULL;
1558         int     instance = VDCUNIT(bufp->b_edev);
1559 
1560         vdc = ddi_get_soft_state(vdc_state, instance);
1561         VERIFY(vdc != NULL);
1562 
1563         if (bufp->b_bcount > (vdc->max_xfer_sz * vdc->vdisk_bsize)) {
1564                 bufp->b_bcount = vdc->max_xfer_sz * vdc->vdisk_bsize;
1565         }
1566 }
1567 
1568 static int
1569 vdc_read(dev_t dev, struct uio *uio, cred_t *cred)
1570 {
1571         _NOTE(ARGUNUSED(cred))
1572 
1573         DMSGX(1, "[%d] Entered", VDCUNIT(dev));
1574         return (physio(vdc_strategy, NULL, dev, B_READ, vdc_min, uio));
1575 }
1576 
1577 static int
1578 vdc_write(dev_t dev, struct uio *uio, cred_t *cred)
1579 {
1580         _NOTE(ARGUNUSED(cred))
1581 
1582         DMSGX(1, "[%d] Entered", VDCUNIT(dev));
1583         return (physio(vdc_strategy, NULL, dev, B_WRITE, vdc_min, uio));
1584 }
1585 
1586 static int
1587 vdc_aread(dev_t dev, struct aio_req *aio, cred_t *cred)
1588 {
1589         _NOTE(ARGUNUSED(cred))
1590 
1591         DMSGX(1, "[%d] Entered", VDCUNIT(dev));
1592         return (aphysio(vdc_strategy, anocancel, dev, B_READ, vdc_min, aio));
1593 }
1594 
1595 static int
1596 vdc_awrite(dev_t dev, struct aio_req *aio, cred_t *cred)
1597 {
1598         _NOTE(ARGUNUSED(cred))
1599 
1600         DMSGX(1, "[%d] Entered", VDCUNIT(dev));
1601         return (aphysio(vdc_strategy, anocancel, dev, B_WRITE, vdc_min, aio));
1602 }
1603 
1604 
1605 /* -------------------------------------------------------------------------- */
1606 
1607 /*
1608  * Handshake support
1609  */
1610 
1611 
1612 /*
1613  * Function:
1614  *      vdc_init_ver_negotiation()
1615  *
1616  * Description:
1617  *
1618  * Arguments:
1619  *      vdc     - soft state pointer for this instance of the device driver.
1620  *
1621  * Return Code:
1622  *      0       - Success
1623  */
1624 static int
1625 vdc_init_ver_negotiation(vdc_t *vdc, vio_ver_t ver)
1626 {
1627         vio_ver_msg_t   pkt;
1628         size_t          msglen = sizeof (pkt);
1629         int             status = -1;
1630 
1631         ASSERT(vdc != NULL);
1632         ASSERT(mutex_owned(&vdc->lock));
1633 
1634         DMSG(vdc, 0, "[%d] Entered.\n", vdc->instance);
1635 
1636         /*
1637          * set the Session ID to a unique value
1638          * (the lower 32 bits of the clock tick)
1639          */
1640         vdc->session_id = ((uint32_t)gettick() & 0xffffffff);
1641         DMSG(vdc, 0, "[%d] Set SID to 0x%lx\n", vdc->instance, vdc->session_id);
1642 
1643         pkt.tag.vio_msgtype = VIO_TYPE_CTRL;
1644         pkt.tag.vio_subtype = VIO_SUBTYPE_INFO;
1645         pkt.tag.vio_subtype_env = VIO_VER_INFO;
1646         pkt.tag.vio_sid = vdc->session_id;
1647         pkt.dev_class = VDEV_DISK;
1648         pkt.ver_major = ver.major;
1649         pkt.ver_minor = ver.minor;
1650 
1651         status = vdc_send(vdc, (caddr_t)&pkt, &msglen);
1652         DMSG(vdc, 0, "[%d] Ver info sent (status = %d)\n",
1653             vdc->instance, status);
1654         if ((status != 0) || (msglen != sizeof (vio_ver_msg_t))) {
1655                 DMSG(vdc, 0, "[%d] Failed to send Ver negotiation info: "
1656                     "id(%lx) rv(%d) size(%ld)", vdc->instance,
1657                     vdc->curr_server->ldc_handle, status, msglen);
1658                 if (msglen != sizeof (vio_ver_msg_t))
1659                         status = ENOMSG;
1660         }
1661 
1662         return (status);
1663 }
1664 
1665 /*
1666  * Function:
1667  *      vdc_ver_negotiation()
1668  *
1669  * Description:
1670  *
1671  * Arguments:
1672  *      vdcp    - soft state pointer for this instance of the device driver.
1673  *
1674  * Return Code:
1675  *      0       - Success
1676  */
1677 static int
1678 vdc_ver_negotiation(vdc_t *vdcp)
1679 {
1680         vio_msg_t vio_msg;
1681         int status;
1682 
1683         if (status = vdc_init_ver_negotiation(vdcp, vdc_version[0]))
1684                 return (status);
1685 
1686         /* release lock and wait for response */
1687         mutex_exit(&vdcp->lock);
1688         status = vdc_wait_for_response(vdcp, &vio_msg);
1689         mutex_enter(&vdcp->lock);
1690         if (status) {
1691                 DMSG(vdcp, 0,
1692                     "[%d] Failed waiting for Ver negotiation response, rv(%d)",
1693                     vdcp->instance, status);
1694                 return (status);
1695         }
1696 
1697         /* check type and sub_type ... */
1698         if (vio_msg.tag.vio_msgtype != VIO_TYPE_CTRL ||
1699             vio_msg.tag.vio_subtype == VIO_SUBTYPE_INFO) {
1700                 DMSG(vdcp, 0, "[%d] Invalid ver negotiation response\n",
1701                     vdcp->instance);
1702                 return (EPROTO);
1703         }
1704 
1705         return (vdc_handle_ver_msg(vdcp, (vio_ver_msg_t *)&vio_msg));
1706 }
1707 
1708 /*
1709  * Function:
1710  *      vdc_init_attr_negotiation()
1711  *
1712  * Description:
1713  *
1714  * Arguments:
1715  *      vdc     - soft state pointer for this instance of the device driver.
1716  *
1717  * Return Code:
1718  *      0       - Success
1719  */
1720 static int
1721 vdc_init_attr_negotiation(vdc_t *vdc)
1722 {
1723         vd_attr_msg_t   pkt;
1724         size_t          msglen = sizeof (pkt);
1725         int             status;
1726 
1727         ASSERT(vdc != NULL);
1728         ASSERT(mutex_owned(&vdc->lock));
1729 
1730         DMSG(vdc, 0, "[%d] entered\n", vdc->instance);
1731 
1732         /* fill in tag */
1733         pkt.tag.vio_msgtype = VIO_TYPE_CTRL;
1734         pkt.tag.vio_subtype = VIO_SUBTYPE_INFO;
1735         pkt.tag.vio_subtype_env = VIO_ATTR_INFO;
1736         pkt.tag.vio_sid = vdc->session_id;
1737         /* fill in payload */
1738         pkt.max_xfer_sz = vdc->max_xfer_sz;
1739         pkt.vdisk_block_size = vdc->vdisk_bsize;
1740         pkt.xfer_mode = VIO_DRING_MODE_V1_0;
1741         pkt.operations = 0;     /* server will set bits of valid operations */
1742         pkt.vdisk_type = 0;     /* server will set to valid device type */
1743         pkt.vdisk_media = 0;    /* server will set to valid media type */
1744         pkt.vdisk_size = 0;     /* server will set to valid size */
1745 
1746         status = vdc_send(vdc, (caddr_t)&pkt, &msglen);
1747         DMSG(vdc, 0, "Attr info sent (status = %d)\n", status);
1748 
1749         if ((status != 0) || (msglen != sizeof (vd_attr_msg_t))) {
1750                 DMSG(vdc, 0, "[%d] Failed to send Attr negotiation info: "
1751                     "id(%lx) rv(%d) size(%ld)", vdc->instance,
1752                     vdc->curr_server->ldc_handle, status, msglen);
1753                 if (msglen != sizeof (vd_attr_msg_t))
1754                         status = ENOMSG;
1755         }
1756 
1757         return (status);
1758 }
1759 
1760 /*
1761  * Function:
1762  *      vdc_attr_negotiation()
1763  *
1764  * Description:
1765  *
1766  * Arguments:
1767  *      vdc     - soft state pointer for this instance of the device driver.
1768  *
1769  * Return Code:
1770  *      0       - Success
1771  */
1772 static int
1773 vdc_attr_negotiation(vdc_t *vdcp)
1774 {
1775         int status;
1776         vio_msg_t vio_msg;
1777 
1778         if (status = vdc_init_attr_negotiation(vdcp))
1779                 return (status);
1780 
1781         /* release lock and wait for response */
1782         mutex_exit(&vdcp->lock);
1783         status = vdc_wait_for_response(vdcp, &vio_msg);
1784         mutex_enter(&vdcp->lock);
1785         if (status) {
1786                 DMSG(vdcp, 0,
1787                     "[%d] Failed waiting for Attr negotiation response, rv(%d)",
1788                     vdcp->instance, status);
1789                 return (status);
1790         }
1791 
1792         /* check type and sub_type ... */
1793         if (vio_msg.tag.vio_msgtype != VIO_TYPE_CTRL ||
1794             vio_msg.tag.vio_subtype == VIO_SUBTYPE_INFO) {
1795                 DMSG(vdcp, 0, "[%d] Invalid attr negotiation response\n",
1796                     vdcp->instance);
1797                 return (EPROTO);
1798         }
1799 
1800         return (vdc_handle_attr_msg(vdcp, (vd_attr_msg_t *)&vio_msg));
1801 }
1802 
1803 
1804 /*
1805  * Function:
1806  *      vdc_init_dring_negotiate()
1807  *
1808  * Description:
1809  *
1810  * Arguments:
1811  *      vdc     - soft state pointer for this instance of the device driver.
1812  *
1813  * Return Code:
1814  *      0       - Success
1815  */
1816 static int
1817 vdc_init_dring_negotiate(vdc_t *vdc)
1818 {
1819         vio_dring_reg_msg_t     pkt;
1820         size_t                  msglen = sizeof (pkt);
1821         int                     status = -1;
1822         int                     retry;
1823         int                     nretries = 10;
1824 
1825         ASSERT(vdc != NULL);
1826         ASSERT(mutex_owned(&vdc->lock));
1827 
1828         for (retry = 0; retry < nretries; retry++) {
1829                 status = vdc_init_descriptor_ring(vdc);
1830                 if (status != EAGAIN)
1831                         break;
1832                 drv_usecwait(vdc_min_timeout_ldc);
1833         }
1834 
1835         if (status != 0) {
1836                 DMSG(vdc, 0, "[%d] Failed to init DRing (status = %d)\n",
1837                     vdc->instance, status);
1838                 return (status);
1839         }
1840 
1841         DMSG(vdc, 0, "[%d] Init of descriptor ring completed (status = %d)\n",
1842             vdc->instance, status);
1843 
1844         /* fill in tag */
1845         pkt.tag.vio_msgtype = VIO_TYPE_CTRL;
1846         pkt.tag.vio_subtype = VIO_SUBTYPE_INFO;
1847         pkt.tag.vio_subtype_env = VIO_DRING_REG;
1848         pkt.tag.vio_sid = vdc->session_id;
1849         /* fill in payload */
1850         pkt.dring_ident = 0;
1851         pkt.num_descriptors = vdc->dring_len;
1852         pkt.descriptor_size = vdc->dring_entry_size;
1853         pkt.options = (VIO_TX_DRING | VIO_RX_DRING);
1854         pkt.ncookies = vdc->dring_cookie_count;
1855         pkt.cookie[0] = vdc->dring_cookie[0];        /* for now just one cookie */
1856 
1857         status = vdc_send(vdc, (caddr_t)&pkt, &msglen);
1858         if (status != 0) {
1859                 DMSG(vdc, 0, "[%d] Failed to register DRing (err = %d)",
1860                     vdc->instance, status);
1861         }
1862 
1863         return (status);
1864 }
1865 
1866 
1867 /*
1868  * Function:
1869  *      vdc_dring_negotiation()
1870  *
1871  * Description:
1872  *
1873  * Arguments:
1874  *      vdc     - soft state pointer for this instance of the device driver.
1875  *
1876  * Return Code:
1877  *      0       - Success
1878  */
1879 static int
1880 vdc_dring_negotiation(vdc_t *vdcp)
1881 {
1882         int status;
1883         vio_msg_t vio_msg;
1884 
1885         if (status = vdc_init_dring_negotiate(vdcp))
1886                 return (status);
1887 
1888         /* release lock and wait for response */
1889         mutex_exit(&vdcp->lock);
1890         status = vdc_wait_for_response(vdcp, &vio_msg);
1891         mutex_enter(&vdcp->lock);
1892         if (status) {
1893                 DMSG(vdcp, 0,
1894                     "[%d] Failed waiting for Dring negotiation response,"
1895                     " rv(%d)", vdcp->instance, status);
1896                 return (status);
1897         }
1898 
1899         /* check type and sub_type ... */
1900         if (vio_msg.tag.vio_msgtype != VIO_TYPE_CTRL ||
1901             vio_msg.tag.vio_subtype == VIO_SUBTYPE_INFO) {
1902                 DMSG(vdcp, 0, "[%d] Invalid Dring negotiation response\n",
1903                     vdcp->instance);
1904                 return (EPROTO);
1905         }
1906 
1907         return (vdc_handle_dring_reg_msg(vdcp,
1908             (vio_dring_reg_msg_t *)&vio_msg));
1909 }
1910 
1911 
1912 /*
1913  * Function:
1914  *      vdc_send_rdx()
1915  *
1916  * Description:
1917  *
1918  * Arguments:
1919  *      vdc     - soft state pointer for this instance of the device driver.
1920  *
1921  * Return Code:
1922  *      0       - Success
1923  */
1924 static int
1925 vdc_send_rdx(vdc_t *vdcp)
1926 {
1927         vio_msg_t       msg;
1928         size_t          msglen = sizeof (vio_msg_t);
1929         int             status;
1930 
1931         /*
1932          * Send an RDX message to vds to indicate we are ready
1933          * to send data
1934          */
1935         msg.tag.vio_msgtype = VIO_TYPE_CTRL;
1936         msg.tag.vio_subtype = VIO_SUBTYPE_INFO;
1937         msg.tag.vio_subtype_env = VIO_RDX;
1938         msg.tag.vio_sid = vdcp->session_id;
1939         status = vdc_send(vdcp, (caddr_t)&msg, &msglen);
1940         if (status != 0) {
1941                 DMSG(vdcp, 0, "[%d] Failed to send RDX message (%d)",
1942                     vdcp->instance, status);
1943         }
1944 
1945         return (status);
1946 }
1947 
1948 /*
1949  * Function:
1950  *      vdc_handle_rdx()
1951  *
1952  * Description:
1953  *
1954  * Arguments:
1955  *      vdc     - soft state pointer for this instance of the device driver.
1956  *      msgp    - received msg
1957  *
1958  * Return Code:
1959  *      0       - Success
1960  */
1961 static int
1962 vdc_handle_rdx(vdc_t *vdcp, vio_rdx_msg_t *msgp)
1963 {
1964         _NOTE(ARGUNUSED(vdcp))
1965         _NOTE(ARGUNUSED(msgp))
1966 
1967         ASSERT(msgp->tag.vio_msgtype == VIO_TYPE_CTRL);
1968         ASSERT(msgp->tag.vio_subtype == VIO_SUBTYPE_ACK);
1969         ASSERT(msgp->tag.vio_subtype_env == VIO_RDX);
1970 
1971         DMSG(vdcp, 1, "[%d] Got an RDX msg", vdcp->instance);
1972 
1973         return (0);
1974 }
1975 
1976 /*
1977  * Function:
1978  *      vdc_rdx_exchange()
1979  *
1980  * Description:
1981  *
1982  * Arguments:
1983  *      vdc     - soft state pointer for this instance of the device driver.
1984  *
1985  * Return Code:
1986  *      0       - Success
1987  */
1988 static int
1989 vdc_rdx_exchange(vdc_t *vdcp)
1990 {
1991         int status;
1992         vio_msg_t vio_msg;
1993 
1994         if (status = vdc_send_rdx(vdcp))
1995                 return (status);
1996 
1997         /* release lock and wait for response */
1998         mutex_exit(&vdcp->lock);
1999         status = vdc_wait_for_response(vdcp, &vio_msg);
2000         mutex_enter(&vdcp->lock);
2001         if (status) {
2002                 DMSG(vdcp, 0, "[%d] Failed waiting for RDX response, rv(%d)",
2003                     vdcp->instance, status);
2004                 return (status);
2005         }
2006 
2007         /* check type and sub_type ... */
2008         if (vio_msg.tag.vio_msgtype != VIO_TYPE_CTRL ||
2009             vio_msg.tag.vio_subtype != VIO_SUBTYPE_ACK) {
2010                 DMSG(vdcp, 0, "[%d] Invalid RDX response\n", vdcp->instance);
2011                 return (EPROTO);
2012         }
2013 
2014         return (vdc_handle_rdx(vdcp, (vio_rdx_msg_t *)&vio_msg));
2015 }
2016 
2017 
2018 /* -------------------------------------------------------------------------- */
2019 
2020 /*
2021  * LDC helper routines
2022  */
2023 
2024 static int
2025 vdc_recv(vdc_t *vdc, vio_msg_t *msgp, size_t *nbytesp)
2026 {
2027         int             status;
2028         uint64_t        delay_time;
2029         size_t          len;
2030 
2031         /*
2032          * Until we get a blocking ldc read we have to retry until the entire
2033          * LDC message has arrived before ldc_read() will return that message.
2034          * If ldc_read() succeed but returns a zero length message then that
2035          * means that the LDC queue is empty and we have to wait for a
2036          * notification from the LDC callback which will set the read_state to
2037          * VDC_READ_PENDING. Note we also bail out if the channel is reset or
2038          * goes away.
2039          */
2040         delay_time = vdc_ldc_read_init_delay;
2041 
2042         for (;;) {
2043 
2044                 len = *nbytesp;
2045                 /*
2046                  * vdc->curr_server is protected by vdc->lock but to avoid
2047                  * contentions we don't take the lock here. We can do this
2048                  * safely because vdc_recv() is only called from thread
2049                  * process_msg_thread() which is also the only thread that
2050                  * can change vdc->curr_server.
2051                  */
2052                 status = ldc_read(vdc->curr_server->ldc_handle,
2053                     (caddr_t)msgp, &len);
2054 
2055                 if (status == EAGAIN) {
2056                         delay_time *= 2;
2057                         if (delay_time >= vdc_ldc_read_max_delay)
2058                                 delay_time = vdc_ldc_read_max_delay;
2059                         delay(delay_time);
2060                         continue;
2061                 }
2062 
2063                 if (status != 0) {
2064                         DMSG(vdc, 0, "ldc_read returned %d\n", status);
2065                         break;
2066                 }
2067 
2068                 if (len != 0) {
2069                         *nbytesp = len;
2070                         break;
2071                 }
2072 
2073                 mutex_enter(&vdc->read_lock);
2074 
2075                 while (vdc->read_state != VDC_READ_PENDING) {
2076 
2077                         /* detect if the connection has been reset */
2078                         if (vdc->read_state == VDC_READ_RESET) {
2079                                 mutex_exit(&vdc->read_lock);
2080                                 return (ECONNRESET);
2081                         }
2082 
2083                         vdc->read_state = VDC_READ_WAITING;
2084                         cv_wait(&vdc->read_cv, &vdc->read_lock);
2085                 }
2086 
2087                 vdc->read_state = VDC_READ_IDLE;
2088                 mutex_exit(&vdc->read_lock);
2089 
2090                 delay_time = vdc_ldc_read_init_delay;
2091         }
2092 
2093         return (status);
2094 }
2095 
2096 
2097 
2098 #ifdef DEBUG
2099 void
2100 vdc_decode_tag(vdc_t *vdcp, vio_msg_t *msg)
2101 {
2102         char *ms, *ss, *ses;
2103         switch (msg->tag.vio_msgtype) {
2104 #define Q(_s)   case _s : ms = #_s; break;
2105         Q(VIO_TYPE_CTRL)
2106         Q(VIO_TYPE_DATA)
2107         Q(VIO_TYPE_ERR)
2108 #undef Q
2109         default: ms = "unknown"; break;
2110         }
2111 
2112         switch (msg->tag.vio_subtype) {
2113 #define Q(_s)   case _s : ss = #_s; break;
2114         Q(VIO_SUBTYPE_INFO)
2115         Q(VIO_SUBTYPE_ACK)
2116         Q(VIO_SUBTYPE_NACK)
2117 #undef Q
2118         default: ss = "unknown"; break;
2119         }
2120 
2121         switch (msg->tag.vio_subtype_env) {
2122 #define Q(_s)   case _s : ses = #_s; break;
2123         Q(VIO_VER_INFO)
2124         Q(VIO_ATTR_INFO)
2125         Q(VIO_DRING_REG)
2126         Q(VIO_DRING_UNREG)
2127         Q(VIO_RDX)
2128         Q(VIO_PKT_DATA)
2129         Q(VIO_DESC_DATA)
2130         Q(VIO_DRING_DATA)
2131 #undef Q
2132         default: ses = "unknown"; break;
2133         }
2134 
2135         DMSG(vdcp, 3, "(%x/%x/%x) message : (%s/%s/%s)\n",
2136             msg->tag.vio_msgtype, msg->tag.vio_subtype,
2137             msg->tag.vio_subtype_env, ms, ss, ses);
2138 }
2139 #endif
2140 
2141 /*
2142  * Function:
2143  *      vdc_send()
2144  *
2145  * Description:
2146  *      The function encapsulates the call to write a message using LDC.
2147  *      If LDC indicates that the call failed due to the queue being full,
2148  *      we retry the ldc_write(), otherwise we return the error returned by LDC.
2149  *
2150  * Arguments:
2151  *      ldc_handle      - LDC handle for the channel this instance of vdc uses
2152  *      pkt             - address of LDC message to be sent
2153  *      msglen          - the size of the message being sent. When the function
2154  *                        returns, this contains the number of bytes written.
2155  *
2156  * Return Code:
2157  *      0               - Success.
2158  *      EINVAL          - pkt or msglen were NULL
2159  *      ECONNRESET      - The connection was not up.
2160  *      EWOULDBLOCK     - LDC queue is full
2161  *      xxx             - other error codes returned by ldc_write
2162  */
2163 static int
2164 vdc_send(vdc_t *vdc, caddr_t pkt, size_t *msglen)
2165 {
2166         size_t  size = 0;
2167         int     status = 0;
2168         clock_t delay_ticks;
2169 
2170         ASSERT(vdc != NULL);
2171         ASSERT(mutex_owned(&vdc->lock));
2172         ASSERT(msglen != NULL);
2173         ASSERT(*msglen != 0);
2174 
2175 #ifdef DEBUG
2176         vdc_decode_tag(vdc, (vio_msg_t *)(uintptr_t)pkt);
2177 #endif
2178         /*
2179          * Wait indefinitely to send if channel
2180          * is busy, but bail out if we succeed or
2181          * if the channel closes or is reset.
2182          */
2183         delay_ticks = vdc_hz_min_ldc_delay;
2184         do {
2185                 size = *msglen;
2186                 status = ldc_write(vdc->curr_server->ldc_handle, pkt, &size);
2187                 if (status == EWOULDBLOCK) {
2188                         delay(delay_ticks);
2189                         /* geometric backoff */
2190                         delay_ticks *= 2;
2191                         if (delay_ticks > vdc_hz_max_ldc_delay)
2192                                 delay_ticks = vdc_hz_max_ldc_delay;
2193                 }
2194         } while (status == EWOULDBLOCK);
2195 
2196         /* if LDC had serious issues --- reset vdc state */
2197         if (status == EIO || status == ECONNRESET) {
2198                 /* LDC had serious issues --- reset vdc state */
2199                 mutex_enter(&vdc->read_lock);
2200                 if ((vdc->read_state == VDC_READ_WAITING) ||
2201                     (vdc->read_state == VDC_READ_RESET))
2202                         cv_signal(&vdc->read_cv);
2203                 vdc->read_state = VDC_READ_RESET;
2204                 mutex_exit(&vdc->read_lock);
2205 
2206                 /* wake up any waiters in the reset thread */
2207                 if (vdc->state == VDC_STATE_INIT_WAITING) {
2208                         DMSG(vdc, 0, "[%d] write reset - "
2209                             "vdc is resetting ..\n", vdc->instance);
2210                         vdc->state = VDC_STATE_RESETTING;
2211                         cv_signal(&vdc->initwait_cv);
2212                 }
2213 
2214                 return (ECONNRESET);
2215         }
2216 
2217         /* return the last size written */
2218         *msglen = size;
2219 
2220         return (status);
2221 }
2222 
2223 /*
2224  * Function:
2225  *      vdc_get_md_node
2226  *
2227  * Description:
2228  *      Get the MD, the device node for the given disk instance. The
2229  *      caller is responsible for cleaning up the reference to the
2230  *      returned MD (mdpp) by calling md_fini_handle().
2231  *
2232  * Arguments:
2233  *      dip     - dev info pointer for this instance of the device driver.
2234  *      mdpp    - the returned MD.
2235  *      vd_nodep - the returned device node.
2236  *
2237  * Return Code:
2238  *      0       - Success.
2239  *      ENOENT  - Expected node or property did not exist.
2240  *      ENXIO   - Unexpected error communicating with MD framework
2241  */
2242 static int
2243 vdc_get_md_node(dev_info_t *dip, md_t **mdpp, mde_cookie_t *vd_nodep)
2244 {
2245         int             status = ENOENT;
2246         char            *node_name = NULL;
2247         md_t            *mdp = NULL;
2248         int             num_nodes;
2249         int             num_vdevs;
2250         mde_cookie_t    rootnode;
2251         mde_cookie_t    *listp = NULL;
2252         boolean_t       found_inst = B_FALSE;
2253         int             listsz;
2254         int             idx;
2255         uint64_t        md_inst;
2256         int             obp_inst;
2257         int             instance = ddi_get_instance(dip);
2258 
2259         /*
2260          * Get the OBP instance number for comparison with the MD instance
2261          *
2262          * The "cfg-handle" property of a vdc node in an MD contains the MD's
2263          * notion of "instance", or unique identifier, for that node; OBP
2264          * stores the value of the "cfg-handle" MD property as the value of
2265          * the "reg" property on the node in the device tree it builds from
2266          * the MD and passes to Solaris.  Thus, we look up the devinfo node's
2267          * "reg" property value to uniquely identify this device instance.
2268          * If the "reg" property cannot be found, the device tree state is
2269          * presumably so broken that there is no point in continuing.
2270          */
2271         if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, OBP_REG)) {
2272                 cmn_err(CE_WARN, "'%s' property does not exist", OBP_REG);
2273                 return (ENOENT);
2274         }
2275         obp_inst = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
2276             OBP_REG, -1);
2277         DMSGX(1, "[%d] OBP inst=%d\n", instance, obp_inst);
2278 
2279         /*
2280          * We now walk the MD nodes to find the node for this vdisk.
2281          */
2282         if ((mdp = md_get_handle()) == NULL) {
2283                 cmn_err(CE_WARN, "unable to init machine description");
2284                 return (ENXIO);
2285         }
2286 
2287         num_nodes = md_node_count(mdp);
2288         ASSERT(num_nodes > 0);
2289 
2290         listsz = num_nodes * sizeof (mde_cookie_t);
2291 
2292         /* allocate memory for nodes */
2293         listp = kmem_zalloc(listsz, KM_SLEEP);
2294 
2295         rootnode = md_root_node(mdp);
2296         ASSERT(rootnode != MDE_INVAL_ELEM_COOKIE);
2297 
2298         /*
2299          * Search for all the virtual devices, we will then check to see which
2300          * ones are disk nodes.
2301          */
2302         num_vdevs = md_scan_dag(mdp, rootnode,
2303             md_find_name(mdp, VDC_MD_VDEV_NAME),
2304             md_find_name(mdp, "fwd"), listp);
2305 
2306         if (num_vdevs <= 0) {
2307                 cmn_err(CE_NOTE, "No '%s' node found", VDC_MD_VDEV_NAME);
2308                 status = ENOENT;
2309                 goto done;
2310         }
2311 
2312         DMSGX(1, "[%d] num_vdevs=%d\n", instance, num_vdevs);
2313         for (idx = 0; idx < num_vdevs; idx++) {
2314                 status = md_get_prop_str(mdp, listp[idx], "name", &node_name);
2315                 if ((status != 0) || (node_name == NULL)) {
2316                         cmn_err(CE_NOTE, "Unable to get name of node type '%s'"
2317                             ": err %d", VDC_MD_VDEV_NAME, status);
2318                         continue;
2319                 }
2320 
2321                 DMSGX(1, "[%d] Found node '%s'\n", instance, node_name);
2322                 if (strcmp(VDC_MD_DISK_NAME, node_name) == 0) {
2323                         status = md_get_prop_val(mdp, listp[idx],
2324                             VDC_MD_CFG_HDL, &md_inst);
2325                         DMSGX(1, "[%d] vdc inst in MD=%lx\n",
2326                             instance, md_inst);
2327                         if ((status == 0) && (md_inst == obp_inst)) {
2328                                 found_inst = B_TRUE;
2329                                 break;
2330                         }
2331                 }
2332         }
2333 
2334         if (!found_inst) {
2335                 DMSGX(0, "Unable to find correct '%s' node", VDC_MD_DISK_NAME);
2336                 status = ENOENT;
2337                 goto done;
2338         }
2339         DMSGX(0, "[%d] MD inst=%lx\n", instance, md_inst);
2340 
2341         *vd_nodep = listp[idx];
2342         *mdpp = mdp;
2343 done:
2344         kmem_free(listp, listsz);
2345         return (status);
2346 }
2347 
2348 /*
2349  * Function:
2350  *      vdc_init_ports
2351  *
2352  * Description:
2353  *      Initialize all the ports for this vdisk instance.
2354  *
2355  * Arguments:
2356  *      vdc     - soft state pointer for this instance of the device driver.
2357  *      mdp     - md pointer
2358  *      vd_nodep - device md node.
2359  *
2360  * Return Code:
2361  *      0       - Success.
2362  *      ENOENT  - Expected node or property did not exist.
2363  */
2364 static int
2365 vdc_init_ports(vdc_t *vdc, md_t *mdp, mde_cookie_t vd_nodep)
2366 {
2367         int             status = 0;
2368         int             idx;
2369         int             num_nodes;
2370         int             num_vports;
2371         int             num_chans;
2372         int             listsz;
2373         mde_cookie_t    vd_port;
2374         mde_cookie_t    *chanp = NULL;
2375         mde_cookie_t    *portp = NULL;
2376         vdc_server_t    *srvr;
2377         vdc_server_t    *prev_srvr = NULL;
2378 
2379         /*
2380          * We now walk the MD nodes to find the port nodes for this vdisk.
2381          */
2382         num_nodes = md_node_count(mdp);
2383         ASSERT(num_nodes > 0);
2384 
2385         listsz = num_nodes * sizeof (mde_cookie_t);
2386 
2387         /* allocate memory for nodes */
2388         portp = kmem_zalloc(listsz, KM_SLEEP);
2389         chanp = kmem_zalloc(listsz, KM_SLEEP);
2390 
2391         num_vports = md_scan_dag(mdp, vd_nodep,
2392             md_find_name(mdp, VDC_MD_PORT_NAME),
2393             md_find_name(mdp, "fwd"), portp);
2394         if (num_vports == 0) {
2395                 DMSGX(0, "Found no '%s' node for '%s' port\n",
2396                     VDC_MD_PORT_NAME, VDC_MD_VDEV_NAME);
2397                 status = ENOENT;
2398                 goto done;
2399         }
2400 
2401         DMSGX(1, "Found %d '%s' node(s) for '%s' port\n",
2402             num_vports, VDC_MD_PORT_NAME, VDC_MD_VDEV_NAME);
2403 
2404         vdc->num_servers = 0;
2405         for (idx = 0; idx < num_vports; idx++) {
2406 
2407                 /* initialize this port */
2408                 vd_port = portp[idx];
2409                 srvr = kmem_zalloc(sizeof (vdc_server_t), KM_SLEEP);
2410                 srvr->vdcp = vdc;
2411                 srvr->svc_state = VDC_SERVICE_OFFLINE;
2412                 srvr->log_state = VDC_SERVICE_NONE;
2413 
2414                 /* get port id */
2415                 if (md_get_prop_val(mdp, vd_port, VDC_MD_ID, &srvr->id) != 0) {
2416                         cmn_err(CE_NOTE, "vDisk port '%s' property not found",
2417                             VDC_MD_ID);
2418                         kmem_free(srvr, sizeof (vdc_server_t));
2419                         continue;
2420                 }
2421 
2422                 /* set the connection timeout */
2423                 if (md_get_prop_val(mdp, vd_port, VDC_MD_TIMEOUT,
2424                     &srvr->ctimeout) != 0) {
2425                         srvr->ctimeout = 0;
2426                 }
2427 
2428                 /* get the ldc id */
2429                 num_chans = md_scan_dag(mdp, vd_port,
2430                     md_find_name(mdp, VDC_MD_CHAN_NAME),
2431                     md_find_name(mdp, "fwd"), chanp);
2432 
2433                 /* expecting at least one channel */
2434                 if (num_chans <= 0) {
2435                         cmn_err(CE_NOTE, "No '%s' node for '%s' port",
2436                             VDC_MD_CHAN_NAME, VDC_MD_VDEV_NAME);
2437                         kmem_free(srvr, sizeof (vdc_server_t));
2438                         continue;
2439                 } else if (num_chans != 1) {
2440                         DMSGX(0, "Expected 1 '%s' node for '%s' port, "
2441                             "found %d\n", VDC_MD_CHAN_NAME, VDC_MD_VDEV_NAME,
2442                             num_chans);
2443                 }
2444 
2445                 /*
2446                  * We use the first channel found (index 0), irrespective of how
2447                  * many are there in total.
2448                  */
2449                 if (md_get_prop_val(mdp, chanp[0], VDC_MD_ID,
2450                     &srvr->ldc_id) != 0) {
2451                         cmn_err(CE_NOTE, "Channel '%s' property not found",
2452                             VDC_MD_ID);
2453                         kmem_free(srvr, sizeof (vdc_server_t));
2454                         continue;
2455                 }
2456 
2457                 /*
2458                  * now initialise LDC channel which will be used to
2459                  * communicate with this server
2460                  */
2461                 if (vdc_do_ldc_init(vdc, srvr) != 0) {
2462                         kmem_free(srvr, sizeof (vdc_server_t));
2463                         continue;
2464                 }
2465 
2466                 /* add server to list */
2467                 if (prev_srvr)
2468                         prev_srvr->next = srvr;
2469                 else
2470                         vdc->server_list = srvr;
2471 
2472                 prev_srvr = srvr;
2473 
2474                 /* inc numbers of servers */
2475                 vdc->num_servers++;
2476         }
2477 
2478         /* pick first server as current server */
2479         if (vdc->server_list != NULL) {
2480                 vdc->curr_server = vdc->server_list;
2481                 status = 0;
2482         } else {
2483                 status = ENOENT;
2484         }
2485 
2486 done:
2487         kmem_free(chanp, listsz);
2488         kmem_free(portp, listsz);
2489         return (status);
2490 }
2491 
2492 
2493 /*
2494  * Function:
2495  *      vdc_do_ldc_up
2496  *
2497  * Description:
2498  *      Bring the channel for the current server up.
2499  *
2500  * Arguments:
2501  *      vdc     - soft state pointer for this instance of the device driver.
2502  *
2503  * Return Code:
2504  *      0               - Success.
2505  *      EINVAL          - Driver is detaching / LDC error
2506  *      ECONNREFUSED    - Other end is not listening
2507  */
2508 static int
2509 vdc_do_ldc_up(vdc_t *vdc)
2510 {
2511         int             status;
2512         ldc_status_t    ldc_state;
2513 
2514         ASSERT(MUTEX_HELD(&vdc->lock));
2515 
2516         DMSG(vdc, 0, "[%d] Bringing up channel %lx\n",
2517             vdc->instance, vdc->curr_server->ldc_id);
2518 
2519         if (vdc->lifecycle == VDC_LC_DETACHING)
2520                 return (EINVAL);
2521 
2522         if ((status = ldc_up(vdc->curr_server->ldc_handle)) != 0) {
2523                 switch (status) {
2524                 case ECONNREFUSED:      /* listener not ready at other end */
2525                         DMSG(vdc, 0, "[%d] ldc_up(%lx,...) return %d\n",
2526                             vdc->instance, vdc->curr_server->ldc_id, status);
2527                         status = 0;
2528                         break;
2529                 default:
2530                         DMSG(vdc, 0, "[%d] Failed to bring up LDC: "
2531                             "channel=%ld, err=%d", vdc->instance,
2532                             vdc->curr_server->ldc_id, status);
2533                         break;
2534                 }
2535         }
2536 
2537         if (ldc_status(vdc->curr_server->ldc_handle, &ldc_state) == 0) {
2538                 vdc->curr_server->ldc_state = ldc_state;
2539                 if (ldc_state == LDC_UP) {
2540                         DMSG(vdc, 0, "[%d] LDC channel already up\n",
2541                             vdc->instance);
2542                         vdc->seq_num = 1;
2543                         vdc->seq_num_reply = 0;
2544                 }
2545         }
2546 
2547         return (status);
2548 }
2549 
2550 /*
2551  * Function:
2552  *      vdc_terminate_ldc()
2553  *
2554  * Description:
2555  *
2556  * Arguments:
2557  *      vdc     - soft state pointer for this instance of the device driver.
2558  *      srvr    - vdc per-server info structure
2559  *
2560  * Return Code:
2561  *      None
2562  */
2563 static void
2564 vdc_terminate_ldc(vdc_t *vdc, vdc_server_t *srvr)
2565 {
2566         int     instance = ddi_get_instance(vdc->dip);
2567 
2568         if (srvr->state & VDC_LDC_OPEN) {
2569                 DMSG(vdc, 0, "[%d] ldc_close()\n", instance);
2570                 (void) ldc_close(srvr->ldc_handle);
2571         }
2572         if (srvr->state & VDC_LDC_CB) {
2573                 DMSG(vdc, 0, "[%d] ldc_unreg_callback()\n", instance);
2574                 (void) ldc_unreg_callback(srvr->ldc_handle);
2575         }
2576         if (srvr->state & VDC_LDC_INIT) {
2577                 DMSG(vdc, 0, "[%d] ldc_fini()\n", instance);
2578                 (void) ldc_fini(srvr->ldc_handle);
2579                 srvr->ldc_handle = NULL;
2580         }
2581 
2582         srvr->state &= ~(VDC_LDC_INIT | VDC_LDC_CB | VDC_LDC_OPEN);
2583 }
2584 
2585 /*
2586  * Function:
2587  *      vdc_fini_ports()
2588  *
2589  * Description:
2590  *      Finalize all ports by closing the channel associated with each
2591  *      port and also freeing the server structure.
2592  *
2593  * Arguments:
2594  *      vdc     - soft state pointer for this instance of the device driver.
2595  *
2596  * Return Code:
2597  *      None
2598  */
2599 static void
2600 vdc_fini_ports(vdc_t *vdc)
2601 {
2602         int             instance = ddi_get_instance(vdc->dip);
2603         vdc_server_t    *srvr, *prev_srvr;
2604 
2605         ASSERT(vdc != NULL);
2606         ASSERT(mutex_owned(&vdc->lock));
2607 
2608         DMSG(vdc, 0, "[%d] initialized=%x\n", instance, vdc->initialized);
2609 
2610         srvr = vdc->server_list;
2611 
2612         while (srvr) {
2613 
2614                 vdc_terminate_ldc(vdc, srvr);
2615 
2616                 /* next server */
2617                 prev_srvr = srvr;
2618                 srvr = srvr->next;
2619 
2620                 /* free server */
2621                 kmem_free(prev_srvr, sizeof (vdc_server_t));
2622         }
2623 
2624         vdc->server_list = NULL;
2625         vdc->num_servers = 0;
2626 }
2627 
2628 /* -------------------------------------------------------------------------- */
2629 
2630 /*
2631  * Descriptor Ring helper routines
2632  */
2633 
2634 /*
2635  * Function:
2636  *      vdc_init_descriptor_ring()
2637  *
2638  * Description:
2639  *
2640  * Arguments:
2641  *      vdc     - soft state pointer for this instance of the device driver.
2642  *
2643  * Return Code:
2644  *      0       - Success
2645  */
2646 static int
2647 vdc_init_descriptor_ring(vdc_t *vdc)
2648 {
2649         vd_dring_entry_t        *dep = NULL;    /* DRing Entry pointer */
2650         int     status = 0;
2651         int     i;
2652 
2653         DMSG(vdc, 0, "[%d] initialized=%x\n", vdc->instance, vdc->initialized);
2654 
2655         ASSERT(vdc != NULL);
2656         ASSERT(mutex_owned(&vdc->lock));
2657 
2658         /* ensure we have enough room to store max sized block */
2659         ASSERT(maxphys <= VD_MAX_BLOCK_SIZE);
2660 
2661         if ((vdc->initialized & VDC_DRING_INIT) == 0) {
2662                 DMSG(vdc, 0, "[%d] ldc_mem_dring_create\n", vdc->instance);
2663                 /*
2664                  * Calculate the maximum block size we can transmit using one
2665                  * Descriptor Ring entry from the attributes returned by the
2666                  * vDisk server. This is subject to a minimum of 'maxphys'
2667                  * as we do not have the capability to split requests over
2668                  * multiple DRing entries.
2669                  */
2670                 if ((vdc->max_xfer_sz * vdc->vdisk_bsize) < maxphys) {
2671                         DMSG(vdc, 0, "[%d] using minimum DRing size\n",
2672                             vdc->instance);
2673                         vdc->dring_max_cookies = maxphys / PAGESIZE;
2674                 } else {
2675                         vdc->dring_max_cookies =
2676                             (vdc->max_xfer_sz * vdc->vdisk_bsize) / PAGESIZE;
2677                 }
2678                 vdc->dring_entry_size = (sizeof (vd_dring_entry_t) +
2679                     (sizeof (ldc_mem_cookie_t) *
2680                     (vdc->dring_max_cookies - 1)));
2681                 vdc->dring_len = VD_DRING_LEN;
2682 
2683                 status = ldc_mem_dring_create(vdc->dring_len,
2684                     vdc->dring_entry_size, &vdc->dring_hdl);
2685                 if ((vdc->dring_hdl == NULL) || (status != 0)) {
2686                         DMSG(vdc, 0, "[%d] Descriptor ring creation failed",
2687                             vdc->instance);
2688                         return (status);
2689                 }
2690                 vdc->initialized |= VDC_DRING_INIT;
2691         }
2692 
2693         if ((vdc->initialized & VDC_DRING_BOUND) == 0) {
2694                 DMSG(vdc, 0, "[%d] ldc_mem_dring_bind\n", vdc->instance);
2695                 vdc->dring_cookie =
2696                     kmem_zalloc(sizeof (ldc_mem_cookie_t), KM_SLEEP);
2697 
2698                 status = ldc_mem_dring_bind(vdc->curr_server->ldc_handle,
2699                     vdc->dring_hdl,
2700                     LDC_SHADOW_MAP|LDC_DIRECT_MAP, LDC_MEM_RW,
2701                     &vdc->dring_cookie[0],
2702                     &vdc->dring_cookie_count);
2703                 if (status != 0) {
2704                         DMSG(vdc, 0, "[%d] Failed to bind descriptor ring "
2705                             "(%lx) to channel (%lx) status=%d\n",
2706                             vdc->instance, vdc->dring_hdl,
2707                             vdc->curr_server->ldc_handle, status);
2708                         return (status);
2709                 }
2710                 ASSERT(vdc->dring_cookie_count == 1);
2711                 vdc->initialized |= VDC_DRING_BOUND;
2712         }
2713 
2714         status = ldc_mem_dring_info(vdc->dring_hdl, &vdc->dring_mem_info);
2715         if (status != 0) {
2716                 DMSG(vdc, 0,
2717                     "[%d] Failed to get info for descriptor ring (%lx)\n",
2718                     vdc->instance, vdc->dring_hdl);
2719                 return (status);
2720         }
2721 
2722         if ((vdc->initialized & VDC_DRING_LOCAL) == 0) {
2723                 DMSG(vdc, 0, "[%d] local dring\n", vdc->instance);
2724 
2725                 /* Allocate the local copy of this dring */
2726                 vdc->local_dring =
2727                     kmem_zalloc(vdc->dring_len * sizeof (vdc_local_desc_t),
2728                     KM_SLEEP);
2729                 vdc->initialized |= VDC_DRING_LOCAL;
2730         }
2731 
2732         /*
2733          * Mark all DRing entries as free and initialize the private
2734          * descriptor's memory handles. If any entry is initialized,
2735          * we need to free it later so we set the bit in 'initialized'
2736          * at the start.
2737          */
2738         vdc->initialized |= VDC_DRING_ENTRY;
2739         for (i = 0; i < vdc->dring_len; i++) {
2740                 dep = VDC_GET_DRING_ENTRY_PTR(vdc, i);
2741                 dep->hdr.dstate = VIO_DESC_FREE;
2742 
2743                 status = ldc_mem_alloc_handle(vdc->curr_server->ldc_handle,
2744                     &vdc->local_dring[i].desc_mhdl);
2745                 if (status != 0) {
2746                         DMSG(vdc, 0, "![%d] Failed to alloc mem handle for"
2747                             " descriptor %d", vdc->instance, i);
2748                         return (status);
2749                 }
2750                 vdc->local_dring[i].is_free = B_TRUE;
2751                 vdc->local_dring[i].dep = dep;
2752         }
2753 
2754         /* Initialize the starting index */
2755         vdc->dring_curr_idx = VDC_DRING_FIRST_ENTRY;
2756 
2757         return (status);
2758 }
2759 
2760 /*
2761  * Function:
2762  *      vdc_destroy_descriptor_ring()
2763  *
2764  * Description:
2765  *
2766  * Arguments:
2767  *      vdc     - soft state pointer for this instance of the device driver.
2768  *
2769  * Return Code:
2770  *      None
2771  */
2772 static void
2773 vdc_destroy_descriptor_ring(vdc_t *vdc)
2774 {
2775         vdc_local_desc_t        *ldep = NULL;   /* Local Dring Entry Pointer */
2776         ldc_mem_handle_t        mhdl = NULL;
2777         ldc_mem_info_t          minfo;
2778         int                     status = -1;
2779         int                     i;      /* loop */
2780 
2781         ASSERT(vdc != NULL);
2782         ASSERT(mutex_owned(&vdc->lock));
2783 
2784         DMSG(vdc, 0, "[%d] Entered\n", vdc->instance);
2785 
2786         if (vdc->initialized & VDC_DRING_ENTRY) {
2787                 DMSG(vdc, 0,
2788                     "[%d] Removing Local DRing entries\n", vdc->instance);
2789                 for (i = 0; i < vdc->dring_len; i++) {
2790                         ldep = &vdc->local_dring[i];
2791                         mhdl = ldep->desc_mhdl;
2792 
2793                         if (mhdl == NULL)
2794                                 continue;
2795 
2796                         if ((status = ldc_mem_info(mhdl, &minfo)) != 0) {
2797                                 DMSG(vdc, 0,
2798                                     "ldc_mem_info returned an error: %d\n",
2799                                     status);
2800 
2801                                 /*
2802                                  * This must mean that the mem handle
2803                                  * is not valid. Clear it out so that
2804                                  * no one tries to use it.
2805                                  */
2806                                 ldep->desc_mhdl = NULL;
2807                                 continue;
2808                         }
2809 
2810                         if (minfo.status == LDC_BOUND) {
2811                                 (void) ldc_mem_unbind_handle(mhdl);
2812                         }
2813 
2814                         (void) ldc_mem_free_handle(mhdl);
2815 
2816                         ldep->desc_mhdl = NULL;
2817                 }
2818                 vdc->initialized &= ~VDC_DRING_ENTRY;
2819         }
2820 
2821         if (vdc->initialized & VDC_DRING_LOCAL) {
2822                 DMSG(vdc, 0, "[%d] Freeing Local DRing\n", vdc->instance);
2823                 kmem_free(vdc->local_dring,
2824                     vdc->dring_len * sizeof (vdc_local_desc_t));
2825                 vdc->initialized &= ~VDC_DRING_LOCAL;
2826         }
2827 
2828         if (vdc->initialized & VDC_DRING_BOUND) {
2829                 DMSG(vdc, 0, "[%d] Unbinding DRing\n", vdc->instance);
2830                 status = ldc_mem_dring_unbind(vdc->dring_hdl);
2831                 if (status == 0) {
2832                         vdc->initialized &= ~VDC_DRING_BOUND;
2833                 } else {
2834                         DMSG(vdc, 0, "[%d] Error %d unbinding DRing %lx",
2835                             vdc->instance, status, vdc->dring_hdl);
2836                 }
2837                 kmem_free(vdc->dring_cookie, sizeof (ldc_mem_cookie_t));
2838         }
2839 
2840         if (vdc->initialized & VDC_DRING_INIT) {
2841                 DMSG(vdc, 0, "[%d] Destroying DRing\n", vdc->instance);
2842                 status = ldc_mem_dring_destroy(vdc->dring_hdl);
2843                 if (status == 0) {
2844                         vdc->dring_hdl = NULL;
2845                         bzero(&vdc->dring_mem_info, sizeof (ldc_mem_info_t));
2846                         vdc->initialized &= ~VDC_DRING_INIT;
2847                 } else {
2848                         DMSG(vdc, 0, "[%d] Error %d destroying DRing (%lx)",
2849                             vdc->instance, status, vdc->dring_hdl);
2850                 }
2851         }
2852 }
2853 
2854 /*
2855  * Function:
2856  *      vdc_map_to_shared_dring()
2857  *
2858  * Description:
2859  *      Copy contents of the local descriptor to the shared
2860  *      memory descriptor.
2861  *
2862  * Arguments:
2863  *      vdcp    - soft state pointer for this instance of the device driver.
2864  *      idx     - descriptor ring index
2865  *
2866  * Return Code:
2867  *      None
2868  */
2869 static int
2870 vdc_map_to_shared_dring(vdc_t *vdcp, int idx)
2871 {
2872         vdc_local_desc_t        *ldep;
2873         vd_dring_entry_t        *dep;
2874         int                     rv;
2875 
2876         ldep = &(vdcp->local_dring[idx]);
2877 
2878         /* for now leave in the old pop_mem_hdl stuff */
2879         if (ldep->nbytes > 0) {
2880                 rv = vdc_populate_mem_hdl(vdcp, ldep);
2881                 if (rv) {
2882                         DMSG(vdcp, 0, "[%d] Cannot populate mem handle\n",
2883                             vdcp->instance);
2884                         return (rv);
2885                 }
2886         }
2887 
2888         /*
2889          * fill in the data details into the DRing
2890          */
2891         dep = ldep->dep;
2892         ASSERT(dep != NULL);
2893 
2894         dep->payload.req_id = VDC_GET_NEXT_REQ_ID(vdcp);
2895         dep->payload.operation = ldep->operation;
2896         dep->payload.addr = ldep->offset;
2897         dep->payload.nbytes = ldep->nbytes;
2898         dep->payload.status = (uint32_t)-1;  /* vds will set valid value */
2899         dep->payload.slice = ldep->slice;
2900         dep->hdr.dstate = VIO_DESC_READY;
2901         dep->hdr.ack = 1;            /* request an ACK for every message */
2902 
2903         return (0);
2904 }
2905 
2906 /*
2907  * Function:
2908  *      vdc_send_request
2909  *
2910  * Description:
2911  *      This routine writes the data to be transmitted to vds into the
2912  *      descriptor, notifies vds that the ring has been updated and
2913  *      then waits for the request to be processed.
2914  *
2915  * Arguments:
2916  *      vdcp      - the soft state pointer
2917  *      operation - operation we want vds to perform (VD_OP_XXX)
2918  *      addr      - address of data buf to be read/written.
2919  *      nbytes    - number of bytes to read/write
2920  *      slice     - the disk slice this request is for
2921  *      offset    - relative disk offset
2922  *      bufp      - buf of operation
2923  *      dir       - direction of operation (READ/WRITE/BOTH)
2924  *
2925  * Return Codes:
2926  *      0
2927  *      ENXIO
2928  */
2929 static int
2930 vdc_send_request(vdc_t *vdcp, int operation, caddr_t addr,
2931     size_t nbytes, int slice, diskaddr_t offset, buf_t *bufp,
2932     vio_desc_direction_t dir, int flags)
2933 {
2934         int     rv = 0;
2935 
2936         ASSERT(vdcp != NULL);
2937         ASSERT(slice == VD_SLICE_NONE || slice < V_NUMPAR);
2938 
2939         mutex_enter(&vdcp->lock);
2940 
2941         /*
2942          * If this is a block read/write operation we update the I/O statistics
2943          * to indicate that the request is being put on the waitq to be
2944          * serviced. Operations which are resubmitted are already in the waitq.
2945          *
2946          * We do it here (a common routine for both synchronous and strategy
2947          * calls) for performance reasons - we are already holding vdc->lock
2948          * so there is no extra locking overhead. We would have to explicitly
2949          * grab the 'lock' mutex to update the stats if we were to do this
2950          * higher up the stack in vdc_strategy() et. al.
2951          */
2952         if (((operation == VD_OP_BREAD) || (operation == VD_OP_BWRITE)) &&
2953             !(flags & VDC_OP_RESUBMIT)) {
2954                 DTRACE_IO1(start, buf_t *, bufp);
2955                 VD_KSTAT_WAITQ_ENTER(vdcp);
2956         }
2957 
2958         /*
2959          * If the request does not expect the state to be VDC_STATE_RUNNING
2960          * then we just try to populate the descriptor ring once.
2961          */
2962         if (!(flags & VDC_OP_STATE_RUNNING)) {
2963                 rv = vdc_populate_descriptor(vdcp, operation, addr,
2964                     nbytes, slice, offset, bufp, dir, flags);
2965                 goto done;
2966         }
2967 
2968         do {
2969                 while (vdcp->state != VDC_STATE_RUNNING) {
2970 
2971                         /* return error if detaching */
2972                         if (vdcp->state == VDC_STATE_DETACH) {
2973                                 rv = ENXIO;
2974                                 goto done;
2975                         }
2976 
2977                         /*
2978                          * If we are panicking and the disk is not ready then
2979                          * we can't send any request because we can't complete
2980                          * the handshake now.
2981                          */
2982                         if (ddi_in_panic()) {
2983                                 rv = EIO;
2984                                 goto done;
2985                         }
2986 
2987                         /*
2988                          * If the state is faulted, notify that a new I/O is
2989                          * being submitted to force the system to check if any
2990                          * server has recovered.
2991                          */
2992                         if (vdcp->state == VDC_STATE_FAILED) {
2993                                 vdcp->io_pending = B_TRUE;
2994                                 cv_signal(&vdcp->io_pending_cv);
2995                         }
2996 
2997                         cv_wait(&vdcp->running_cv, &vdcp->lock);
2998 
2999                         /* if service is still faulted then fail the request */
3000                         if (vdcp->state == VDC_STATE_FAILED) {
3001                                 rv = EIO;
3002                                 goto done;
3003                         }
3004                 }
3005 
3006         } while (vdc_populate_descriptor(vdcp, operation, addr,
3007             nbytes, slice, offset, bufp, dir, flags & ~VDC_OP_RESUBMIT));
3008 
3009 done:
3010         /*
3011          * If this is a block read/write we update the I/O statistics kstat
3012          * to indicate that this request has been placed on the queue for
3013          * processing (i.e sent to the vDisk server) - iostat(1M) will
3014          * report the time waiting for the vDisk server under the %b column
3015          *
3016          * In the case of an error we take it off the wait queue only if
3017          * the I/O was not resubmited.
3018          */
3019         if ((operation == VD_OP_BREAD) || (operation == VD_OP_BWRITE)) {
3020                 if (rv == 0) {
3021                         VD_KSTAT_WAITQ_TO_RUNQ(vdcp);
3022                         DTRACE_PROBE1(send, buf_t *, bufp);
3023                 } else {
3024                         VD_UPDATE_ERR_STATS(vdcp, vd_transerrs);
3025                         if (!(flags & VDC_OP_RESUBMIT)) {
3026                                 VD_KSTAT_WAITQ_EXIT(vdcp);
3027                                 DTRACE_IO1(done, buf_t *, bufp);
3028                         }
3029                 }
3030         }
3031 
3032         mutex_exit(&vdcp->lock);
3033 
3034         return (rv);
3035 }
3036 
3037 
3038 /*
3039  * Function:
3040  *      vdc_populate_descriptor
3041  *
3042  * Description:
3043  *      This routine writes the data to be transmitted to vds into the
3044  *      descriptor, notifies vds that the ring has been updated and
3045  *      then waits for the request to be processed.
3046  *
3047  * Arguments:
3048  *      vdcp      - the soft state pointer
3049  *      operation - operation we want vds to perform (VD_OP_XXX)
3050  *      addr      - address of data buf to be read/written.
3051  *      nbytes    - number of bytes to read/write
3052  *      slice     - the disk slice this request is for
3053  *      offset    - relative disk offset
3054  *      bufp      - buf of operation
3055  *      dir       - direction of operation (READ/WRITE/BOTH)
3056  *
3057  * Return Codes:
3058  *      0
3059  *      EAGAIN
3060  *      ECONNRESET
3061  *      ENXIO
3062  */
3063 static int
3064 vdc_populate_descriptor(vdc_t *vdcp, int operation, caddr_t addr,
3065     size_t nbytes, int slice, diskaddr_t offset,
3066     buf_t *bufp, vio_desc_direction_t dir, int flags)
3067 {
3068         vdc_local_desc_t        *local_dep = NULL; /* Local Dring Pointer */
3069         int                     idx;            /* Index of DRing entry used */
3070         int                     next_idx;
3071         vio_dring_msg_t         dmsg;
3072         size_t                  msglen;
3073         int                     rv;
3074 
3075         ASSERT(MUTEX_HELD(&vdcp->lock));
3076         vdcp->threads_pending++;
3077 loop:
3078         DMSG(vdcp, 2, ": dring_curr_idx = %d\n", vdcp->dring_curr_idx);
3079 
3080         if (flags & VDC_OP_DRING_RESERVED) {
3081                 /* use D-Ring reserved entry */
3082                 idx = VDC_DRING_FIRST_RESV;
3083                 local_dep = &(vdcp->local_dring[idx]);
3084         } else {
3085                 /* Get next available D-Ring entry */
3086                 idx = vdcp->dring_curr_idx;
3087                 local_dep = &(vdcp->local_dring[idx]);
3088 
3089                 if (!local_dep->is_free) {
3090                         DMSG(vdcp, 2, "[%d]: dring full - waiting for space\n",
3091                             vdcp->instance);
3092                         cv_wait(&vdcp->dring_free_cv, &vdcp->lock);
3093                         if (vdcp->state == VDC_STATE_RUNNING ||
3094                             vdcp->state == VDC_STATE_HANDLE_PENDING) {
3095                                 goto loop;
3096                         }
3097                         vdcp->threads_pending--;
3098                         return (ECONNRESET);
3099                 }
3100 
3101                 next_idx = idx + 1;
3102                 if (next_idx >= vdcp->dring_len)
3103                         next_idx = VDC_DRING_FIRST_ENTRY;
3104                 vdcp->dring_curr_idx = next_idx;
3105         }
3106 
3107         ASSERT(local_dep->is_free);
3108 
3109         local_dep->operation = operation;
3110         local_dep->addr = addr;
3111         local_dep->nbytes = nbytes;
3112         local_dep->slice = slice;
3113         local_dep->offset = offset;
3114         local_dep->buf = bufp;
3115         local_dep->dir = dir;
3116         local_dep->flags = flags;
3117 
3118         local_dep->is_free = B_FALSE;
3119 
3120         rv = vdc_map_to_shared_dring(vdcp, idx);
3121         if (rv) {
3122                 if (flags & VDC_OP_DRING_RESERVED) {
3123                         DMSG(vdcp, 0, "[%d]: cannot bind memory - error\n",
3124                             vdcp->instance);
3125                         /*
3126                          * We can't wait if we are using reserved slot.
3127                          * Free the descriptor and return.
3128                          */
3129                         local_dep->is_free = B_TRUE;
3130                         vdcp->threads_pending--;
3131                         return (rv);
3132                 }
3133                 DMSG(vdcp, 0, "[%d]: cannot bind memory - waiting ..\n",
3134                     vdcp->instance);
3135                 /* free the descriptor */
3136                 local_dep->is_free = B_TRUE;
3137                 vdcp->dring_curr_idx = idx;
3138                 cv_wait(&vdcp->membind_cv, &vdcp->lock);
3139                 if (vdcp->state == VDC_STATE_RUNNING ||
3140                     vdcp->state == VDC_STATE_HANDLE_PENDING) {
3141                         goto loop;
3142                 }
3143                 vdcp->threads_pending--;
3144                 return (ECONNRESET);
3145         }
3146 
3147         /*
3148          * Send a msg with the DRing details to vds
3149          */
3150         VIO_INIT_DRING_DATA_TAG(dmsg);
3151         VDC_INIT_DRING_DATA_MSG_IDS(dmsg, vdcp);
3152         dmsg.dring_ident = vdcp->dring_ident;
3153         dmsg.start_idx = idx;
3154         dmsg.end_idx = idx;
3155         vdcp->seq_num++;
3156 
3157         DTRACE_PROBE2(populate, int, vdcp->instance,
3158             vdc_local_desc_t *, local_dep);
3159         DMSG(vdcp, 2, "ident=0x%lx, st=%u, end=%u, seq=%ld\n",
3160             vdcp->dring_ident, dmsg.start_idx, dmsg.end_idx, dmsg.seq_num);
3161 
3162         /*
3163          * note we're still holding the lock here to
3164          * make sure the message goes out in order !!!...
3165          */
3166         msglen = sizeof (dmsg);
3167         rv = vdc_send(vdcp, (caddr_t)&dmsg, &msglen);
3168         switch (rv) {
3169         case ECONNRESET:
3170                 /*
3171                  * vdc_send initiates the reset on failure.
3172                  * Since the transaction has already been put
3173                  * on the local dring, it will automatically get
3174                  * retried when the channel is reset. Given that,
3175                  * it is ok to just return success even though the
3176                  * send failed.
3177                  */
3178                 rv = 0;
3179                 break;
3180 
3181         case 0: /* EOK */
3182                 DMSG(vdcp, 1, "sent via LDC: rv=%d\n", rv);
3183                 break;
3184 
3185         default:
3186                 DMSG(vdcp, 0, "unexpected error, rv=%d\n", rv);
3187                 rv = ENXIO;
3188                 break;
3189         }
3190 
3191         vdcp->threads_pending--;
3192         return (rv);
3193 }
3194 
3195 /*
3196  * Function:
3197  *      vdc_do_op
3198  *
3199  * Description:
3200  *      Wrapper around vdc_submit_request(). Each request is associated with a
3201  *      buf structure. If a buf structure is provided (bufp != NULL) then the
3202  *      request will be submitted with that buf, and the caller can wait for
3203  *      completion of the request with biowait(). If a buf structure is not
3204  *      provided (bufp == NULL) then a buf structure is created and the function
3205  *      waits for the completion of the request.
3206  *
3207  *      If the flag VD_OP_STATE_RUNNING is set then vdc_submit_request() will
3208  *      submit the request only when the vdisk is in state VD_STATE_RUNNING.
3209  *      If the vdisk is not in that state then the vdc_submit_request() will
3210  *      wait for that state to be reached. After the request is submitted, the
3211  *      reply will be processed asynchronously by the vdc_process_msg_thread()
3212  *      thread.
3213  *
3214  *      If the flag VD_OP_STATE_RUNNING is not set then vdc_submit_request()
3215  *      submit the request whatever the state of the vdisk is. Then vdc_do_op()
3216  *      will wait for a reply message, process the reply and complete the
3217  *      request.
3218  *
3219  * Arguments:
3220  *      vdc     - the soft state pointer
3221  *      op      - operation we want vds to perform (VD_OP_XXX)
3222  *      addr    - address of data buf to be read/written.
3223  *      nbytes  - number of bytes to read/write
3224  *      slice   - the disk slice this request is for
3225  *      offset  - relative disk offset
3226  *      bufp    - buf structure associated with the request (can be NULL).
3227  *      dir     - direction of operation (READ/WRITE/BOTH)
3228  *      flags   - flags for the request.
3229  *
3230  * Return Codes:
3231  *      0       - the request has been succesfully submitted and completed.
3232  *      != 0    - the request has failed. In that case, if a buf structure
3233  *                was provided (bufp != NULL) then the B_ERROR flag is set
3234  *                and the b_error field of the buf structure is set to EIO.
3235  */
3236 static int
3237 vdc_do_op(vdc_t *vdc, int op, caddr_t addr, size_t nbytes, int slice,
3238     diskaddr_t offset, struct buf *bufp, vio_desc_direction_t dir, int flags)
3239 {
3240         vio_msg_t vio_msg;
3241         struct buf buf;
3242         int rv;
3243 
3244         if (bufp == NULL) {
3245                 /*
3246                  * We use buf just as a convenient way to get a notification
3247                  * that the request is completed, so we initialize buf to the
3248                  * minimum we need.
3249                  */
3250                 bioinit(&buf);
3251                 buf.b_bcount = nbytes;
3252                 buf.b_flags = B_BUSY;
3253                 bufp = &buf;
3254         }
3255 
3256         rv = vdc_send_request(vdc, op, addr, nbytes, slice, offset, bufp,
3257             dir, flags);
3258 
3259         if (rv != 0)
3260                 goto done;
3261 
3262         /*
3263          * If the request should be done in VDC_STATE_RUNNING state then the
3264          * reply will be received and processed by vdc_process_msg_thread()
3265          * and we just have to handle the panic case. Otherwise we have to
3266          * wait for the reply message and process it.
3267          */
3268         if (flags & VDC_OP_STATE_RUNNING) {
3269 
3270                 if (ddi_in_panic()) {
3271                         rv = vdc_drain_response(vdc, bufp);
3272                         goto done;
3273                 }
3274 
3275         } else {
3276                 /* wait for the response message */
3277                 rv = vdc_wait_for_response(vdc, &vio_msg);
3278 
3279                 if (rv == 0)
3280                         rv = vdc_process_data_msg(vdc, &vio_msg);
3281 
3282                 if (rv) {
3283                         /*
3284                          * If this is a block read/write we update the I/O
3285                          * statistics kstat to take it off the run queue.
3286                          * If it is a resubmit then it needs to stay in
3287                          * in the waitq, and it will be removed when the
3288                          * I/O is eventually completed or cancelled.
3289                          */
3290                         mutex_enter(&vdc->lock);
3291                         if (op == VD_OP_BREAD || op == VD_OP_BWRITE) {
3292                                 if (flags & VDC_OP_RESUBMIT) {
3293                                         VD_KSTAT_RUNQ_BACK_TO_WAITQ(vdc);
3294                                 } else {
3295                                         VD_KSTAT_RUNQ_EXIT(vdc);
3296                                         DTRACE_IO1(done, buf_t *, bufp);
3297                                 }
3298                         }
3299                         mutex_exit(&vdc->lock);
3300                         goto done;
3301                 }
3302 
3303         }
3304 
3305         if (bufp == &buf)
3306                 rv = biowait(bufp);
3307 
3308 done:
3309         if (bufp == &buf) {
3310                 biofini(bufp);
3311         } else if (rv != 0) {
3312                 bioerror(bufp, EIO);
3313                 biodone(bufp);
3314         }
3315 
3316         return (rv);
3317 }
3318 
3319 /*
3320  * Function:
3321  *      vdc_do_sync_op
3322  *
3323  * Description:
3324  *      Wrapper around vdc_do_op that serializes requests.
3325  *
3326  * Arguments:
3327  *      vdcp      - the soft state pointer
3328  *      operation - operation we want vds to perform (VD_OP_XXX)
3329  *      addr      - address of data buf to be read/written.
3330  *      nbytes    - number of bytes to read/write
3331  *      slice     - the disk slice this request is for
3332  *      offset    - relative disk offset
3333  *      dir       - direction of operation (READ/WRITE/BOTH)
3334  *      rconflict - check for reservation conflict in case of failure
3335  *
3336  * rconflict should be set to B_TRUE by most callers. Callers invoking the
3337  * VD_OP_SCSICMD operation can set rconflict to B_FALSE if they check the
3338  * result of a successful operation with vdc_scsi_status().
3339  *
3340  * Return Codes:
3341  *      0
3342  *      EAGAIN
3343  *      EFAULT
3344  *      ENXIO
3345  *      EIO
3346  */
3347 static int
3348 vdc_do_sync_op(vdc_t *vdcp, int operation, caddr_t addr, size_t nbytes,
3349     int slice, diskaddr_t offset, vio_desc_direction_t dir, boolean_t rconflict)
3350 {
3351         int status;
3352         int flags = VDC_OP_NORMAL;
3353 
3354         /*
3355          * Grab the lock, if blocked wait until the server
3356          * response causes us to wake up again.
3357          */
3358         mutex_enter(&vdcp->lock);
3359         vdcp->sync_op_cnt++;
3360         while (vdcp->sync_op_blocked && vdcp->state != VDC_STATE_DETACH) {
3361                 if (ddi_in_panic()) {
3362                         /* don't block if we are panicking */
3363                         vdcp->sync_op_cnt--;
3364                         mutex_exit(&vdcp->lock);
3365                         return (EIO);
3366                 } else {
3367                         cv_wait(&vdcp->sync_blocked_cv, &vdcp->lock);
3368                 }
3369         }
3370 
3371         if (vdcp->state == VDC_STATE_DETACH) {
3372                 cv_broadcast(&vdcp->sync_blocked_cv);
3373                 vdcp->sync_op_cnt--;
3374                 mutex_exit(&vdcp->lock);
3375                 return (ENXIO);
3376         }
3377 
3378         /* now block anyone other thread entering after us */
3379         vdcp->sync_op_blocked = B_TRUE;
3380 
3381         mutex_exit(&vdcp->lock);
3382 
3383         if (!rconflict)
3384                 flags &= ~VDC_OP_ERRCHK_CONFLICT;
3385 
3386         status = vdc_do_op(vdcp, operation, addr, nbytes, slice, offset,
3387             NULL, dir, flags);
3388 
3389         mutex_enter(&vdcp->lock);
3390 
3391         DMSG(vdcp, 2, ": operation returned %d\n", status);
3392 
3393         if (vdcp->state == VDC_STATE_DETACH) {
3394                 status = ENXIO;
3395         }
3396 
3397         vdcp->sync_op_blocked = B_FALSE;
3398         vdcp->sync_op_cnt--;
3399 
3400         /* signal the next waiting thread */
3401         cv_signal(&vdcp->sync_blocked_cv);
3402 
3403         mutex_exit(&vdcp->lock);
3404 
3405         return (status);
3406 }
3407 
3408 
3409 /*
3410  * Function:
3411  *      vdc_drain_response()
3412  *
3413  * Description:
3414  *      When a guest is panicking, the completion of requests needs to be
3415  *      handled differently because interrupts are disabled and vdc
3416  *      will not get messages. We have to poll for the messages instead.
3417  *
3418  *      Note: since we are panicking we don't implement the io:::done
3419  *      DTrace probe or update the I/O statistics kstats.
3420  *
3421  * Arguments:
3422  *      vdc     - soft state pointer for this instance of the device driver.
3423  *      buf     - if buf is NULL then we drain all responses, otherwise we
3424  *                poll until we receive a ACK/NACK for the specific I/O
3425  *                described by buf.
3426  *
3427  * Return Code:
3428  *      0       - Success. If we were expecting a response to a particular
3429  *                request then this means that a response has been received.
3430  */
3431 static int
3432 vdc_drain_response(vdc_t *vdc, struct buf *buf)
3433 {
3434         int                     rv, idx, retries;
3435         size_t                  msglen;
3436         vdc_local_desc_t        *ldep = NULL;   /* Local Dring Entry Pointer */
3437         vio_dring_msg_t         dmsg;
3438         struct buf              *mbuf;
3439         boolean_t               ack;
3440 
3441         mutex_enter(&vdc->lock);
3442 
3443         retries = 0;
3444         for (;;) {
3445                 msglen = sizeof (dmsg);
3446                 rv = ldc_read(vdc->curr_server->ldc_handle, (caddr_t)&dmsg,
3447                     &msglen);
3448                 if (rv) {
3449                         rv = EINVAL;
3450                         break;
3451                 }
3452 
3453                 /*
3454                  * if there are no packets wait and check again
3455                  */
3456                 if ((rv == 0) && (msglen == 0)) {
3457                         if (retries++ > vdc_dump_retries) {
3458                                 rv = EAGAIN;
3459                                 break;
3460                         }
3461 
3462                         drv_usecwait(vdc_usec_timeout_dump);
3463                         continue;
3464                 }
3465 
3466                 /*
3467                  * Ignore all messages that are not ACKs/NACKs to
3468                  * DRing requests.
3469                  */
3470                 if ((dmsg.tag.vio_msgtype != VIO_TYPE_DATA) ||
3471                     (dmsg.tag.vio_subtype_env != VIO_DRING_DATA)) {
3472                         DMSG(vdc, 0, "discard pkt: type=%d sub=%d env=%d\n",
3473                             dmsg.tag.vio_msgtype,
3474                             dmsg.tag.vio_subtype,
3475                             dmsg.tag.vio_subtype_env);
3476                         continue;
3477                 }
3478 
3479                 /*
3480                  * Record if the packet was ACK'ed or not. If the packet was not
3481                  * ACK'ed then we will just mark the request as failed; we don't
3482                  * want to reset the connection at this point.
3483                  */
3484                 switch (dmsg.tag.vio_subtype) {
3485                 case VIO_SUBTYPE_ACK:
3486                         ack = B_TRUE;
3487                         break;
3488                 case VIO_SUBTYPE_NACK:
3489                         ack = B_FALSE;
3490                         break;
3491                 default:
3492                         continue;
3493                 }
3494 
3495                 idx = dmsg.start_idx;
3496                 if (idx >= vdc->dring_len) {
3497                         DMSG(vdc, 0, "[%d] Bogus ack data : start %d\n",
3498                             vdc->instance, idx);
3499                         continue;
3500                 }
3501                 ldep = &vdc->local_dring[idx];
3502                 if (ldep->dep->hdr.dstate != VIO_DESC_DONE) {
3503                         DMSG(vdc, 0, "[%d] Entry @ %d - state !DONE %d\n",
3504                             vdc->instance, idx, ldep->dep->hdr.dstate);
3505                         continue;
3506                 }
3507 
3508                 mbuf = ldep->buf;
3509                 ASSERT(mbuf != NULL);
3510                 mbuf->b_resid = mbuf->b_bcount - ldep->dep->payload.nbytes;
3511                 bioerror(mbuf, ack ? ldep->dep->payload.status : EIO);
3512                 biodone(mbuf);
3513 
3514                 rv = vdc_depopulate_descriptor(vdc, idx);
3515                 if (buf != NULL && buf == mbuf) {
3516                         rv = 0;
3517                         goto done;
3518                 }
3519 
3520                 /* if this is the last descriptor - break out of loop */
3521                 if ((idx + 1) % vdc->dring_len == vdc->dring_curr_idx) {
3522                         /*
3523                          * If we were expecting a response for a particular
3524                          * request then we return with an error otherwise we
3525                          * have successfully completed the drain.
3526                          */
3527                         rv = (buf != NULL)? ESRCH: 0;
3528                         break;
3529                 }
3530         }
3531 
3532 done:
3533         mutex_exit(&vdc->lock);
3534         DMSG(vdc, 0, "End idx=%d\n", idx);
3535 
3536         return (rv);
3537 }
3538 
3539 
3540 /*
3541  * Function:
3542  *      vdc_depopulate_descriptor()
3543  *
3544  * Description:
3545  *
3546  * Arguments:
3547  *      vdc     - soft state pointer for this instance of the device driver.
3548  *      idx     - Index of the Descriptor Ring entry being modified
3549  *
3550  * Return Code:
3551  *      0       - Success
3552  */
3553 static int
3554 vdc_depopulate_descriptor(vdc_t *vdc, uint_t idx)
3555 {
3556         vd_dring_entry_t *dep = NULL;           /* Dring Entry Pointer */
3557         vdc_local_desc_t *ldep = NULL;          /* Local Dring Entry Pointer */
3558         int             status = ENXIO;
3559         int             rv = 0;
3560 
3561         ASSERT(vdc != NULL);
3562         ASSERT(idx < vdc->dring_len);
3563         ldep = &vdc->local_dring[idx];
3564         ASSERT(ldep != NULL);
3565         ASSERT(MUTEX_HELD(&vdc->lock));
3566 
3567         DTRACE_PROBE2(depopulate, int, vdc->instance, vdc_local_desc_t *, ldep);
3568         DMSG(vdc, 2, ": idx = %d\n", idx);
3569 
3570         dep = ldep->dep;
3571         ASSERT(dep != NULL);
3572         ASSERT((dep->hdr.dstate == VIO_DESC_DONE) ||
3573             (dep->payload.status == ECANCELED));
3574 
3575         VDC_MARK_DRING_ENTRY_FREE(vdc, idx);
3576 
3577         ldep->is_free = B_TRUE;
3578         status = dep->payload.status;
3579         DMSG(vdc, 2, ": is_free = %d : status = %d\n", ldep->is_free, status);
3580 
3581         /*
3582          * If no buffers were used to transfer information to the server when
3583          * populating the descriptor then no memory handles need to be unbound
3584          * and we can return now.
3585          */
3586         if (ldep->nbytes == 0) {
3587                 cv_signal(&vdc->dring_free_cv);
3588                 return (status);
3589         }
3590 
3591         /*
3592          * If the upper layer passed in a misaligned address we copied the
3593          * data into an aligned buffer before sending it to LDC - we now
3594          * copy it back to the original buffer.
3595          */
3596         if (ldep->align_addr) {
3597                 ASSERT(ldep->addr != NULL);
3598 
3599                 if (dep->payload.nbytes > 0)
3600                         bcopy(ldep->align_addr, ldep->addr,
3601                             dep->payload.nbytes);
3602                 kmem_free(ldep->align_addr,
3603                     sizeof (caddr_t) * P2ROUNDUP(ldep->nbytes, 8));
3604                 ldep->align_addr = NULL;
3605         }
3606 
3607         rv = ldc_mem_unbind_handle(ldep->desc_mhdl);
3608         if (rv != 0) {
3609                 DMSG(vdc, 0, "?[%d] unbind mhdl 0x%lx @ idx %d failed (%d)",
3610                     vdc->instance, ldep->desc_mhdl, idx, rv);
3611                 /*
3612                  * The error returned by the vDisk server is more informative
3613                  * and thus has a higher priority but if it isn't set we ensure
3614                  * that this function returns an error.
3615                  */
3616                 if (status == 0)
3617                         status = EINVAL;
3618         }
3619 
3620         cv_signal(&vdc->membind_cv);
3621         cv_signal(&vdc->dring_free_cv);
3622 
3623         return (status);
3624 }
3625 
3626 /*
3627  * Function:
3628  *      vdc_populate_mem_hdl()
3629  *
3630  * Description:
3631  *
3632  * Arguments:
3633  *      vdc     - soft state pointer for this instance of the device driver.
3634  *      idx     - Index of the Descriptor Ring entry being modified
3635  *      addr    - virtual address being mapped in
3636  *      nybtes  - number of bytes in 'addr'
3637  *      operation - the vDisk operation being performed (VD_OP_xxx)
3638  *
3639  * Return Code:
3640  *      0       - Success
3641  */
3642 static int
3643 vdc_populate_mem_hdl(vdc_t *vdcp, vdc_local_desc_t *ldep)
3644 {
3645         vd_dring_entry_t        *dep = NULL;
3646         ldc_mem_handle_t        mhdl;
3647         caddr_t                 vaddr;
3648         size_t                  nbytes;
3649         uint8_t                 perm = LDC_MEM_RW;
3650         uint8_t                 maptype;
3651         int                     rv = 0;
3652         int                     i;
3653 
3654         ASSERT(vdcp != NULL);
3655 
3656         dep = ldep->dep;
3657         mhdl = ldep->desc_mhdl;
3658 
3659         switch (ldep->dir) {
3660         case VIO_read_dir:
3661                 perm = LDC_MEM_W;
3662                 break;
3663 
3664         case VIO_write_dir:
3665                 perm = LDC_MEM_R;
3666                 break;
3667 
3668         case VIO_both_dir:
3669                 perm = LDC_MEM_RW;
3670                 break;
3671 
3672         default:
3673                 ASSERT(0);      /* catch bad programming in vdc */
3674         }
3675 
3676         /*
3677          * LDC expects any addresses passed in to be 8-byte aligned. We need
3678          * to copy the contents of any misaligned buffers to a newly allocated
3679          * buffer and bind it instead (and copy the the contents back to the
3680          * original buffer passed in when depopulating the descriptor)
3681          */
3682         vaddr = ldep->addr;
3683         nbytes = ldep->nbytes;
3684         if (((uint64_t)vaddr & 0x7) != 0) {
3685                 ASSERT(ldep->align_addr == NULL);
3686                 ldep->align_addr =
3687                     kmem_alloc(sizeof (caddr_t) *
3688                     P2ROUNDUP(nbytes, 8), KM_SLEEP);
3689                 DMSG(vdcp, 0, "[%d] Misaligned address %p reallocating "
3690                     "(buf=%p nb=%ld op=%d)\n",
3691                     vdcp->instance, (void *)vaddr, (void *)ldep->align_addr,
3692                     nbytes, ldep->operation);
3693                 if (perm != LDC_MEM_W)
3694                         bcopy(vaddr, ldep->align_addr, nbytes);
3695                 vaddr = ldep->align_addr;
3696         }
3697 
3698         maptype = LDC_IO_MAP|LDC_SHADOW_MAP;
3699         rv = ldc_mem_bind_handle(mhdl, vaddr, P2ROUNDUP(nbytes, 8),
3700             maptype, perm, &dep->payload.cookie[0], &dep->payload.ncookies);
3701         DMSG(vdcp, 2, "[%d] bound mem handle; ncookies=%d\n",
3702             vdcp->instance, dep->payload.ncookies);
3703         if (rv != 0) {
3704                 DMSG(vdcp, 0, "[%d] Failed to bind LDC memory handle "
3705                     "(mhdl=%p, buf=%p, err=%d)\n",
3706                     vdcp->instance, (void *)mhdl, (void *)vaddr, rv);
3707                 if (ldep->align_addr) {
3708                         kmem_free(ldep->align_addr,
3709                             sizeof (caddr_t) * P2ROUNDUP(nbytes, 8));
3710                         ldep->align_addr = NULL;
3711                 }
3712                 return (EAGAIN);
3713         }
3714 
3715         /*
3716          * Get the other cookies (if any).
3717          */
3718         for (i = 1; i < dep->payload.ncookies; i++) {
3719                 rv = ldc_mem_nextcookie(mhdl, &dep->payload.cookie[i]);
3720                 if (rv != 0) {
3721                         (void) ldc_mem_unbind_handle(mhdl);
3722                         DMSG(vdcp, 0, "?[%d] Failed to get next cookie "
3723                             "(mhdl=%lx cnum=%d), err=%d",
3724                             vdcp->instance, mhdl, i, rv);
3725                         if (ldep->align_addr) {
3726                                 kmem_free(ldep->align_addr,
3727                                     sizeof (caddr_t) * ldep->nbytes);
3728                                 ldep->align_addr = NULL;
3729                         }
3730                         return (EAGAIN);
3731                 }
3732         }
3733 
3734         return (rv);
3735 }
3736 
3737 /*
3738  * Interrupt handlers for messages from LDC
3739  */
3740 
3741 /*
3742  * Function:
3743  *      vdc_handle_cb()
3744  *
3745  * Description:
3746  *
3747  * Arguments:
3748  *      event   - Type of event (LDC_EVT_xxx) that triggered the callback
3749  *      arg     - soft state pointer for this instance of the device driver.
3750  *
3751  * Return Code:
3752  *      0       - Success
3753  */
3754 static uint_t
3755 vdc_handle_cb(uint64_t event, caddr_t arg)
3756 {
3757         ldc_status_t    ldc_state;
3758         int             rv = 0;
3759         vdc_server_t    *srvr = (vdc_server_t *)(void *)arg;
3760         vdc_t           *vdc = srvr->vdcp;
3761 
3762         ASSERT(vdc != NULL);
3763 
3764         DMSG(vdc, 1, "evt=%lx seqID=%ld\n", event, vdc->seq_num);
3765 
3766         /* If callback is not for the current server, ignore it */
3767         mutex_enter(&vdc->lock);
3768 
3769         if (vdc->curr_server != srvr) {
3770                 DMSG(vdc, 0, "[%d] Ignoring event 0x%lx for port@%ld\n",
3771                     vdc->instance, event, srvr->id);
3772                 mutex_exit(&vdc->lock);
3773                 return (LDC_SUCCESS);
3774         }
3775 
3776         /*
3777          * Depending on the type of event that triggered this callback,
3778          * we modify the handshake state or read the data.
3779          *
3780          * NOTE: not done as a switch() as event could be triggered by
3781          * a state change and a read request. Also the ordering of the
3782          * check for the event types is deliberate.
3783          */
3784         if (event & LDC_EVT_UP) {
3785                 DMSG(vdc, 0, "[%d] Received LDC_EVT_UP\n", vdc->instance);
3786 
3787                 /* get LDC state */
3788                 rv = ldc_status(srvr->ldc_handle, &ldc_state);
3789                 if (rv != 0) {
3790                         DMSG(vdc, 0, "[%d] Couldn't get LDC status %d",
3791                             vdc->instance, rv);
3792                         mutex_exit(&vdc->lock);
3793                         return (LDC_SUCCESS);
3794                 }
3795                 if (srvr->ldc_state != LDC_UP &&
3796                     ldc_state == LDC_UP) {
3797                         /*
3798                          * Reset the transaction sequence numbers when
3799                          * LDC comes up. We then kick off the handshake
3800                          * negotiation with the vDisk server.
3801                          */
3802                         vdc->seq_num = 1;
3803                         vdc->seq_num_reply = 0;
3804                         vdc->io_pending = B_TRUE;
3805                         srvr->ldc_state = ldc_state;
3806                         cv_signal(&vdc->initwait_cv);
3807                         cv_signal(&vdc->io_pending_cv);
3808                 }
3809         }
3810 
3811         if (event & LDC_EVT_READ) {
3812                 DMSG(vdc, 1, "[%d] Received LDC_EVT_READ\n", vdc->instance);
3813                 mutex_enter(&vdc->read_lock);
3814                 cv_signal(&vdc->read_cv);
3815                 vdc->read_state = VDC_READ_PENDING;
3816                 mutex_exit(&vdc->read_lock);
3817                 mutex_exit(&vdc->lock);
3818 
3819                 /* that's all we have to do - no need to handle DOWN/RESET */
3820                 return (LDC_SUCCESS);
3821         }
3822 
3823         if (event & (LDC_EVT_RESET|LDC_EVT_DOWN)) {
3824 
3825                 DMSG(vdc, 0, "[%d] Received LDC RESET event\n", vdc->instance);
3826 
3827                 /*
3828                  * Need to wake up any readers so they will
3829                  * detect that a reset has occurred.
3830                  */
3831                 mutex_enter(&vdc->read_lock);
3832                 if ((vdc->read_state == VDC_READ_WAITING) ||
3833                     (vdc->read_state == VDC_READ_RESET))
3834                         cv_signal(&vdc->read_cv);
3835                 vdc->read_state = VDC_READ_RESET;
3836                 mutex_exit(&vdc->read_lock);
3837 
3838                 /* wake up any threads waiting for connection to come up */
3839                 if (vdc->state == VDC_STATE_INIT_WAITING) {
3840                         vdc->state = VDC_STATE_RESETTING;
3841                         cv_signal(&vdc->initwait_cv);
3842                 } else if (vdc->state == VDC_STATE_FAILED) {
3843                         vdc->io_pending = B_TRUE;
3844                         cv_signal(&vdc->io_pending_cv);
3845                 }
3846 
3847         }
3848 
3849         mutex_exit(&vdc->lock);
3850 
3851         if (event & ~(LDC_EVT_UP | LDC_EVT_RESET | LDC_EVT_DOWN | LDC_EVT_READ))
3852                 DMSG(vdc, 0, "![%d] Unexpected LDC event (%lx) received",
3853                     vdc->instance, event);
3854 
3855         return (LDC_SUCCESS);
3856 }
3857 
3858 /*
3859  * Function:
3860  *      vdc_wait_for_response()
3861  *
3862  * Description:
3863  *      Block waiting for a response from the server. If there is
3864  *      no data the thread block on the read_cv that is signalled
3865  *      by the callback when an EVT_READ occurs.
3866  *
3867  * Arguments:
3868  *      vdcp    - soft state pointer for this instance of the device driver.
3869  *
3870  * Return Code:
3871  *      0       - Success
3872  */
3873 static int
3874 vdc_wait_for_response(vdc_t *vdcp, vio_msg_t *msgp)
3875 {
3876         size_t          nbytes = sizeof (*msgp);
3877         int             status;
3878 
3879         ASSERT(vdcp != NULL);
3880 
3881         DMSG(vdcp, 1, "[%d] Entered\n", vdcp->instance);
3882 
3883         status = vdc_recv(vdcp, msgp, &nbytes);
3884         DMSG(vdcp, 3, "vdc_read() done.. status=0x%x size=0x%x\n",
3885             status, (int)nbytes);
3886         if (status) {
3887                 DMSG(vdcp, 0, "?[%d] Error %d reading LDC msg\n",
3888                     vdcp->instance, status);
3889                 return (status);
3890         }
3891 
3892         if (nbytes < sizeof (vio_msg_tag_t)) {
3893                 DMSG(vdcp, 0, "?[%d] Expect %lu bytes; recv'd %lu\n",
3894                     vdcp->instance, sizeof (vio_msg_tag_t), nbytes);
3895                 return (ENOMSG);
3896         }
3897 
3898         DMSG(vdcp, 2, "[%d] (%x/%x/%x)\n", vdcp->instance,
3899             msgp->tag.vio_msgtype,
3900             msgp->tag.vio_subtype,
3901             msgp->tag.vio_subtype_env);
3902 
3903         /*
3904          * Verify the Session ID of the message
3905          *
3906          * Every message after the Version has been negotiated should
3907          * have the correct session ID set.
3908          */
3909         if ((msgp->tag.vio_sid != vdcp->session_id) &&
3910             (msgp->tag.vio_subtype_env != VIO_VER_INFO)) {
3911                 DMSG(vdcp, 0, "[%d] Invalid SID: received 0x%x, "
3912                     "expected 0x%lx [seq num %lx @ %d]",
3913                     vdcp->instance, msgp->tag.vio_sid,
3914                     vdcp->session_id,
3915                     ((vio_dring_msg_t *)msgp)->seq_num,
3916                     ((vio_dring_msg_t *)msgp)->start_idx);
3917                 return (ENOMSG);
3918         }
3919         return (0);
3920 }
3921 
3922 
3923 /*
3924  * Function:
3925  *      vdc_resubmit_backup_dring()
3926  *
3927  * Description:
3928  *      Resubmit each descriptor in the backed up dring to
3929  *      vDisk server. The Dring was backed up during connection
3930  *      reset.
3931  *
3932  * Arguments:
3933  *      vdcp    - soft state pointer for this instance of the device driver.
3934  *
3935  * Return Code:
3936  *      0       - Success
3937  */
3938 static int
3939 vdc_resubmit_backup_dring(vdc_t *vdcp)
3940 {
3941         int             processed = 0;
3942         int             count;
3943         int             b_idx;
3944         int             rv = 0;
3945         int             dring_size;
3946         vdc_local_desc_t        *curr_ldep;
3947 
3948         ASSERT(MUTEX_NOT_HELD(&vdcp->lock));
3949         ASSERT(vdcp->state == VDC_STATE_HANDLE_PENDING);
3950 
3951         if (vdcp->local_dring_backup == NULL) {
3952                 /* the pending requests have already been processed */
3953                 return (0);
3954         }
3955 
3956         DMSG(vdcp, 1, "restoring pending dring entries (len=%d, tail=%d)\n",
3957             vdcp->local_dring_backup_len, vdcp->local_dring_backup_tail);
3958 
3959         /*
3960          * Walk the backup copy of the local descriptor ring and
3961          * resubmit all the outstanding transactions.
3962          */
3963         b_idx = vdcp->local_dring_backup_tail;
3964         for (count = 0; count < vdcp->local_dring_backup_len; count++) {
3965 
3966                 curr_ldep = &(vdcp->local_dring_backup[b_idx]);
3967 
3968                 /* only resubmit outstanding transactions */
3969                 if (!curr_ldep->is_free) {
3970 
3971                         DMSG(vdcp, 1, "resubmitting entry idx=%x\n", b_idx);
3972 
3973                         rv = vdc_do_op(vdcp, curr_ldep->operation,
3974                             curr_ldep->addr, curr_ldep->nbytes,
3975                             curr_ldep->slice, curr_ldep->offset,
3976                             curr_ldep->buf, curr_ldep->dir,
3977                             (curr_ldep->flags & ~VDC_OP_STATE_RUNNING) |
3978                             VDC_OP_RESUBMIT);
3979 
3980                         if (rv) {
3981                                 DMSG(vdcp, 1, "[%d] resubmit entry %d failed\n",
3982                                     vdcp->instance, b_idx);
3983                                 goto done;
3984                         }
3985 
3986                         /*
3987                          * Mark this entry as free so that we will not resubmit
3988                          * this "done" request again, if we were to use the same
3989                          * backup_dring again in future. This could happen when
3990                          * a reset happens while processing the backup_dring.
3991                          */
3992                         curr_ldep->is_free = B_TRUE;
3993                         processed++;
3994                 }
3995 
3996                 /* get the next element to submit */
3997                 if (++b_idx >= vdcp->local_dring_backup_len)
3998                         b_idx = 0;
3999         }
4000 
4001         /* all done - now clear up pending dring copy */
4002         dring_size = vdcp->local_dring_backup_len *
4003             sizeof (vdcp->local_dring_backup[0]);
4004 
4005         (void) kmem_free(vdcp->local_dring_backup, dring_size);
4006 
4007         vdcp->local_dring_backup = NULL;
4008 
4009 done:
4010         DTRACE_PROBE2(processed, int, processed, vdc_t *, vdcp);
4011 
4012         return (rv);
4013 }
4014 
4015 /*
4016  * Function:
4017  *      vdc_cancel_backup_dring
4018  *
4019  * Description:
4020  *      Cancel each descriptor in the backed up dring to vDisk server.
4021  *      The Dring was backed up during connection reset.
4022  *
4023  * Arguments:
4024  *      vdcp    - soft state pointer for this instance of the device driver.
4025  *
4026  * Return Code:
4027  *      None
4028  */
4029 void
4030 vdc_cancel_backup_dring(vdc_t *vdcp)
4031 {
4032         vdc_local_desc_t *ldep;
4033         struct buf      *bufp;
4034         int             count;
4035         int             b_idx;
4036         int             dring_size;
4037         int             cancelled = 0;
4038 
4039         ASSERT(MUTEX_HELD(&vdcp->lock));
4040         ASSERT(vdcp->state == VDC_STATE_FAILED);
4041 
4042         if (vdcp->local_dring_backup == NULL) {
4043                 /* the pending requests have already been processed */
4044                 return;
4045         }
4046 
4047         DMSG(vdcp, 1, "cancelling pending dring entries (len=%d, tail=%d)\n",
4048             vdcp->local_dring_backup_len, vdcp->local_dring_backup_tail);
4049 
4050         /*
4051          * Walk the backup copy of the local descriptor ring and
4052          * cancel all the outstanding transactions.
4053          */
4054         b_idx = vdcp->local_dring_backup_tail;
4055         for (count = 0; count < vdcp->local_dring_backup_len; count++) {
4056 
4057                 ldep = &(vdcp->local_dring_backup[b_idx]);
4058 
4059                 /* only cancel outstanding transactions */
4060                 if (!ldep->is_free) {
4061 
4062                         DMSG(vdcp, 1, "cancelling entry idx=%x\n", b_idx);
4063                         cancelled++;
4064 
4065                         /*
4066                          * All requests have already been cleared from the
4067                          * local descriptor ring and the LDC channel has been
4068                          * reset so we will never get any reply for these
4069                          * requests. Now we just have to notify threads waiting
4070                          * for replies that the request has failed.
4071                          */
4072                         bufp = ldep->buf;
4073                         ASSERT(bufp != NULL);
4074                         bufp->b_resid = bufp->b_bcount;
4075                         if (ldep->operation == VD_OP_BREAD ||
4076                             ldep->operation == VD_OP_BWRITE) {
4077                                 VD_UPDATE_ERR_STATS(vdcp, vd_softerrs);
4078                                 VD_KSTAT_WAITQ_EXIT(vdcp);
4079                                 DTRACE_IO1(done, buf_t *, bufp);
4080                         }
4081                         bioerror(bufp, EIO);
4082                         biodone(bufp);
4083                 }
4084 
4085                 /* get the next element to cancel */
4086                 if (++b_idx >= vdcp->local_dring_backup_len)
4087                         b_idx = 0;
4088         }
4089 
4090         /* all done - now clear up pending dring copy */
4091         dring_size = vdcp->local_dring_backup_len *
4092             sizeof (vdcp->local_dring_backup[0]);
4093 
4094         (void) kmem_free(vdcp->local_dring_backup, dring_size);
4095 
4096         vdcp->local_dring_backup = NULL;
4097 
4098         DTRACE_PROBE2(cancelled, int, cancelled, vdc_t *, vdcp);
4099 }
4100 
4101 /*
4102  * Function:
4103  *      vdc_connection_timeout
4104  *
4105  * Description:
4106  *      This function is invoked if the timeout set to establish the connection
4107  *      with vds expires. This will happen if we spend too much time in the
4108  *      VDC_STATE_INIT_WAITING, VDC_STATE_NEGOTIATE or VDC_STATE_HANDLE_PENDING
4109  *      states.
4110  *
4111  * Arguments:
4112  *      arg     - argument of the timeout function actually a soft state
4113  *                pointer for the instance of the device driver.
4114  *
4115  * Return Code:
4116  *      None
4117  */
4118 void
4119 vdc_connection_timeout(void *arg)
4120 {
4121         vdc_t           *vdcp = (vdc_t *)arg;
4122 
4123         mutex_enter(&vdcp->lock);
4124 
4125         vdcp->ctimeout_reached = B_TRUE;
4126 
4127         mutex_exit(&vdcp->lock);
4128 }
4129 
4130 /*
4131  * Function:
4132  *      vdc_backup_local_dring()
4133  *
4134  * Description:
4135  *      Backup the current dring in the event of a reset. The Dring
4136  *      transactions will be resubmitted to the server when the
4137  *      connection is restored.
4138  *
4139  * Arguments:
4140  *      vdcp    - soft state pointer for this instance of the device driver.
4141  *
4142  * Return Code:
4143  *      NONE
4144  */
4145 static void
4146 vdc_backup_local_dring(vdc_t *vdcp)
4147 {
4148         int b_idx, count, dring_size;
4149         vdc_local_desc_t *curr_ldep;
4150 
4151         ASSERT(MUTEX_HELD(&vdcp->lock));
4152         ASSERT(vdcp->state == VDC_STATE_RESETTING);
4153 
4154         /*
4155          * If the backup dring is stil around, it means
4156          * that the last restore did not complete. However,
4157          * since we never got back into the running state,
4158          * the backup copy we have is still valid.
4159          */
4160         if (vdcp->local_dring_backup != NULL) {
4161                 DMSG(vdcp, 1, "reusing local descriptor ring backup "
4162                     "(len=%d, tail=%d)\n", vdcp->local_dring_backup_len,
4163                     vdcp->local_dring_backup_tail);
4164                 return;
4165         }
4166 
4167         /*
4168          * The backup dring can be NULL and the local dring may not be
4169          * initialized. This can happen if we had a reset while establishing
4170          * a new connection but after the connection has timed out. In that
4171          * case the backup dring is NULL because the requests have been
4172          * cancelled and the request occured before the local dring is
4173          * initialized.
4174          */
4175         if (!(vdcp->initialized & VDC_DRING_LOCAL))
4176                 return;
4177 
4178         DMSG(vdcp, 1, "backing up the local descriptor ring (len=%d, "
4179             "tail=%d)\n", vdcp->dring_len, vdcp->dring_curr_idx);
4180 
4181         dring_size = vdcp->dring_len * sizeof (vdcp->local_dring[0]);
4182 
4183         vdcp->local_dring_backup = kmem_alloc(dring_size, KM_SLEEP);
4184         bcopy(vdcp->local_dring, vdcp->local_dring_backup, dring_size);
4185 
4186         vdcp->local_dring_backup_tail = vdcp->dring_curr_idx;
4187         vdcp->local_dring_backup_len = vdcp->dring_len;
4188 
4189         /*
4190          * At this point, pending read or write I/Os are recorded in the
4191          * runq. We update the I/O statistics to indicate that they are now
4192          * back in the waitq.
4193          */
4194         b_idx = vdcp->local_dring_backup_tail;
4195         for (count = 0; count < vdcp->local_dring_backup_len; count++) {
4196 
4197                 curr_ldep = &(vdcp->local_dring_backup[b_idx]);
4198 
4199                 if (!curr_ldep->is_free &&
4200                     (curr_ldep->operation == VD_OP_BREAD ||
4201                     curr_ldep->operation == VD_OP_BWRITE)) {
4202                         VD_KSTAT_RUNQ_BACK_TO_WAITQ(vdcp);
4203                 }
4204 
4205                 /* get the next element */
4206                 if (++b_idx >= vdcp->local_dring_backup_len)
4207                         b_idx = 0;
4208         }
4209 
4210 }
4211 
4212 static void
4213 vdc_switch_server(vdc_t *vdcp)
4214 {
4215         int             rv;
4216         vdc_server_t    *curr_server, *new_server;
4217 
4218         ASSERT(MUTEX_HELD(&vdcp->lock));
4219 
4220         /* if there is only one server return back */
4221         if (vdcp->num_servers == 1) {
4222                 return;
4223         }
4224 
4225         /* Get current and next server */
4226         curr_server = vdcp->curr_server;
4227         new_server =
4228             (curr_server->next) ? curr_server->next : vdcp->server_list;
4229         ASSERT(curr_server != new_server);
4230 
4231         /* bring current server's channel down */
4232         rv = ldc_down(curr_server->ldc_handle);
4233         if (rv) {
4234                 DMSG(vdcp, 0, "[%d] Cannot bring channel down, port %ld\n",
4235                     vdcp->instance, curr_server->id);
4236                 return;
4237         }
4238 
4239         /* switch the server */
4240         vdcp->curr_server = new_server;
4241 
4242         DMSG(vdcp, 0, "[%d] Switched to next vdisk server, port@%ld, ldc@%ld\n",
4243             vdcp->instance, vdcp->curr_server->id, vdcp->curr_server->ldc_id);
4244 }
4245 
4246 static void
4247 vdc_print_svc_status(vdc_t *vdcp)
4248 {
4249         int instance;
4250         uint64_t ldc_id, port_id;
4251         vdc_service_state_t svc_state;
4252 
4253         ASSERT(mutex_owned(&vdcp->lock));
4254 
4255         svc_state = vdcp->curr_server->svc_state;
4256 
4257         if (vdcp->curr_server->log_state == svc_state)
4258                 return;
4259 
4260         instance = vdcp->instance;
4261         ldc_id = vdcp->curr_server->ldc_id;
4262         port_id = vdcp->curr_server->id;
4263 
4264         switch (svc_state) {
4265 
4266         case VDC_SERVICE_OFFLINE:
4267                 cmn_err(CE_CONT, "?vdisk@%d is offline\n", instance);
4268                 break;
4269 
4270         case VDC_SERVICE_CONNECTED:
4271                 cmn_err(CE_CONT, "?vdisk@%d is connected using ldc@%ld,%ld\n",
4272                     instance, ldc_id, port_id);
4273                 break;
4274 
4275         case VDC_SERVICE_ONLINE:
4276                 cmn_err(CE_CONT, "?vdisk@%d is online using ldc@%ld,%ld\n",
4277                     instance, ldc_id, port_id);
4278                 break;
4279 
4280         case VDC_SERVICE_FAILED:
4281                 cmn_err(CE_CONT, "?vdisk@%d access to service failed "
4282                     "using ldc@%ld,%ld\n", instance, ldc_id, port_id);
4283                 break;
4284 
4285         case VDC_SERVICE_FAULTED:
4286                 cmn_err(CE_CONT, "?vdisk@%d access to backend failed "
4287                     "using ldc@%ld,%ld\n", instance, ldc_id, port_id);
4288                 break;
4289 
4290         default:
4291                 ASSERT(0);
4292                 break;
4293         }
4294 
4295         vdcp->curr_server->log_state = svc_state;
4296 }
4297 
4298 /*
4299  * Function:
4300  *      vdc_handshake_retry
4301  *
4302  * Description:
4303  *      This function indicates if the handshake should be retried or not.
4304  *      This depends on the lifecycle of the driver:
4305  *
4306  *      VDC_LC_ATTACHING: the handshake is retried until we have tried
4307  *      a handshake with each server. We don't care how far each handshake
4308  *      went, the goal is just to try the handshake. We want to minimize the
4309  *      the time spent doing the attach because this is locking the device
4310  *      tree.
4311  *
4312  *      VDC_LC_ONLINE_PENDING: the handshake is retried while we haven't done
4313  *      consecutive attribute negotiations with each server, and we haven't
4314  *      reached a minimum total of consecutive negotiations (hattr_min). The
4315  *      number of attribution negotiations determines the time spent before
4316  *      failing pending I/Os if the handshake is not successful.
4317  *
4318  *      VDC_LC_ONLINE: the handshake is always retried, until we have a
4319  *      successful handshake with a server.
4320  *
4321  *      VDC_LC_DETACHING: N/A
4322  *
4323  * Arguments:
4324  *      hshake_cnt      - number of handshake attempts
4325  *      hattr_cnt       - number of attribute negotiation attempts
4326  *
4327  * Return Code:
4328  *      B_TRUE          - handshake should be retried
4329  *      B_FALSE         - handshake should not be retried
4330  */
4331 static boolean_t
4332 vdc_handshake_retry(vdc_t *vdcp, int hshake_cnt, int hattr_cnt)
4333 {
4334         int             hattr_total = 0;
4335         vdc_server_t    *srvr;
4336 
4337         ASSERT(vdcp->lifecycle != VDC_LC_DETACHING);
4338 
4339         /* update handshake counters */
4340         vdcp->curr_server->hshake_cnt = hshake_cnt;
4341         vdcp->curr_server->hattr_cnt = hattr_cnt;
4342 
4343         /*
4344          * If no attribute negotiation was done then we reset the total
4345          *  number otherwise we cumulate the number.
4346          */
4347         if (hattr_cnt == 0)
4348                 vdcp->curr_server->hattr_total = 0;
4349         else
4350                 vdcp->curr_server->hattr_total += hattr_cnt;
4351 
4352         /*
4353          * If we are online (i.e. at least one handshake was successfully
4354          * completed) then we always retry the handshake.
4355          */
4356         if (vdcp->lifecycle == VDC_LC_ONLINE)
4357                 return (B_TRUE);
4358 
4359         /*
4360          * If we are attaching then we retry the handshake only if we haven't
4361          * tried with all servers.
4362          */
4363         if (vdcp->lifecycle == VDC_LC_ATTACHING) {
4364 
4365                 for (srvr = vdcp->server_list; srvr != NULL;
4366                     srvr = srvr->next) {
4367                         if (srvr->hshake_cnt == 0) {
4368                                 return (B_TRUE);
4369                         }
4370                 }
4371 
4372                 return (B_FALSE);
4373         }
4374 
4375         /*
4376          * Here we are in the case where we haven't completed any handshake
4377          * successfully yet.
4378          */
4379         ASSERT(vdcp->lifecycle == VDC_LC_ONLINE_PENDING);
4380 
4381         /*
4382          * We retry the handshake if we haven't done an attribute negotiation
4383          * with each server. This is to handle the case where one service domain
4384          * is down.
4385          */
4386         for (srvr = vdcp->server_list; srvr != NULL; srvr = srvr->next) {
4387                 if (srvr->hattr_cnt == 0) {
4388                         return (B_TRUE);
4389                 }
4390                 hattr_total += srvr->hattr_total;
4391         }
4392 
4393         /*
4394          * We retry the handshake if we haven't reached the minimum number of
4395          * attribute negotiation.
4396          */
4397         return (hattr_total < vdcp->hattr_min);
4398 }
4399 
4400 /* -------------------------------------------------------------------------- */
4401 
4402 /*
4403  * The following functions process the incoming messages from vds
4404  */
4405 
4406 /*
4407  * Function:
4408  *      vdc_process_msg_thread()
4409  *
4410  * Description:
4411  *
4412  *      Main VDC message processing thread. Each vDisk instance
4413  *      consists of a copy of this thread. This thread triggers
4414  *      all the handshakes and data exchange with the server. It
4415  *      also handles all channel resets
4416  *
4417  * Arguments:
4418  *      vdc     - soft state pointer for this instance of the device driver.
4419  *
4420  * Return Code:
4421  *      None
4422  */
4423 static void
4424 vdc_process_msg_thread(vdc_t *vdcp)
4425 {
4426         boolean_t       failure_msg = B_FALSE;
4427         int             status;
4428         int             ctimeout;
4429         timeout_id_t    tmid = 0;
4430         clock_t         ldcup_timeout = 0;
4431         vdc_server_t    *srvr;
4432         vdc_service_state_t svc_state;
4433         int             hshake_cnt = 0;
4434         int             hattr_cnt = 0;
4435 
4436         mutex_enter(&vdcp->lock);
4437 
4438         ASSERT(vdcp->lifecycle == VDC_LC_ATTACHING);
4439 
4440         for (;;) {
4441 
4442 #define Q(_s)   (vdcp->state == _s) ? #_s :
4443                 DMSG(vdcp, 3, "state = %d (%s)\n", vdcp->state,
4444                     Q(VDC_STATE_INIT)
4445                     Q(VDC_STATE_INIT_WAITING)
4446                     Q(VDC_STATE_NEGOTIATE)
4447                     Q(VDC_STATE_HANDLE_PENDING)
4448                     Q(VDC_STATE_FAULTED)
4449                     Q(VDC_STATE_FAILED)
4450                     Q(VDC_STATE_RUNNING)
4451                     Q(VDC_STATE_RESETTING)
4452                     Q(VDC_STATE_DETACH)
4453                     "UNKNOWN");
4454 #undef Q
4455 
4456                 switch (vdcp->state) {
4457                 case VDC_STATE_INIT:
4458 
4459                         /*
4460                          * If requested, start a timeout to check if the
4461                          * connection with vds is established in the
4462                          * specified delay. If the timeout expires, we
4463                          * will cancel any pending request.
4464                          *
4465                          * If some reset have occurred while establishing
4466                          * the connection, we already have a timeout armed
4467                          * and in that case we don't need to arm a new one.
4468                          *
4469                          * The same rule applies when there are multiple vds'.
4470                          * If either a connection cannot be established or
4471                          * the handshake times out, the connection thread will
4472                          * try another server. The 'ctimeout' will report
4473                          * back an error after it expires irrespective of
4474                          * whether the vdisk is trying to connect to just
4475                          * one or multiple servers.
4476                          */
4477                         ctimeout = (vdc_timeout != 0)?
4478                             vdc_timeout : vdcp->curr_server->ctimeout;
4479 
4480                         if (ctimeout != 0 && tmid == 0) {
4481                                 tmid = timeout(vdc_connection_timeout, vdcp,
4482                                     ctimeout * drv_usectohz(MICROSEC));
4483                         }
4484 
4485                         /* Switch to STATE_DETACH if drv is detaching */
4486                         if (vdcp->lifecycle == VDC_LC_DETACHING) {
4487                                 vdcp->state = VDC_STATE_DETACH;
4488                                 break;
4489                         }
4490 
4491                         /* Check if the timeout has been reached */
4492                         if (vdcp->ctimeout_reached) {
4493                                 ASSERT(tmid != 0);
4494                                 tmid = 0;
4495                                 vdcp->state = VDC_STATE_FAILED;
4496                                 break;
4497                         }
4498 
4499                         /*
4500                          * Switch to another server when we reach the limit of
4501                          * the number of handshake per server or if we have done
4502                          * an attribute negotiation.
4503                          */
4504                         if (hshake_cnt >= vdc_hshake_retries || hattr_cnt > 0) {
4505 
4506                                 if (!vdc_handshake_retry(vdcp, hshake_cnt,
4507                                     hattr_cnt)) {
4508                                         DMSG(vdcp, 0, "[%d] too many "
4509                                             "handshakes", vdcp->instance);
4510                                         vdcp->state = VDC_STATE_FAILED;
4511                                         break;
4512                                 }
4513 
4514                                 vdc_switch_server(vdcp);
4515 
4516                                 hshake_cnt = 0;
4517                                 hattr_cnt = 0;
4518                         }
4519 
4520                         hshake_cnt++;
4521 
4522                         /* Bring up connection with vds via LDC */
4523                         status = vdc_start_ldc_connection(vdcp);
4524                         if (status != EINVAL) {
4525                                 vdcp->state = VDC_STATE_INIT_WAITING;
4526                         } else {
4527                                 vdcp->curr_server->svc_state =
4528                                     VDC_SERVICE_FAILED;
4529                                 vdc_print_svc_status(vdcp);
4530                         }
4531                         break;
4532 
4533                 case VDC_STATE_INIT_WAITING:
4534 
4535                         /* if channel is UP, start negotiation */
4536                         if (vdcp->curr_server->ldc_state == LDC_UP) {
4537                                 vdcp->state = VDC_STATE_NEGOTIATE;
4538                                 break;
4539                         }
4540 
4541                         /*
4542                          * Wait for LDC_UP. If it times out and we have multiple
4543                          * servers then we will retry using a different server.
4544                          */
4545                         ldcup_timeout = ddi_get_lbolt() + (vdc_ldcup_timeout *
4546                             drv_usectohz(MICROSEC));
4547                         status = cv_timedwait(&vdcp->initwait_cv, &vdcp->lock,
4548                             ldcup_timeout);
4549                         if (status == -1 &&
4550                             vdcp->state == VDC_STATE_INIT_WAITING &&
4551                             vdcp->curr_server->ldc_state != LDC_UP) {
4552                                 /* timed out & still waiting */
4553                                 vdcp->curr_server->svc_state =
4554                                     VDC_SERVICE_FAILED;
4555                                 vdc_print_svc_status(vdcp);
4556                                 vdcp->state = VDC_STATE_INIT;
4557                                 break;
4558                         }
4559 
4560                         if (vdcp->state != VDC_STATE_INIT_WAITING) {
4561                                 DMSG(vdcp, 0,
4562                                     "state moved to %d out from under us...\n",
4563                                     vdcp->state);
4564                         }
4565                         break;
4566 
4567                 case VDC_STATE_NEGOTIATE:
4568                         switch (status = vdc_ver_negotiation(vdcp)) {
4569                         case 0:
4570                                 break;
4571                         default:
4572                                 DMSG(vdcp, 0, "ver negotiate failed (%d)..\n",
4573                                     status);
4574                                 goto reset;
4575                         }
4576 
4577                         hattr_cnt++;
4578 
4579                         switch (status = vdc_attr_negotiation(vdcp)) {
4580                         case 0:
4581                                 break;
4582                         default:
4583                                 DMSG(vdcp, 0, "attr negotiate failed (%d)..\n",
4584                                     status);
4585                                 goto reset;
4586                         }
4587 
4588                         switch (status = vdc_dring_negotiation(vdcp)) {
4589                         case 0:
4590                                 break;
4591                         default:
4592                                 DMSG(vdcp, 0, "dring negotiate failed (%d)..\n",
4593                                     status);
4594                                 goto reset;
4595                         }
4596 
4597                         switch (status = vdc_rdx_exchange(vdcp)) {
4598                         case 0:
4599                                 vdcp->state = VDC_STATE_HANDLE_PENDING;
4600                                 goto done;
4601                         default:
4602                                 DMSG(vdcp, 0, "RDX xchg failed ..(%d)\n",
4603                                     status);
4604                                 goto reset;
4605                         }
4606 reset:
4607                         DMSG(vdcp, 0, "negotiation failed: resetting (%d)\n",
4608                             status);
4609                         vdcp->state = VDC_STATE_RESETTING;
4610                         vdcp->self_reset = B_TRUE;
4611                         vdcp->curr_server->svc_state = VDC_SERVICE_FAILED;
4612                         vdc_print_svc_status(vdcp);
4613 done:
4614                         DMSG(vdcp, 0, "negotiation complete (state=0x%x)...\n",
4615                             vdcp->state);
4616                         break;
4617 
4618                 case VDC_STATE_HANDLE_PENDING:
4619 
4620                         DMSG(vdcp, 0, "[%d] connection to service domain is up",
4621                             vdcp->instance);
4622                         vdcp->curr_server->svc_state = VDC_SERVICE_CONNECTED;
4623 
4624                         mutex_exit(&vdcp->lock);
4625 
4626                         /*
4627                          * If we have multiple servers, check that the backend
4628                          * is effectively available before resubmitting any IO.
4629                          */
4630                         if (vdcp->num_servers > 1 &&
4631                             vdc_eio_check(vdcp, 0) != 0) {
4632                                 mutex_enter(&vdcp->lock);
4633                                 vdcp->curr_server->svc_state =
4634                                     VDC_SERVICE_FAULTED;
4635                                 vdcp->state = VDC_STATE_FAULTED;
4636                                 break;
4637                         }
4638 
4639                         if (tmid != 0) {
4640                                 (void) untimeout(tmid);
4641                                 tmid = 0;
4642                                 vdcp->ctimeout_reached = B_FALSE;
4643                         }
4644 
4645                         /*
4646                          * Setup devid
4647                          */
4648                         (void) vdc_setup_devid(vdcp);
4649 
4650                         status = vdc_resubmit_backup_dring(vdcp);
4651 
4652                         mutex_enter(&vdcp->lock);
4653 
4654                         if (status) {
4655                                 vdcp->state = VDC_STATE_RESETTING;
4656                                 vdcp->self_reset = B_TRUE;
4657                                 vdcp->curr_server->svc_state =
4658                                     VDC_SERVICE_FAILED;
4659                                 vdc_print_svc_status(vdcp);
4660                         } else {
4661                                 vdcp->state = VDC_STATE_RUNNING;
4662                         }
4663                         break;
4664 
4665                 case VDC_STATE_FAULTED:
4666                         /*
4667                          * Server is faulted because the backend is unavailable.
4668                          * If all servers are faulted then we mark the service
4669                          * as failed, otherwise we reset to switch to another
4670                          * server.
4671                          */
4672                         vdc_print_svc_status(vdcp);
4673 
4674                         /* check if all servers are faulted */
4675                         for (srvr = vdcp->server_list; srvr != NULL;
4676                             srvr = srvr->next) {
4677                                 svc_state = srvr->svc_state;
4678                                 if (svc_state != VDC_SERVICE_FAULTED)
4679                                         break;
4680                         }
4681 
4682                         if (srvr != NULL) {
4683                                 vdcp->state = VDC_STATE_RESETTING;
4684                                 vdcp->self_reset = B_TRUE;
4685                         } else {
4686                                 vdcp->state = VDC_STATE_FAILED;
4687                         }
4688                         break;
4689 
4690                 case VDC_STATE_FAILED:
4691                         /*
4692                          * We reach this state when we are unable to access the
4693                          * backend from any server, either because of a maximum
4694                          * connection retries or timeout, or because the backend
4695                          * is unavailable.
4696                          *
4697                          * Then we cancel the backup DRing so that errors get
4698                          * reported and we wait for a new I/O before attempting
4699                          * another connection.
4700                          */
4701 
4702                         cmn_err(CE_NOTE, "vdisk@%d disk access failed",
4703                             vdcp->instance);
4704                         failure_msg = B_TRUE;
4705 
4706                         if (vdcp->lifecycle == VDC_LC_ATTACHING) {
4707                                 vdcp->lifecycle = VDC_LC_ONLINE_PENDING;
4708                                 vdcp->hattr_min = vdc_hattr_min_initial;
4709                         } else {
4710                                 vdcp->hattr_min = vdc_hattr_min;
4711                         }
4712 
4713                         /* cancel any timeout */
4714                         if (tmid != 0) {
4715                                 (void) untimeout(tmid);
4716                                 tmid = 0;
4717                         }
4718 
4719                         /* cancel pending I/Os */
4720                         cv_broadcast(&vdcp->running_cv);
4721                         vdc_cancel_backup_dring(vdcp);
4722 
4723                         /* wait for new I/O */
4724                         while (!vdcp->io_pending)
4725                                 cv_wait(&vdcp->io_pending_cv, &vdcp->lock);
4726 
4727                         /*
4728                          * There's a new IO pending. Try to re-establish a
4729                          * connection. Mark all services as offline, so that
4730                          * we don't stop again before having retried all
4731                          * servers.
4732                          */
4733                         for (srvr = vdcp->server_list; srvr != NULL;
4734                             srvr = srvr->next) {
4735                                 srvr->svc_state = VDC_SERVICE_OFFLINE;
4736                                 srvr->hshake_cnt = 0;
4737                                 srvr->hattr_cnt = 0;
4738                                 srvr->hattr_total = 0;
4739                         }
4740 
4741                         /* reset variables */
4742                         hshake_cnt = 0;
4743                         hattr_cnt = 0;
4744                         vdcp->ctimeout_reached = B_FALSE;
4745 
4746                         vdcp->state = VDC_STATE_RESETTING;
4747                         vdcp->self_reset = B_TRUE;
4748                         break;
4749 
4750                 /* enter running state */
4751                 case VDC_STATE_RUNNING:
4752 
4753                         if (vdcp->lifecycle == VDC_LC_DETACHING) {
4754                                 vdcp->state = VDC_STATE_DETACH;
4755                                 break;
4756                         }
4757 
4758                         vdcp->lifecycle = VDC_LC_ONLINE;
4759 
4760                         if (failure_msg) {
4761                                 cmn_err(CE_NOTE, "vdisk@%d disk access "
4762                                     "recovered", vdcp->instance);
4763                                 failure_msg = B_FALSE;
4764                         }
4765 
4766                         /*
4767                          * Signal anyone waiting for the connection
4768                          * to come on line.
4769                          */
4770                         cv_broadcast(&vdcp->running_cv);
4771 
4772                         /* backend has to be checked after reset */
4773                         if (vdcp->failfast_interval != 0 ||
4774                             vdcp->num_servers > 1)
4775                                 cv_signal(&vdcp->eio_cv);
4776 
4777                         /* ownership is lost during reset */
4778                         if (vdcp->ownership & VDC_OWNERSHIP_WANTED)
4779                                 vdcp->ownership |= VDC_OWNERSHIP_RESET;
4780                         cv_signal(&vdcp->ownership_cv);
4781 
4782                         vdcp->curr_server->svc_state = VDC_SERVICE_ONLINE;
4783                         vdc_print_svc_status(vdcp);
4784 
4785                         mutex_exit(&vdcp->lock);
4786 
4787                         for (;;) {
4788                                 vio_msg_t msg;
4789                                 status = vdc_wait_for_response(vdcp, &msg);
4790                                 if (status) break;
4791 
4792                                 DMSG(vdcp, 1, "[%d] new pkt(s) available\n",
4793                                     vdcp->instance);
4794                                 status = vdc_process_data_msg(vdcp, &msg);
4795                                 if (status) {
4796                                         DMSG(vdcp, 1, "[%d] process_data_msg "
4797                                             "returned err=%d\n", vdcp->instance,
4798                                             status);
4799                                         break;
4800                                 }
4801 
4802                         }
4803 
4804                         mutex_enter(&vdcp->lock);
4805 
4806                         /* all servers are now offline */
4807                         for (srvr = vdcp->server_list; srvr != NULL;
4808                             srvr = srvr->next) {
4809                                 srvr->svc_state = VDC_SERVICE_OFFLINE;
4810                                 srvr->log_state = VDC_SERVICE_NONE;
4811                                 srvr->hshake_cnt = 0;
4812                                 srvr->hattr_cnt = 0;
4813                                 srvr->hattr_total = 0;
4814                         }
4815 
4816                         hshake_cnt = 0;
4817                         hattr_cnt = 0;
4818 
4819                         vdc_print_svc_status(vdcp);
4820 
4821                         vdcp->state = VDC_STATE_RESETTING;
4822                         vdcp->self_reset = B_TRUE;
4823                         break;
4824 
4825                 case VDC_STATE_RESETTING:
4826                         /*
4827                          * When we reach this state, we either come from the
4828                          * VDC_STATE_RUNNING state and we can have pending
4829                          * request but no timeout is armed; or we come from
4830                          * the VDC_STATE_INIT_WAITING, VDC_NEGOTIATE or
4831                          * VDC_HANDLE_PENDING state and there is no pending
4832                          * request or pending requests have already been copied
4833                          * into the backup dring. So we can safely keep the
4834                          * connection timeout armed while we are in this state.
4835                          */
4836 
4837                         DMSG(vdcp, 0, "Initiating channel reset "
4838                             "(pending = %d)\n", (int)vdcp->threads_pending);
4839 
4840                         if (vdcp->self_reset) {
4841                                 DMSG(vdcp, 0,
4842                                     "[%d] calling stop_ldc_connection.\n",
4843                                     vdcp->instance);
4844                                 status = vdc_stop_ldc_connection(vdcp);
4845                                 vdcp->self_reset = B_FALSE;
4846                         }
4847 
4848                         /*
4849                          * Wait for all threads currently waiting
4850                          * for a free dring entry to use.
4851                          */
4852                         while (vdcp->threads_pending) {
4853                                 cv_broadcast(&vdcp->membind_cv);
4854                                 cv_broadcast(&vdcp->dring_free_cv);
4855                                 mutex_exit(&vdcp->lock);
4856                                 /* give the waiters enough time to wake up */
4857                                 delay(vdc_hz_min_ldc_delay);
4858                                 mutex_enter(&vdcp->lock);
4859                         }
4860 
4861                         ASSERT(vdcp->threads_pending == 0);
4862 
4863                         /* Sanity check that no thread is receiving */
4864                         ASSERT(vdcp->read_state != VDC_READ_WAITING);
4865 
4866                         vdcp->read_state = VDC_READ_IDLE;
4867                         vdcp->io_pending = B_FALSE;
4868 
4869                         /*
4870                          * Cleanup any pending eio. These I/Os are going to
4871                          * be resubmitted.
4872                          */
4873                         vdc_eio_unqueue(vdcp, 0, B_FALSE);
4874 
4875                         vdc_backup_local_dring(vdcp);
4876 
4877                         /* cleanup the old d-ring */
4878                         vdc_destroy_descriptor_ring(vdcp);
4879 
4880                         /* go and start again */
4881                         vdcp->state = VDC_STATE_INIT;
4882 
4883                         break;
4884 
4885                 case VDC_STATE_DETACH:
4886                         DMSG(vdcp, 0, "[%d] Reset thread exit cleanup ..\n",
4887                             vdcp->instance);
4888 
4889                         /* cancel any pending timeout */
4890                         mutex_exit(&vdcp->lock);
4891                         if (tmid != 0) {
4892                                 (void) untimeout(tmid);
4893                                 tmid = 0;
4894                         }
4895                         mutex_enter(&vdcp->lock);
4896 
4897                         /*
4898                          * Signal anyone waiting for connection
4899                          * to come online
4900                          */
4901                         cv_broadcast(&vdcp->running_cv);
4902 
4903                         while (vdcp->sync_op_cnt > 0) {
4904                                 cv_broadcast(&vdcp->sync_blocked_cv);
4905                                 mutex_exit(&vdcp->lock);
4906                                 /* give the waiters enough time to wake up */
4907                                 delay(vdc_hz_min_ldc_delay);
4908                                 mutex_enter(&vdcp->lock);
4909                         }
4910 
4911                         mutex_exit(&vdcp->lock);
4912 
4913                         DMSG(vdcp, 0, "[%d] Msg processing thread exiting ..\n",
4914                             vdcp->instance);
4915                         thread_exit();
4916                         break;
4917                 }
4918         }
4919 }
4920 
4921 
4922 /*
4923  * Function:
4924  *      vdc_process_data_msg()
4925  *
4926  * Description:
4927  *      This function is called by the message processing thread each time
4928  *      a message with a msgtype of VIO_TYPE_DATA is received. It will either
4929  *      be an ACK or NACK from vds[1] which vdc handles as follows.
4930  *              ACK     - wake up the waiting thread
4931  *              NACK    - resend any messages necessary
4932  *
4933  *      [1] Although the message format allows it, vds should not send a
4934  *          VIO_SUBTYPE_INFO message to vdc asking it to read data; if for
4935  *          some bizarre reason it does, vdc will reset the connection.
4936  *
4937  * Arguments:
4938  *      vdc     - soft state pointer for this instance of the device driver.
4939  *      msg     - the LDC message sent by vds
4940  *
4941  * Return Code:
4942  *      0       - Success.
4943  *      > 0  - error value returned by LDC
4944  */
4945 static int
4946 vdc_process_data_msg(vdc_t *vdcp, vio_msg_t *msg)
4947 {
4948         int                     status = 0;
4949         vio_dring_msg_t         *dring_msg;
4950         vdc_local_desc_t        *ldep = NULL;
4951         int                     start, end;
4952         int                     idx;
4953         int                     op;
4954 
4955         dring_msg = (vio_dring_msg_t *)msg;
4956 
4957         ASSERT(msg->tag.vio_msgtype == VIO_TYPE_DATA);
4958         ASSERT(vdcp != NULL);
4959 
4960         mutex_enter(&vdcp->lock);
4961 
4962         /*
4963          * Check to see if the message has bogus data
4964          */
4965         idx = start = dring_msg->start_idx;
4966         end = dring_msg->end_idx;
4967         if ((start >= vdcp->dring_len) ||
4968             (end >= vdcp->dring_len) || (end < -1)) {
4969                 /*
4970                  * Update the I/O statistics to indicate that an error ocurred.
4971                  * No need to update the wait/run queues as no specific read or
4972                  * write request is being completed in response to this 'msg'.
4973                  */
4974                 VD_UPDATE_ERR_STATS(vdcp, vd_softerrs);
4975                 DMSG(vdcp, 0, "[%d] Bogus ACK data : start %d, end %d\n",
4976                     vdcp->instance, start, end);
4977                 mutex_exit(&vdcp->lock);
4978                 return (EINVAL);
4979         }
4980 
4981         /*
4982          * Verify that the sequence number is what vdc expects.
4983          */
4984         switch (vdc_verify_seq_num(vdcp, dring_msg)) {
4985         case VDC_SEQ_NUM_TODO:
4986                 break;  /* keep processing this message */
4987         case VDC_SEQ_NUM_SKIP:
4988                 mutex_exit(&vdcp->lock);
4989                 return (0);
4990         case VDC_SEQ_NUM_INVALID:
4991                 /*
4992                  * Update the I/O statistics to indicate that an error ocurred.
4993                  * No need to update the wait/run queues as no specific read or
4994                  * write request is being completed in response to this 'msg'.
4995                  */
4996                 VD_UPDATE_ERR_STATS(vdcp, vd_softerrs);
4997                 DMSG(vdcp, 0, "[%d] invalid seqno\n", vdcp->instance);
4998                 mutex_exit(&vdcp->lock);
4999                 return (ENXIO);
5000         }
5001 
5002         if (msg->tag.vio_subtype == VIO_SUBTYPE_NACK) {
5003                 /*
5004                  * Update the I/O statistics to indicate that an error ocurred.
5005                  * No need to update the wait/run queues, this will be done by
5006                  * the thread calling this function.
5007                  */
5008                 VD_UPDATE_ERR_STATS(vdcp, vd_softerrs);
5009                 VDC_DUMP_DRING_MSG(dring_msg);
5010                 DMSG(vdcp, 0, "[%d] DATA NACK\n", vdcp->instance);
5011                 mutex_exit(&vdcp->lock);
5012                 return (EIO);
5013 
5014         } else if (msg->tag.vio_subtype == VIO_SUBTYPE_INFO) {
5015                 /*
5016                  * Update the I/O statistics to indicate that an error occurred.
5017                  * No need to update the wait/run queues as no specific read or
5018                  * write request is being completed in response to this 'msg'.
5019                  */
5020                 VD_UPDATE_ERR_STATS(vdcp, vd_protoerrs);
5021                 mutex_exit(&vdcp->lock);
5022                 return (EPROTO);
5023         }
5024 
5025         DMSG(vdcp, 1, ": start %d end %d\n", start, end);
5026         ASSERT(start == end);
5027 
5028         ldep = &vdcp->local_dring[idx];
5029 
5030         DMSG(vdcp, 1, ": state 0x%x\n", ldep->dep->hdr.dstate);
5031 
5032         if (ldep->dep->hdr.dstate == VIO_DESC_DONE) {
5033                 struct buf *bufp;
5034 
5035                 status = ldep->dep->payload.status;
5036 
5037                 bufp = ldep->buf;
5038                 ASSERT(bufp != NULL);
5039 
5040                 bufp->b_resid = bufp->b_bcount - ldep->dep->payload.nbytes;
5041                 bioerror(bufp, status);
5042 
5043                 if (status != 0) {
5044                         DMSG(vdcp, 1, "I/O status=%d\n", status);
5045                 }
5046 
5047                 DMSG(vdcp, 1,
5048                     "I/O complete req=%ld bytes resp=%ld bytes\n",
5049                     bufp->b_bcount, ldep->dep->payload.nbytes);
5050 
5051                 /*
5052                  * If the request has failed and we have multiple servers or
5053                  * failfast is enabled then we will have to defer the completion
5054                  * of the request until we have checked that the vdisk backend
5055                  * is effectively available (if multiple server) or that there
5056                  * is no reservation conflict (if failfast).
5057                  */
5058                 if (status != 0 &&
5059                     ((vdcp->num_servers > 1 &&
5060                     (ldep->flags & VDC_OP_ERRCHK_BACKEND)) ||
5061                     (vdcp->failfast_interval != 0 &&
5062                     (ldep->flags & VDC_OP_ERRCHK_CONFLICT)))) {
5063                         /*
5064                          * The I/O has failed and we need to check the error.
5065                          */
5066                         (void) vdc_eio_queue(vdcp, idx);
5067                 } else {
5068                         op = ldep->operation;
5069                         if (op == VD_OP_BREAD || op == VD_OP_BWRITE) {
5070                                 if (status == 0) {
5071                                         VD_UPDATE_IO_STATS(vdcp, op,
5072                                             ldep->dep->payload.nbytes);
5073                                 } else {
5074                                         VD_UPDATE_ERR_STATS(vdcp, vd_softerrs);
5075                                 }
5076                                 VD_KSTAT_RUNQ_EXIT(vdcp);
5077                                 DTRACE_IO1(done, buf_t *, bufp);
5078                         }
5079                         (void) vdc_depopulate_descriptor(vdcp, idx);
5080                         biodone(bufp);
5081                 }
5082         }
5083 
5084         /* let the arrival signal propogate */
5085         mutex_exit(&vdcp->lock);
5086 
5087         /* probe gives the count of how many entries were processed */
5088         DTRACE_PROBE2(processed, int, 1, vdc_t *, vdcp);
5089 
5090         return (0);
5091 }
5092 
5093 
5094 /*
5095  * Function:
5096  *      vdc_handle_ver_msg()
5097  *
5098  * Description:
5099  *
5100  * Arguments:
5101  *      vdc     - soft state pointer for this instance of the device driver.
5102  *      ver_msg - LDC message sent by vDisk server
5103  *
5104  * Return Code:
5105  *      0       - Success
5106  */
5107 static int
5108 vdc_handle_ver_msg(vdc_t *vdc, vio_ver_msg_t *ver_msg)
5109 {
5110         int status = 0;
5111 
5112         ASSERT(vdc != NULL);
5113         ASSERT(mutex_owned(&vdc->lock));
5114 
5115         if (ver_msg->tag.vio_subtype_env != VIO_VER_INFO) {
5116                 return (EPROTO);
5117         }
5118 
5119         if (ver_msg->dev_class != VDEV_DISK_SERVER) {
5120                 return (EINVAL);
5121         }
5122 
5123         switch (ver_msg->tag.vio_subtype) {
5124         case VIO_SUBTYPE_ACK:
5125                 /*
5126                  * We check to see if the version returned is indeed supported
5127                  * (The server may have also adjusted the minor number downwards
5128                  * and if so 'ver_msg' will contain the actual version agreed)
5129                  */
5130                 if (vdc_is_supported_version(ver_msg)) {
5131                         vdc->ver.major = ver_msg->ver_major;
5132                         vdc->ver.minor = ver_msg->ver_minor;
5133                         ASSERT(vdc->ver.major > 0);
5134                 } else {
5135                         status = EPROTO;
5136                 }
5137                 break;
5138 
5139         case VIO_SUBTYPE_NACK:
5140                 /*
5141                  * call vdc_is_supported_version() which will return the next
5142                  * supported version (if any) in 'ver_msg'
5143                  */
5144                 (void) vdc_is_supported_version(ver_msg);
5145                 if (ver_msg->ver_major > 0) {
5146                         size_t len = sizeof (*ver_msg);
5147 
5148                         ASSERT(vdc->ver.major > 0);
5149 
5150                         /* reset the necessary fields and resend */
5151                         ver_msg->tag.vio_subtype = VIO_SUBTYPE_INFO;
5152                         ver_msg->dev_class = VDEV_DISK;
5153 
5154                         status = vdc_send(vdc, (caddr_t)ver_msg, &len);
5155                         DMSG(vdc, 0, "[%d] Resend VER info (LDC status = %d)\n",
5156                             vdc->instance, status);
5157                         if (len != sizeof (*ver_msg))
5158                                 status = EBADMSG;
5159                 } else {
5160                         DMSG(vdc, 0, "[%d] No common version with vDisk server",
5161                             vdc->instance);
5162                         status = ENOTSUP;
5163                 }
5164 
5165                 break;
5166         case VIO_SUBTYPE_INFO:
5167                 /*
5168                  * Handle the case where vds starts handshake
5169                  * (for now only vdc is the instigator)
5170                  */
5171                 status = ENOTSUP;
5172                 break;
5173 
5174         default:
5175                 status = EINVAL;
5176                 break;
5177         }
5178 
5179         return (status);
5180 }
5181 
5182 /*
5183  * Function:
5184  *      vdc_handle_attr_msg()
5185  *
5186  * Description:
5187  *
5188  * Arguments:
5189  *      vdc     - soft state pointer for this instance of the device driver.
5190  *      attr_msg        - LDC message sent by vDisk server
5191  *
5192  * Return Code:
5193  *      0       - Success
5194  */
5195 static int
5196 vdc_handle_attr_msg(vdc_t *vdc, vd_attr_msg_t *attr_msg)
5197 {
5198         int status = 0;
5199         vd_disk_type_t old_type;
5200 
5201         ASSERT(vdc != NULL);
5202         ASSERT(mutex_owned(&vdc->lock));
5203 
5204         if (attr_msg->tag.vio_subtype_env != VIO_ATTR_INFO) {
5205                 return (EPROTO);
5206         }
5207 
5208         switch (attr_msg->tag.vio_subtype) {
5209         case VIO_SUBTYPE_ACK:
5210                 /*
5211                  * We now verify the attributes sent by vds.
5212                  */
5213                 if (attr_msg->vdisk_size == 0) {
5214                         DMSG(vdc, 0, "[%d] Invalid disk size from vds",
5215                             vdc->instance);
5216                         status = EINVAL;
5217                         break;
5218                 }
5219 
5220                 if (attr_msg->max_xfer_sz == 0) {
5221                         DMSG(vdc, 0, "[%d] Invalid transfer size from vds",
5222                             vdc->instance);
5223                         status = EINVAL;
5224                         break;
5225                 }
5226 
5227                 if (attr_msg->vdisk_size == VD_SIZE_UNKNOWN) {
5228                         DMSG(vdc, 0, "[%d] Unknown disk size from vds",
5229                             vdc->instance);
5230                         attr_msg->vdisk_size = 0;
5231                 }
5232 
5233                 /* update the VIO block size */
5234                 if (attr_msg->vdisk_block_size > 0 &&
5235                     vdc_update_vio_bsize(vdc,
5236                     attr_msg->vdisk_block_size) != 0) {
5237                         DMSG(vdc, 0, "[%d] Invalid block size (%u) from vds",
5238                             vdc->instance, attr_msg->vdisk_block_size);
5239                         status = EINVAL;
5240                         break;
5241                 }
5242 
5243                 /* update disk, block and transfer sizes */
5244                 old_type = vdc->vdisk_type;
5245                 vdc_update_size(vdc, attr_msg->vdisk_size,
5246                     attr_msg->vdisk_block_size, attr_msg->max_xfer_sz);
5247                 vdc->vdisk_type = attr_msg->vdisk_type;
5248                 vdc->operations = attr_msg->operations;
5249                 if (vio_ver_is_supported(vdc->ver, 1, 1))
5250                         vdc->vdisk_media = attr_msg->vdisk_media;
5251                 else
5252                         vdc->vdisk_media = 0;
5253 
5254                 DMSG(vdc, 0, "[%d] max_xfer_sz: sent %lx acked %lx\n",
5255                     vdc->instance, vdc->max_xfer_sz, attr_msg->max_xfer_sz);
5256                 DMSG(vdc, 0, "[%d] vdisk_block_size: sent %lx acked %x\n",
5257                     vdc->instance, vdc->vdisk_bsize,
5258                     attr_msg->vdisk_block_size);
5259 
5260                 if ((attr_msg->xfer_mode != VIO_DRING_MODE_V1_0) ||
5261                     (attr_msg->vdisk_size > INT64_MAX) ||
5262                     (attr_msg->operations == 0) ||
5263                     (attr_msg->vdisk_type > VD_DISK_TYPE_DISK)) {
5264                         DMSG(vdc, 0, "[%d] Invalid attributes from vds",
5265                             vdc->instance);
5266                         status = EINVAL;
5267                         break;
5268                 }
5269 
5270                 /*
5271                  * Now that we have received all attributes we can create a
5272                  * fake geometry for the disk.
5273                  */
5274                 vdc_create_fake_geometry(vdc);
5275 
5276                 /*
5277                  * If the disk type was previously unknown and device nodes
5278                  * were created then the driver would have created 8 device
5279                  * nodes. If we now find out that this is a single-slice disk
5280                  * then we need to re-create the appropriate device nodes.
5281                  */
5282                 if (old_type == VD_DISK_TYPE_UNK &&
5283                     (vdc->initialized & VDC_MINOR) &&
5284                     vdc->vdisk_type == VD_DISK_TYPE_SLICE) {
5285                         ddi_remove_minor_node(vdc->dip, NULL);
5286                         (void) devfs_clean(ddi_get_parent(vdc->dip),
5287                             NULL, DV_CLEAN_FORCE);
5288                         if (vdc_create_device_nodes(vdc) != 0) {
5289                                 DMSG(vdc, 0, "![%d] Failed to update "
5290                                     "device nodes", vdc->instance);
5291                         }
5292                 }
5293 
5294                 break;
5295 
5296         case VIO_SUBTYPE_NACK:
5297                 /*
5298                  * vds could not handle the attributes we sent so we
5299                  * stop negotiating.
5300                  */
5301                 status = EPROTO;
5302                 break;
5303 
5304         case VIO_SUBTYPE_INFO:
5305                 /*
5306                  * Handle the case where vds starts the handshake
5307                  * (for now; vdc is the only supported instigatior)
5308                  */
5309                 status = ENOTSUP;
5310                 break;
5311 
5312         default:
5313                 status = ENOTSUP;
5314                 break;
5315         }
5316 
5317         return (status);
5318 }
5319 
5320 /*
5321  * Function:
5322  *      vdc_handle_dring_reg_msg()
5323  *
5324  * Description:
5325  *
5326  * Arguments:
5327  *      vdc             - soft state pointer for this instance of the driver.
5328  *      dring_msg       - LDC message sent by vDisk server
5329  *
5330  * Return Code:
5331  *      0       - Success
5332  */
5333 static int
5334 vdc_handle_dring_reg_msg(vdc_t *vdc, vio_dring_reg_msg_t *dring_msg)
5335 {
5336         int             status = 0;
5337 
5338         ASSERT(vdc != NULL);
5339         ASSERT(mutex_owned(&vdc->lock));
5340 
5341         if (dring_msg->tag.vio_subtype_env != VIO_DRING_REG) {
5342                 return (EPROTO);
5343         }
5344 
5345         switch (dring_msg->tag.vio_subtype) {
5346         case VIO_SUBTYPE_ACK:
5347                 /* save the received dring_ident */
5348                 vdc->dring_ident = dring_msg->dring_ident;
5349                 DMSG(vdc, 0, "[%d] Received dring ident=0x%lx\n",
5350                     vdc->instance, vdc->dring_ident);
5351                 break;
5352 
5353         case VIO_SUBTYPE_NACK:
5354                 /*
5355                  * vds could not handle the DRing info we sent so we
5356                  * stop negotiating.
5357                  */
5358                 DMSG(vdc, 0, "[%d] server could not register DRing\n",
5359                     vdc->instance);
5360                 status = EPROTO;
5361                 break;
5362 
5363         case VIO_SUBTYPE_INFO:
5364                 /*
5365                  * Handle the case where vds starts handshake
5366                  * (for now only vdc is the instigatior)
5367                  */
5368                 status = ENOTSUP;
5369                 break;
5370         default:
5371                 status = ENOTSUP;
5372         }
5373 
5374         return (status);
5375 }
5376 
5377 /*
5378  * Function:
5379  *      vdc_verify_seq_num()
5380  *
5381  * Description:
5382  *      This functions verifies that the sequence number sent back by the vDisk
5383  *      server with the latest message is what is expected (i.e. it is greater
5384  *      than the last seq num sent by the vDisk server and less than or equal
5385  *      to the last seq num generated by vdc).
5386  *
5387  *      It then checks the request ID to see if any requests need processing
5388  *      in the DRing.
5389  *
5390  * Arguments:
5391  *      vdc             - soft state pointer for this instance of the driver.
5392  *      dring_msg       - pointer to the LDC message sent by vds
5393  *
5394  * Return Code:
5395  *      VDC_SEQ_NUM_TODO        - Message needs to be processed
5396  *      VDC_SEQ_NUM_SKIP        - Message has already been processed
5397  *      VDC_SEQ_NUM_INVALID     - The seq numbers are so out of sync,
5398  *                                vdc cannot deal with them
5399  */
5400 static int
5401 vdc_verify_seq_num(vdc_t *vdc, vio_dring_msg_t *dring_msg)
5402 {
5403         ASSERT(vdc != NULL);
5404         ASSERT(dring_msg != NULL);
5405         ASSERT(mutex_owned(&vdc->lock));
5406 
5407         /*
5408          * Check to see if the messages were responded to in the correct
5409          * order by vds.
5410          */
5411         if ((dring_msg->seq_num <= vdc->seq_num_reply) ||
5412             (dring_msg->seq_num > vdc->seq_num)) {
5413                 DMSG(vdc, 0, "?[%d] Bogus sequence_number %lu: "
5414                     "%lu > expected <= %lu (last proc req %lu sent %lu)\n",
5415                     vdc->instance, dring_msg->seq_num,
5416                     vdc->seq_num_reply, vdc->seq_num,
5417                     vdc->req_id_proc, vdc->req_id);
5418                 return (VDC_SEQ_NUM_INVALID);
5419         }
5420         vdc->seq_num_reply = dring_msg->seq_num;
5421 
5422         if (vdc->req_id_proc < vdc->req_id)
5423                 return (VDC_SEQ_NUM_TODO);
5424         else
5425                 return (VDC_SEQ_NUM_SKIP);
5426 }
5427 
5428 
5429 /*
5430  * Function:
5431  *      vdc_is_supported_version()
5432  *
5433  * Description:
5434  *      This routine checks if the major/minor version numbers specified in
5435  *      'ver_msg' are supported. If not it finds the next version that is
5436  *      in the supported version list 'vdc_version[]' and sets the fields in
5437  *      'ver_msg' to those values
5438  *
5439  * Arguments:
5440  *      ver_msg - LDC message sent by vDisk server
5441  *
5442  * Return Code:
5443  *      B_TRUE  - Success
5444  *      B_FALSE - Version not supported
5445  */
5446 static boolean_t
5447 vdc_is_supported_version(vio_ver_msg_t *ver_msg)
5448 {
5449         int vdc_num_versions = sizeof (vdc_version) / sizeof (vdc_version[0]);
5450 
5451         for (int i = 0; i < vdc_num_versions; i++) {
5452                 ASSERT(vdc_version[i].major > 0);
5453                 ASSERT((i == 0) ||
5454                     (vdc_version[i].major < vdc_version[i-1].major));
5455 
5456                 /*
5457                  * If the major versions match, adjust the minor version, if
5458                  * necessary, down to the highest value supported by this
5459                  * client. The server should support all minor versions lower
5460                  * than the value it sent
5461                  */
5462                 if (ver_msg->ver_major == vdc_version[i].major) {
5463                         if (ver_msg->ver_minor > vdc_version[i].minor) {
5464                                 DMSGX(0,
5465                                     "Adjusting minor version from %u to %u",
5466                                     ver_msg->ver_minor, vdc_version[i].minor);
5467                                 ver_msg->ver_minor = vdc_version[i].minor;
5468                         }
5469                         return (B_TRUE);
5470                 }
5471 
5472                 /*
5473                  * If the message contains a higher major version number, set
5474                  * the message's major/minor versions to the current values
5475                  * and return false, so this message will get resent with
5476                  * these values, and the server will potentially try again
5477                  * with the same or a lower version
5478                  */
5479                 if (ver_msg->ver_major > vdc_version[i].major) {
5480                         ver_msg->ver_major = vdc_version[i].major;
5481                         ver_msg->ver_minor = vdc_version[i].minor;
5482                         DMSGX(0, "Suggesting major/minor (0x%x/0x%x)\n",
5483                             ver_msg->ver_major, ver_msg->ver_minor);
5484 
5485                         return (B_FALSE);
5486                 }
5487 
5488                 /*
5489                  * Otherwise, the message's major version is less than the
5490                  * current major version, so continue the loop to the next
5491                  * (lower) supported version
5492                  */
5493         }
5494 
5495         /*
5496          * No common version was found; "ground" the version pair in the
5497          * message to terminate negotiation
5498          */
5499         ver_msg->ver_major = 0;
5500         ver_msg->ver_minor = 0;
5501 
5502         return (B_FALSE);
5503 }
5504 /* -------------------------------------------------------------------------- */
5505 
5506 /*
5507  * DKIO(7) support
5508  */
5509 
5510 typedef struct vdc_dk_arg {
5511         struct dk_callback      dkc;
5512         int                     mode;
5513         dev_t                   dev;
5514         vdc_t                   *vdc;
5515 } vdc_dk_arg_t;
5516 
5517 /*
5518  * Function:
5519  *      vdc_dkio_flush_cb()
5520  *
5521  * Description:
5522  *      This routine is a callback for DKIOCFLUSHWRITECACHE which can be called
5523  *      by kernel code.
5524  *
5525  * Arguments:
5526  *      arg     - a pointer to a vdc_dk_arg_t structure.
5527  */
5528 void
5529 vdc_dkio_flush_cb(void *arg)
5530 {
5531         struct vdc_dk_arg       *dk_arg = (struct vdc_dk_arg *)arg;
5532         struct dk_callback      *dkc = NULL;
5533         vdc_t                   *vdc = NULL;
5534         int                     rv;
5535 
5536         if (dk_arg == NULL) {
5537                 cmn_err(CE_NOTE, "?[Unk] DKIOCFLUSHWRITECACHE arg is NULL\n");
5538                 return;
5539         }
5540         dkc = &dk_arg->dkc;
5541         vdc = dk_arg->vdc;
5542         ASSERT(vdc != NULL);
5543 
5544         rv = vdc_do_sync_op(vdc, VD_OP_FLUSH, NULL, 0,
5545             VDCPART(dk_arg->dev), 0, VIO_both_dir, B_TRUE);
5546         if (rv != 0) {
5547                 DMSG(vdc, 0, "[%d] DKIOCFLUSHWRITECACHE failed %d : model %x\n",
5548                     vdc->instance, rv,
5549                     ddi_model_convert_from(dk_arg->mode & FMODELS));
5550         }
5551 
5552         /*
5553          * Trigger the call back to notify the caller the the ioctl call has
5554          * been completed.
5555          */
5556         if ((dk_arg->mode & FKIOCTL) &&
5557             (dkc != NULL) &&
5558             (dkc->dkc_callback != NULL)) {
5559                 ASSERT(dkc->dkc_cookie != NULL);
5560                 (*dkc->dkc_callback)(dkc->dkc_cookie, rv);
5561         }
5562 
5563         /* Indicate that one less DKIO write flush is outstanding */
5564         mutex_enter(&vdc->lock);
5565         vdc->dkio_flush_pending--;
5566         ASSERT(vdc->dkio_flush_pending >= 0);
5567         mutex_exit(&vdc->lock);
5568 
5569         /* free the mem that was allocated when the callback was dispatched */
5570         kmem_free(arg, sizeof (vdc_dk_arg_t));
5571 }
5572 
5573 /*
5574  * Function:
5575  *      vdc_dkio_gapart()
5576  *
5577  * Description:
5578  *      This function implements the DKIOCGAPART ioctl.
5579  *
5580  * Arguments:
5581  *      vdc     - soft state pointer
5582  *      arg     - a pointer to a dk_map[NDKMAP] or dk_map32[NDKMAP] structure
5583  *      flag    - ioctl flags
5584  */
5585 static int
5586 vdc_dkio_gapart(vdc_t *vdc, caddr_t arg, int flag)
5587 {
5588         struct dk_geom *geom;
5589         struct extvtoc *vtoc;
5590         union {
5591                 struct dk_map map[NDKMAP];
5592                 struct dk_map32 map32[NDKMAP];
5593         } data;
5594         int i, rv, size;
5595 
5596         mutex_enter(&vdc->lock);
5597 
5598         if ((rv = vdc_validate_geometry(vdc)) != 0) {
5599                 mutex_exit(&vdc->lock);
5600                 return (rv);
5601         }
5602 
5603         if (vdc->vdisk_size > VD_OLDVTOC_LIMIT) {
5604                 mutex_exit(&vdc->lock);
5605                 return (EOVERFLOW);
5606         }
5607 
5608         vtoc = vdc->vtoc;
5609         geom = vdc->geom;
5610 
5611         if (ddi_model_convert_from(flag & FMODELS) == DDI_MODEL_ILP32) {
5612 
5613                 for (i = 0; i < vtoc->v_nparts; i++) {
5614                         data.map32[i].dkl_cylno = vtoc->v_part[i].p_start /
5615                             (geom->dkg_nhead * geom->dkg_nsect);
5616                         data.map32[i].dkl_nblk = vtoc->v_part[i].p_size;
5617                 }
5618                 size = NDKMAP * sizeof (struct dk_map32);
5619 
5620         } else {
5621 
5622                 for (i = 0; i < vtoc->v_nparts; i++) {
5623                         data.map[i].dkl_cylno = vtoc->v_part[i].p_start /
5624                             (geom->dkg_nhead * geom->dkg_nsect);
5625                         data.map[i].dkl_nblk = vtoc->v_part[i].p_size;
5626                 }
5627                 size = NDKMAP * sizeof (struct dk_map);
5628 
5629         }
5630 
5631         mutex_exit(&vdc->lock);
5632 
5633         if (ddi_copyout(&data, arg, size, flag) != 0)
5634                 return (EFAULT);
5635 
5636         return (0);
5637 }
5638 
5639 /*
5640  * Function:
5641  *      vdc_dkio_partition()
5642  *
5643  * Description:
5644  *      This function implements the DKIOCPARTITION ioctl.
5645  *
5646  * Arguments:
5647  *      vdc     - soft state pointer
5648  *      arg     - a pointer to a struct partition64 structure
5649  *      flag    - ioctl flags
5650  */
5651 static int
5652 vdc_dkio_partition(vdc_t *vdc, caddr_t arg, int flag)
5653 {
5654         struct partition64 p64;
5655         efi_gpt_t *gpt;
5656         efi_gpe_t *gpe;
5657         vd_efi_dev_t edev;
5658         uint_t partno;
5659         int rv;
5660 
5661         if (ddi_copyin(arg, &p64, sizeof (struct partition64), flag)) {
5662                 return (EFAULT);
5663         }
5664 
5665         VDC_EFI_DEV_SET(edev, vdc, vd_process_efi_ioctl);
5666 
5667         if ((rv = vd_efi_alloc_and_read(&edev, &gpt, &gpe)) != 0) {
5668                 return (rv);
5669         }
5670 
5671         partno = p64.p_partno;
5672 
5673         if (partno >= gpt->efi_gpt_NumberOfPartitionEntries) {
5674                 vd_efi_free(&edev, gpt, gpe);
5675                 return (ESRCH);
5676         }
5677 
5678         bcopy(&gpe[partno].efi_gpe_PartitionTypeGUID, &p64.p_type,
5679             sizeof (struct uuid));
5680         p64.p_start = gpe[partno].efi_gpe_StartingLBA;
5681         p64.p_size = gpe[partno].efi_gpe_EndingLBA - p64.p_start + 1;
5682 
5683         if (ddi_copyout(&p64, arg, sizeof (struct partition64), flag)) {
5684                 vd_efi_free(&edev, gpt, gpe);
5685                 return (EFAULT);
5686         }
5687 
5688         vd_efi_free(&edev, gpt, gpe);
5689         return (0);
5690 }
5691 
5692 /*
5693  * Function:
5694  *      vdc_dioctl_rwcmd()
5695  *
5696  * Description:
5697  *      This function implements the DIOCTL_RWCMD ioctl. This ioctl is used
5698  *      for DKC_DIRECT disks to read or write at an absolute disk offset.
5699  *
5700  * Arguments:
5701  *      dev     - device
5702  *      arg     - a pointer to a dadkio_rwcmd or dadkio_rwcmd32 structure
5703  *      flag    - ioctl flags
5704  */
5705 static int
5706 vdc_dioctl_rwcmd(vdc_t *vdc, caddr_t arg, int flag)
5707 {
5708         struct dadkio_rwcmd32 rwcmd32;
5709         struct dadkio_rwcmd rwcmd;
5710         struct iovec aiov;
5711         struct uio auio;
5712         int rw, status;
5713         struct buf *buf;
5714 
5715         if (ddi_model_convert_from(flag & FMODELS) == DDI_MODEL_ILP32) {
5716                 if (ddi_copyin((caddr_t)arg, (caddr_t)&rwcmd32,
5717                     sizeof (struct dadkio_rwcmd32), flag)) {
5718                         return (EFAULT);
5719                 }
5720                 rwcmd.cmd = rwcmd32.cmd;
5721                 rwcmd.flags = rwcmd32.flags;
5722                 rwcmd.blkaddr = (daddr_t)rwcmd32.blkaddr;
5723                 rwcmd.buflen = rwcmd32.buflen;
5724                 rwcmd.bufaddr = (caddr_t)(uintptr_t)rwcmd32.bufaddr;
5725         } else {
5726                 if (ddi_copyin((caddr_t)arg, (caddr_t)&rwcmd,
5727                     sizeof (struct dadkio_rwcmd), flag)) {
5728                         return (EFAULT);
5729                 }
5730         }
5731 
5732         switch (rwcmd.cmd) {
5733         case DADKIO_RWCMD_READ:
5734                 rw = B_READ;
5735                 break;
5736         case DADKIO_RWCMD_WRITE:
5737                 rw = B_WRITE;
5738                 break;
5739         default:
5740                 return (EINVAL);
5741         }
5742 
5743         bzero((caddr_t)&aiov, sizeof (struct iovec));
5744         aiov.iov_base   = rwcmd.bufaddr;
5745         aiov.iov_len    = rwcmd.buflen;
5746 
5747         bzero((caddr_t)&auio, sizeof (struct uio));
5748         auio.uio_iov    = &aiov;
5749         auio.uio_iovcnt = 1;
5750         auio.uio_loffset = rwcmd.blkaddr * vdc->vdisk_bsize;
5751         auio.uio_resid  = rwcmd.buflen;
5752         auio.uio_segflg = flag & FKIOCTL ? UIO_SYSSPACE : UIO_USERSPACE;
5753 
5754         buf = kmem_alloc(sizeof (buf_t), KM_SLEEP);
5755         bioinit(buf);
5756         /*
5757          * We use the private field of buf to specify that this is an
5758          * I/O using an absolute offset.
5759          */
5760         buf->b_private = (void *)VD_SLICE_NONE;
5761 
5762         status = physio(vdc_strategy, buf, VD_MAKE_DEV(vdc->instance, 0),
5763             rw, vdc_min, &auio);
5764 
5765         biofini(buf);
5766         kmem_free(buf, sizeof (buf_t));
5767 
5768         return (status);
5769 }
5770 
5771 /*
5772  * Allocate a buffer for a VD_OP_SCSICMD operation. The size of the allocated
5773  * buffer is returned in alloc_len.
5774  */
5775 static vd_scsi_t *
5776 vdc_scsi_alloc(int cdb_len, int sense_len, int datain_len, int dataout_len,
5777     int *alloc_len)
5778 {
5779         vd_scsi_t *vd_scsi;
5780         int vd_scsi_len = VD_SCSI_SIZE;
5781 
5782         vd_scsi_len += P2ROUNDUP(cdb_len, sizeof (uint64_t));
5783         vd_scsi_len += P2ROUNDUP(sense_len, sizeof (uint64_t));
5784         vd_scsi_len += P2ROUNDUP(datain_len, sizeof (uint64_t));
5785         vd_scsi_len += P2ROUNDUP(dataout_len, sizeof (uint64_t));
5786 
5787         ASSERT(vd_scsi_len % sizeof (uint64_t) == 0);
5788 
5789         vd_scsi = kmem_zalloc(vd_scsi_len, KM_SLEEP);
5790 
5791         vd_scsi->cdb_len = cdb_len;
5792         vd_scsi->sense_len = sense_len;
5793         vd_scsi->datain_len = datain_len;
5794         vd_scsi->dataout_len = dataout_len;
5795 
5796         *alloc_len = vd_scsi_len;
5797 
5798         return (vd_scsi);
5799 }
5800 
5801 /*
5802  * Convert the status of a SCSI command to a Solaris return code.
5803  *
5804  * Arguments:
5805  *      vd_scsi         - The SCSI operation buffer.
5806  *      log_error       - indicate if an error message should be logged.
5807  *
5808  * Note that our SCSI error messages are rather primitive for the moment
5809  * and could be improved by decoding some data like the SCSI command and
5810  * the sense key.
5811  *
5812  * Return value:
5813  *      0               - Status is good.
5814  *      EACCES          - Status reports a reservation conflict.
5815  *      ENOTSUP         - Status reports a check condition and sense key
5816  *                        reports an illegal request.
5817  *      EIO             - Any other status.
5818  */
5819 static int
5820 vdc_scsi_status(vdc_t *vdc, vd_scsi_t *vd_scsi, boolean_t log_error)
5821 {
5822         int rv;
5823         char path_str[MAXPATHLEN];
5824         char panic_str[VDC_RESV_CONFLICT_FMT_LEN + MAXPATHLEN];
5825         union scsi_cdb *cdb;
5826         struct scsi_extended_sense *sense;
5827 
5828         if (vd_scsi->cmd_status == STATUS_GOOD)
5829                 /* no error */
5830                 return (0);
5831 
5832         /* when the tunable vdc_scsi_log_error is true we log all errors */
5833         if (vdc_scsi_log_error)
5834                 log_error = B_TRUE;
5835 
5836         if (log_error) {
5837                 cmn_err(CE_WARN, "%s (vdc%d):\tError for Command: 0x%x)\n",
5838                     ddi_pathname(vdc->dip, path_str), vdc->instance,
5839                     GETCMD(VD_SCSI_DATA_CDB(vd_scsi)));
5840         }
5841 
5842         /* default returned value */
5843         rv = EIO;
5844 
5845         switch (vd_scsi->cmd_status) {
5846 
5847         case STATUS_CHECK:
5848         case STATUS_TERMINATED:
5849                 if (log_error)
5850                         cmn_err(CE_CONT, "\tCheck Condition Error\n");
5851 
5852                 /* check sense buffer */
5853                 if (vd_scsi->sense_len == 0 ||
5854                     vd_scsi->sense_status != STATUS_GOOD) {
5855                         if (log_error)
5856                                 cmn_err(CE_CONT, "\tNo Sense Data Available\n");
5857                         break;
5858                 }
5859 
5860                 sense = VD_SCSI_DATA_SENSE(vd_scsi);
5861 
5862                 if (log_error) {
5863                         cmn_err(CE_CONT, "\tSense Key:  0x%x\n"
5864                             "\tASC: 0x%x, ASCQ: 0x%x\n",
5865                             scsi_sense_key((uint8_t *)sense),
5866                             scsi_sense_asc((uint8_t *)sense),
5867                             scsi_sense_ascq((uint8_t *)sense));
5868                 }
5869 
5870                 if (scsi_sense_key((uint8_t *)sense) == KEY_ILLEGAL_REQUEST)
5871                         rv = ENOTSUP;
5872                 break;
5873 
5874         case STATUS_BUSY:
5875                 if (log_error)
5876                         cmn_err(CE_NOTE, "\tDevice Busy\n");
5877                 break;
5878 
5879         case STATUS_RESERVATION_CONFLICT:
5880                 /*
5881                  * If the command was PERSISTENT_RESERVATION_[IN|OUT] then
5882                  * reservation conflict could be due to various reasons like
5883                  * incorrect keys, not registered or not reserved etc. So,
5884                  * we should not panic in that case.
5885                  */
5886                 cdb = VD_SCSI_DATA_CDB(vd_scsi);
5887                 if (vdc->failfast_interval != 0 &&
5888                     cdb->scc_cmd != SCMD_PERSISTENT_RESERVE_IN &&
5889                     cdb->scc_cmd != SCMD_PERSISTENT_RESERVE_OUT) {
5890                         /* failfast is enabled so we have to panic */
5891                         (void) snprintf(panic_str, sizeof (panic_str),
5892                             VDC_RESV_CONFLICT_FMT_STR "%s",
5893                             ddi_pathname(vdc->dip, path_str));
5894                         panic(panic_str);
5895                 }
5896                 if (log_error)
5897                         cmn_err(CE_NOTE, "\tReservation Conflict\n");
5898                 rv = EACCES;
5899                 break;
5900 
5901         case STATUS_QFULL:
5902                 if (log_error)
5903                         cmn_err(CE_NOTE, "\tQueue Full\n");
5904                 break;
5905 
5906         case STATUS_MET:
5907         case STATUS_INTERMEDIATE:
5908         case STATUS_SCSI2:
5909         case STATUS_INTERMEDIATE_MET:
5910         case STATUS_ACA_ACTIVE:
5911                 if (log_error)
5912                         cmn_err(CE_CONT,
5913                             "\tUnexpected SCSI status received: 0x%x\n",
5914                             vd_scsi->cmd_status);
5915                 break;
5916 
5917         default:
5918                 if (log_error)
5919                         cmn_err(CE_CONT,
5920                             "\tInvalid SCSI status received: 0x%x\n",
5921                             vd_scsi->cmd_status);
5922                 break;
5923         }
5924 
5925         return (rv);
5926 }
5927 
5928 /*
5929  * Implemented the USCSICMD uscsi(7I) ioctl. This ioctl is converted to
5930  * a VD_OP_SCSICMD operation which is sent to the vdisk server. If a SCSI
5931  * reset is requested (i.e. a flag USCSI_RESET* is set) then the ioctl is
5932  * converted to a VD_OP_RESET operation.
5933  */
5934 static int
5935 vdc_uscsi_cmd(vdc_t *vdc, caddr_t arg, int mode)
5936 {
5937         struct uscsi_cmd        uscsi;
5938         struct uscsi_cmd32      uscsi32;
5939         vd_scsi_t               *vd_scsi;
5940         int                     vd_scsi_len;
5941         union scsi_cdb          *cdb;
5942         struct scsi_extended_sense *sense;
5943         char                    *datain, *dataout;
5944         size_t                  cdb_len, datain_len, dataout_len, sense_len;
5945         int                     rv;
5946 
5947         if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
5948                 if (ddi_copyin(arg, &uscsi32, sizeof (struct uscsi_cmd32),
5949                     mode) != 0)
5950                         return (EFAULT);
5951                 uscsi_cmd32touscsi_cmd((&uscsi32), (&uscsi));
5952         } else {
5953                 if (ddi_copyin(arg, &uscsi, sizeof (struct uscsi_cmd),
5954                     mode) != 0)
5955                         return (EFAULT);
5956         }
5957 
5958         /* a uscsi reset is converted to a VD_OP_RESET operation */
5959         if (uscsi.uscsi_flags & (USCSI_RESET | USCSI_RESET_LUN |
5960             USCSI_RESET_ALL)) {
5961                 rv = vdc_do_sync_op(vdc, VD_OP_RESET, NULL, 0, 0, 0,
5962                     VIO_both_dir, B_TRUE);
5963                 return (rv);
5964         }
5965 
5966         /* cdb buffer length */
5967         cdb_len = uscsi.uscsi_cdblen;
5968 
5969         /* data in and out buffers length */
5970         if (uscsi.uscsi_flags & USCSI_READ) {
5971                 datain_len = uscsi.uscsi_buflen;
5972                 dataout_len = 0;
5973         } else {
5974                 datain_len = 0;
5975                 dataout_len = uscsi.uscsi_buflen;
5976         }
5977 
5978         /* sense buffer length */
5979         if (uscsi.uscsi_flags & USCSI_RQENABLE)
5980                 sense_len = uscsi.uscsi_rqlen;
5981         else
5982                 sense_len = 0;
5983 
5984         /* allocate buffer for the VD_SCSICMD_OP operation */
5985         vd_scsi = vdc_scsi_alloc(cdb_len, sense_len, datain_len, dataout_len,
5986             &vd_scsi_len);
5987 
5988         /*
5989          * The documentation of USCSI_ISOLATE and USCSI_DIAGNOSE is very vague,
5990          * but basically they prevent a SCSI command from being retried in case
5991          * of an error.
5992          */
5993         if ((uscsi.uscsi_flags & USCSI_ISOLATE) ||
5994             (uscsi.uscsi_flags & USCSI_DIAGNOSE))
5995                 vd_scsi->options |= VD_SCSI_OPT_NORETRY;
5996 
5997         /* set task attribute */
5998         if (uscsi.uscsi_flags & USCSI_NOTAG) {
5999                 vd_scsi->task_attribute = 0;
6000         } else {
6001                 if (uscsi.uscsi_flags & USCSI_HEAD)
6002                         vd_scsi->task_attribute = VD_SCSI_TASK_ACA;
6003                 else if (uscsi.uscsi_flags & USCSI_HTAG)
6004                         vd_scsi->task_attribute = VD_SCSI_TASK_HQUEUE;
6005                 else if (uscsi.uscsi_flags & USCSI_OTAG)
6006                         vd_scsi->task_attribute = VD_SCSI_TASK_ORDERED;
6007                 else
6008                         vd_scsi->task_attribute = 0;
6009         }
6010 
6011         /* set timeout */
6012         vd_scsi->timeout = uscsi.uscsi_timeout;
6013 
6014         /* copy-in cdb data */
6015         cdb = VD_SCSI_DATA_CDB(vd_scsi);
6016         if (ddi_copyin(uscsi.uscsi_cdb, cdb, cdb_len, mode) != 0) {
6017                 rv = EFAULT;
6018                 goto done;
6019         }
6020 
6021         /* keep a pointer to the sense buffer */
6022         sense = VD_SCSI_DATA_SENSE(vd_scsi);
6023 
6024         /* keep a pointer to the data-in buffer */
6025         datain = (char *)VD_SCSI_DATA_IN(vd_scsi);
6026 
6027         /* copy-in request data to the data-out buffer */
6028         dataout = (char *)VD_SCSI_DATA_OUT(vd_scsi);
6029         if (!(uscsi.uscsi_flags & USCSI_READ)) {
6030                 if (ddi_copyin(uscsi.uscsi_bufaddr, dataout, dataout_len,
6031                     mode)) {
6032                         rv = EFAULT;
6033                         goto done;
6034                 }
6035         }
6036 
6037         /* submit the request */
6038         rv = vdc_do_sync_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6039             0, 0, VIO_both_dir, B_FALSE);
6040 
6041         if (rv != 0)
6042                 goto done;
6043 
6044         /* update scsi status */
6045         uscsi.uscsi_status = vd_scsi->cmd_status;
6046 
6047         /* update sense data */
6048         if ((uscsi.uscsi_flags & USCSI_RQENABLE) &&
6049             (uscsi.uscsi_status == STATUS_CHECK ||
6050             uscsi.uscsi_status == STATUS_TERMINATED)) {
6051 
6052                 uscsi.uscsi_rqstatus = vd_scsi->sense_status;
6053 
6054                 if (uscsi.uscsi_rqstatus == STATUS_GOOD) {
6055                         uscsi.uscsi_rqresid = uscsi.uscsi_rqlen -
6056                             vd_scsi->sense_len;
6057                         if (ddi_copyout(sense, uscsi.uscsi_rqbuf,
6058                             vd_scsi->sense_len, mode) != 0) {
6059                                 rv = EFAULT;
6060                                 goto done;
6061                         }
6062                 }
6063         }
6064 
6065         /* update request data */
6066         if (uscsi.uscsi_status == STATUS_GOOD) {
6067                 if (uscsi.uscsi_flags & USCSI_READ) {
6068                         uscsi.uscsi_resid = uscsi.uscsi_buflen -
6069                             vd_scsi->datain_len;
6070                         if (ddi_copyout(datain, uscsi.uscsi_bufaddr,
6071                             vd_scsi->datain_len, mode) != 0) {
6072                                 rv = EFAULT;
6073                                 goto done;
6074                         }
6075                 } else {
6076                         uscsi.uscsi_resid = uscsi.uscsi_buflen -
6077                             vd_scsi->dataout_len;
6078                 }
6079         }
6080 
6081         /* copy-out result */
6082         if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
6083                 uscsi_cmdtouscsi_cmd32((&uscsi), (&uscsi32));
6084                 if (ddi_copyout(&uscsi32, arg, sizeof (struct uscsi_cmd32),
6085                     mode) != 0) {
6086                         rv = EFAULT;
6087                         goto done;
6088                 }
6089         } else {
6090                 if (ddi_copyout(&uscsi, arg, sizeof (struct uscsi_cmd),
6091                     mode) != 0) {
6092                         rv = EFAULT;
6093                         goto done;
6094                 }
6095         }
6096 
6097         /* get the return code from the SCSI command status */
6098         rv = vdc_scsi_status(vdc, vd_scsi,
6099             !(uscsi.uscsi_flags & USCSI_SILENT));
6100 
6101 done:
6102         kmem_free(vd_scsi, vd_scsi_len);
6103         return (rv);
6104 }
6105 
6106 /*
6107  * Create a VD_OP_SCSICMD buffer for a SCSI PERSISTENT IN command.
6108  *
6109  * Arguments:
6110  *      cmd             - SCSI PERSISTENT IN command
6111  *      len             - length of the SCSI input buffer
6112  *      vd_scsi_len     - return the length of the allocated buffer
6113  *
6114  * Returned Value:
6115  *      a pointer to the allocated VD_OP_SCSICMD buffer.
6116  */
6117 static vd_scsi_t *
6118 vdc_scsi_alloc_persistent_in(uchar_t cmd, int len, int *vd_scsi_len)
6119 {
6120         int cdb_len, sense_len, datain_len, dataout_len;
6121         vd_scsi_t *vd_scsi;
6122         union scsi_cdb *cdb;
6123 
6124         cdb_len = CDB_GROUP1;
6125         sense_len = sizeof (struct scsi_extended_sense);
6126         datain_len = len;
6127         dataout_len = 0;
6128 
6129         vd_scsi = vdc_scsi_alloc(cdb_len, sense_len, datain_len, dataout_len,
6130             vd_scsi_len);
6131 
6132         cdb = VD_SCSI_DATA_CDB(vd_scsi);
6133 
6134         /* set cdb */
6135         cdb->scc_cmd = SCMD_PERSISTENT_RESERVE_IN;
6136         cdb->cdb_opaque[1] = cmd;
6137         FORMG1COUNT(cdb, datain_len);
6138 
6139         vd_scsi->timeout = vdc_scsi_timeout;
6140 
6141         return (vd_scsi);
6142 }
6143 
6144 /*
6145  * Create a VD_OP_SCSICMD buffer for a SCSI PERSISTENT OUT command.
6146  *
6147  * Arguments:
6148  *      cmd             - SCSI PERSISTENT OUT command
6149  *      len             - length of the SCSI output buffer
6150  *      vd_scsi_len     - return the length of the allocated buffer
6151  *
6152  * Returned Code:
6153  *      a pointer to the allocated VD_OP_SCSICMD buffer.
6154  */
6155 static vd_scsi_t *
6156 vdc_scsi_alloc_persistent_out(uchar_t cmd, int len, int *vd_scsi_len)
6157 {
6158         int cdb_len, sense_len, datain_len, dataout_len;
6159         vd_scsi_t *vd_scsi;
6160         union scsi_cdb *cdb;
6161 
6162         cdb_len = CDB_GROUP1;
6163         sense_len = sizeof (struct scsi_extended_sense);
6164         datain_len = 0;
6165         dataout_len = len;
6166 
6167         vd_scsi = vdc_scsi_alloc(cdb_len, sense_len, datain_len, dataout_len,
6168             vd_scsi_len);
6169 
6170         cdb = VD_SCSI_DATA_CDB(vd_scsi);
6171 
6172         /* set cdb */
6173         cdb->scc_cmd = SCMD_PERSISTENT_RESERVE_OUT;
6174         cdb->cdb_opaque[1] = cmd;
6175         FORMG1COUNT(cdb, dataout_len);
6176 
6177         vd_scsi->timeout = vdc_scsi_timeout;
6178 
6179         return (vd_scsi);
6180 }
6181 
6182 /*
6183  * Implement the MHIOCGRP_INKEYS mhd(7i) ioctl. The ioctl is converted
6184  * to a SCSI PERSISTENT IN READ KEYS command which is sent to the vdisk
6185  * server with a VD_OP_SCSICMD operation.
6186  */
6187 static int
6188 vdc_mhd_inkeys(vdc_t *vdc, caddr_t arg, int mode)
6189 {
6190         vd_scsi_t *vd_scsi;
6191         mhioc_inkeys_t inkeys;
6192         mhioc_key_list_t klist;
6193         struct mhioc_inkeys32 inkeys32;
6194         struct mhioc_key_list32 klist32;
6195         sd_prin_readkeys_t *scsi_keys;
6196         void *user_keys;
6197         int vd_scsi_len;
6198         int listsize, listlen, rv;
6199 
6200         /* copyin arguments */
6201         if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
6202                 rv = ddi_copyin(arg, &inkeys32, sizeof (inkeys32), mode);
6203                 if (rv != 0)
6204                         return (EFAULT);
6205 
6206                 rv = ddi_copyin((caddr_t)(uintptr_t)inkeys32.li, &klist32,
6207                     sizeof (klist32), mode);
6208                 if (rv != 0)
6209                         return (EFAULT);
6210 
6211                 listsize = klist32.listsize;
6212         } else {
6213                 rv = ddi_copyin(arg, &inkeys, sizeof (inkeys), mode);
6214                 if (rv != 0)
6215                         return (EFAULT);
6216 
6217                 rv = ddi_copyin(inkeys.li, &klist, sizeof (klist), mode);
6218                 if (rv != 0)
6219                         return (EFAULT);
6220 
6221                 listsize = klist.listsize;
6222         }
6223 
6224         /* build SCSI VD_OP request */
6225         vd_scsi = vdc_scsi_alloc_persistent_in(SD_READ_KEYS,
6226             sizeof (sd_prin_readkeys_t) - sizeof (caddr_t) +
6227             (sizeof (mhioc_resv_key_t) * listsize), &vd_scsi_len);
6228 
6229         scsi_keys = (sd_prin_readkeys_t *)VD_SCSI_DATA_IN(vd_scsi);
6230 
6231         /* submit the request */
6232         rv = vdc_do_sync_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6233             0, 0, VIO_both_dir, B_FALSE);
6234 
6235         if (rv != 0)
6236                 goto done;
6237 
6238         listlen = scsi_keys->len / MHIOC_RESV_KEY_SIZE;
6239 
6240         if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
6241                 inkeys32.generation = scsi_keys->generation;
6242                 rv = ddi_copyout(&inkeys32, arg, sizeof (inkeys32), mode);
6243                 if (rv != 0) {
6244                         rv = EFAULT;
6245                         goto done;
6246                 }
6247 
6248                 klist32.listlen = listlen;
6249                 rv = ddi_copyout(&klist32, (caddr_t)(uintptr_t)inkeys32.li,
6250                     sizeof (klist32), mode);
6251                 if (rv != 0) {
6252                         rv = EFAULT;
6253                         goto done;
6254                 }
6255 
6256                 user_keys = (caddr_t)(uintptr_t)klist32.list;
6257         } else {
6258                 inkeys.generation = scsi_keys->generation;
6259                 rv = ddi_copyout(&inkeys, arg, sizeof (inkeys), mode);
6260                 if (rv != 0) {
6261                         rv = EFAULT;
6262                         goto done;
6263                 }
6264 
6265                 klist.listlen = listlen;
6266                 rv = ddi_copyout(&klist, inkeys.li, sizeof (klist), mode);
6267                 if (rv != 0) {
6268                         rv = EFAULT;
6269                         goto done;
6270                 }
6271 
6272                 user_keys = klist.list;
6273         }
6274 
6275         /* copy out keys */
6276         if (listlen > 0 && listsize > 0) {
6277                 if (listsize < listlen)
6278                         listlen = listsize;
6279                 rv = ddi_copyout(&scsi_keys->keylist, user_keys,
6280                     listlen * MHIOC_RESV_KEY_SIZE, mode);
6281                 if (rv != 0)
6282                         rv = EFAULT;
6283         }
6284 
6285         if (rv == 0)
6286                 rv = vdc_scsi_status(vdc, vd_scsi, B_FALSE);
6287 
6288 done:
6289         kmem_free(vd_scsi, vd_scsi_len);
6290 
6291         return (rv);
6292 }
6293 
6294 /*
6295  * Implement the MHIOCGRP_INRESV mhd(7i) ioctl. The ioctl is converted
6296  * to a SCSI PERSISTENT IN READ RESERVATION command which is sent to
6297  * the vdisk server with a VD_OP_SCSICMD operation.
6298  */
6299 static int
6300 vdc_mhd_inresv(vdc_t *vdc, caddr_t arg, int mode)
6301 {
6302         vd_scsi_t *vd_scsi;
6303         mhioc_inresvs_t inresv;
6304         mhioc_resv_desc_list_t rlist;
6305         struct mhioc_inresvs32 inresv32;
6306         struct mhioc_resv_desc_list32 rlist32;
6307         mhioc_resv_desc_t mhd_resv;
6308         sd_prin_readresv_t *scsi_resv;
6309         sd_readresv_desc_t *resv;
6310         mhioc_resv_desc_t *user_resv;
6311         int vd_scsi_len;
6312         int listsize, listlen, i, rv;
6313 
6314         /* copyin arguments */
6315         if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
6316                 rv = ddi_copyin(arg, &inresv32, sizeof (inresv32), mode);
6317                 if (rv != 0)
6318                         return (EFAULT);
6319 
6320                 rv = ddi_copyin((caddr_t)(uintptr_t)inresv32.li, &rlist32,
6321                     sizeof (rlist32), mode);
6322                 if (rv != 0)
6323                         return (EFAULT);
6324 
6325                 listsize = rlist32.listsize;
6326         } else {
6327                 rv = ddi_copyin(arg, &inresv, sizeof (inresv), mode);
6328                 if (rv != 0)
6329                         return (EFAULT);
6330 
6331                 rv = ddi_copyin(inresv.li, &rlist, sizeof (rlist), mode);
6332                 if (rv != 0)
6333                         return (EFAULT);
6334 
6335                 listsize = rlist.listsize;
6336         }
6337 
6338         /* build SCSI VD_OP request */
6339         vd_scsi = vdc_scsi_alloc_persistent_in(SD_READ_RESV,
6340             sizeof (sd_prin_readresv_t) - sizeof (caddr_t) +
6341             (SCSI3_RESV_DESC_LEN * listsize), &vd_scsi_len);
6342 
6343         scsi_resv = (sd_prin_readresv_t *)VD_SCSI_DATA_IN(vd_scsi);
6344 
6345         /* submit the request */
6346         rv = vdc_do_sync_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6347             0, 0, VIO_both_dir, B_FALSE);
6348 
6349         if (rv != 0)
6350                 goto done;
6351 
6352         listlen = scsi_resv->len / SCSI3_RESV_DESC_LEN;
6353 
6354         if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
6355                 inresv32.generation = scsi_resv->generation;
6356                 rv = ddi_copyout(&inresv32, arg, sizeof (inresv32), mode);
6357                 if (rv != 0) {
6358                         rv = EFAULT;
6359                         goto done;
6360                 }
6361 
6362                 rlist32.listlen = listlen;
6363                 rv = ddi_copyout(&rlist32, (caddr_t)(uintptr_t)inresv32.li,
6364                     sizeof (rlist32), mode);
6365                 if (rv != 0) {
6366                         rv = EFAULT;
6367                         goto done;
6368                 }
6369 
6370                 user_resv = (mhioc_resv_desc_t *)(uintptr_t)rlist32.list;
6371         } else {
6372                 inresv.generation = scsi_resv->generation;
6373                 rv = ddi_copyout(&inresv, arg, sizeof (inresv), mode);
6374                 if (rv != 0) {
6375                         rv = EFAULT;
6376                         goto done;
6377                 }
6378 
6379                 rlist.listlen = listlen;
6380                 rv = ddi_copyout(&rlist, inresv.li, sizeof (rlist), mode);
6381                 if (rv != 0) {
6382                         rv = EFAULT;
6383                         goto done;
6384                 }
6385 
6386                 user_resv = rlist.list;
6387         }
6388 
6389         /* copy out reservations */
6390         if (listsize > 0 && listlen > 0) {
6391                 if (listsize < listlen)
6392                         listlen = listsize;
6393                 resv = (sd_readresv_desc_t *)&scsi_resv->readresv_desc;
6394 
6395                 for (i = 0; i < listlen; i++) {
6396                         mhd_resv.type = resv->type;
6397                         mhd_resv.scope = resv->scope;
6398                         mhd_resv.scope_specific_addr =
6399                             BE_32(resv->scope_specific_addr);
6400                         bcopy(&resv->resvkey, &mhd_resv.key,
6401                             MHIOC_RESV_KEY_SIZE);
6402 
6403                         rv = ddi_copyout(&mhd_resv, user_resv,
6404                             sizeof (mhd_resv), mode);
6405                         if (rv != 0) {
6406                                 rv = EFAULT;
6407                                 goto done;
6408                         }
6409                         resv++;
6410                         user_resv++;
6411                 }
6412         }
6413 
6414         if (rv == 0)
6415                 rv = vdc_scsi_status(vdc, vd_scsi, B_FALSE);
6416 
6417 done:
6418         kmem_free(vd_scsi, vd_scsi_len);
6419         return (rv);
6420 }
6421 
6422 /*
6423  * Implement the MHIOCGRP_REGISTER mhd(7i) ioctl. The ioctl is converted
6424  * to a SCSI PERSISTENT OUT REGISTER command which is sent to the vdisk
6425  * server with a VD_OP_SCSICMD operation.
6426  */
6427 static int
6428 vdc_mhd_register(vdc_t *vdc, caddr_t arg, int mode)
6429 {
6430         vd_scsi_t *vd_scsi;
6431         sd_prout_t *scsi_prout;
6432         mhioc_register_t mhd_reg;
6433         int vd_scsi_len, rv;
6434 
6435         /* copyin arguments */
6436         rv = ddi_copyin(arg, &mhd_reg, sizeof (mhd_reg), mode);
6437         if (rv != 0)
6438                 return (EFAULT);
6439 
6440         /* build SCSI VD_OP request */
6441         vd_scsi = vdc_scsi_alloc_persistent_out(SD_SCSI3_REGISTER,
6442             sizeof (sd_prout_t), &vd_scsi_len);
6443 
6444         /* set parameters */
6445         scsi_prout = (sd_prout_t *)VD_SCSI_DATA_OUT(vd_scsi);
6446         bcopy(mhd_reg.oldkey.key, scsi_prout->res_key, MHIOC_RESV_KEY_SIZE);
6447         bcopy(mhd_reg.newkey.key, scsi_prout->service_key, MHIOC_RESV_KEY_SIZE);
6448         scsi_prout->aptpl = (uchar_t)mhd_reg.aptpl;
6449 
6450         /* submit the request */
6451         rv = vdc_do_sync_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6452             0, 0, VIO_both_dir, B_FALSE);
6453 
6454         if (rv == 0)
6455                 rv = vdc_scsi_status(vdc, vd_scsi, B_FALSE);
6456 
6457         kmem_free(vd_scsi, vd_scsi_len);
6458         return (rv);
6459 }
6460 
6461 /*
6462  * Implement the MHIOCGRP_RESERVE mhd(7i) ioctl. The ioctl is converted
6463  * to a SCSI PERSISTENT OUT RESERVE command which is sent to the vdisk
6464  * server with a VD_OP_SCSICMD operation.
6465  */
6466 static int
6467 vdc_mhd_reserve(vdc_t *vdc, caddr_t arg, int mode)
6468 {
6469         union scsi_cdb *cdb;
6470         vd_scsi_t *vd_scsi;
6471         sd_prout_t *scsi_prout;
6472         mhioc_resv_desc_t mhd_resv;
6473         int vd_scsi_len, rv;
6474 
6475         /* copyin arguments */
6476         rv = ddi_copyin(arg, &mhd_resv, sizeof (mhd_resv), mode);
6477         if (rv != 0)
6478                 return (EFAULT);
6479 
6480         /* build SCSI VD_OP request */
6481         vd_scsi = vdc_scsi_alloc_persistent_out(SD_SCSI3_RESERVE,
6482             sizeof (sd_prout_t), &vd_scsi_len);
6483 
6484         /* set parameters */
6485         cdb = VD_SCSI_DATA_CDB(vd_scsi);
6486         scsi_prout = (sd_prout_t *)VD_SCSI_DATA_OUT(vd_scsi);
6487         bcopy(mhd_resv.key.key, scsi_prout->res_key, MHIOC_RESV_KEY_SIZE);
6488         scsi_prout->scope_address = mhd_resv.scope_specific_addr;
6489         cdb->cdb_opaque[2] = mhd_resv.type;
6490 
6491         /* submit the request */
6492         rv = vdc_do_sync_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6493             0, 0, VIO_both_dir, B_FALSE);
6494 
6495         if (rv == 0)
6496                 rv = vdc_scsi_status(vdc, vd_scsi, B_FALSE);
6497 
6498         kmem_free(vd_scsi, vd_scsi_len);
6499         return (rv);
6500 }
6501 
6502 /*
6503  * Implement the MHIOCGRP_PREEMPTANDABORT mhd(7i) ioctl. The ioctl is
6504  * converted to a SCSI PERSISTENT OUT PREEMPT AND ABORT command which
6505  * is sent to the vdisk server with a VD_OP_SCSICMD operation.
6506  */
6507 static int
6508 vdc_mhd_preemptabort(vdc_t *vdc, caddr_t arg, int mode)
6509 {
6510         union scsi_cdb *cdb;
6511         vd_scsi_t *vd_scsi;
6512         sd_prout_t *scsi_prout;
6513         mhioc_preemptandabort_t mhd_preempt;
6514         int vd_scsi_len, rv;
6515 
6516         /* copyin arguments */
6517         rv = ddi_copyin(arg, &mhd_preempt, sizeof (mhd_preempt), mode);
6518         if (rv != 0)
6519                 return (EFAULT);
6520 
6521         /* build SCSI VD_OP request */
6522         vd_scsi = vdc_scsi_alloc_persistent_out(SD_SCSI3_PREEMPTANDABORT,
6523             sizeof (sd_prout_t), &vd_scsi_len);
6524 
6525         /* set parameters */
6526         vd_scsi->task_attribute = VD_SCSI_TASK_ACA;
6527         cdb = VD_SCSI_DATA_CDB(vd_scsi);
6528         scsi_prout = (sd_prout_t *)VD_SCSI_DATA_OUT(vd_scsi);
6529         bcopy(mhd_preempt.resvdesc.key.key, scsi_prout->res_key,
6530             MHIOC_RESV_KEY_SIZE);
6531         bcopy(mhd_preempt.victim_key.key, scsi_prout->service_key,
6532             MHIOC_RESV_KEY_SIZE);
6533         scsi_prout->scope_address = mhd_preempt.resvdesc.scope_specific_addr;
6534         cdb->cdb_opaque[2] = mhd_preempt.resvdesc.type;
6535 
6536         /* submit the request */
6537         rv = vdc_do_sync_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6538             0, 0, VIO_both_dir, B_FALSE);
6539 
6540         if (rv == 0)
6541                 rv = vdc_scsi_status(vdc, vd_scsi, B_FALSE);
6542 
6543         kmem_free(vd_scsi, vd_scsi_len);
6544         return (rv);
6545 }
6546 
6547 /*
6548  * Implement the MHIOCGRP_REGISTERANDIGNOREKEY mhd(7i) ioctl. The ioctl
6549  * is converted to a SCSI PERSISTENT OUT REGISTER AND IGNORE EXISTING KEY
6550  * command which is sent to the vdisk server with a VD_OP_SCSICMD operation.
6551  */
6552 static int
6553 vdc_mhd_registerignore(vdc_t *vdc, caddr_t arg, int mode)
6554 {
6555         vd_scsi_t *vd_scsi;
6556         sd_prout_t *scsi_prout;
6557         mhioc_registerandignorekey_t mhd_regi;
6558         int vd_scsi_len, rv;
6559 
6560         /* copyin arguments */
6561         rv = ddi_copyin(arg, &mhd_regi, sizeof (mhd_regi), mode);
6562         if (rv != 0)
6563                 return (EFAULT);
6564 
6565         /* build SCSI VD_OP request */
6566         vd_scsi = vdc_scsi_alloc_persistent_out(SD_SCSI3_REGISTERANDIGNOREKEY,
6567             sizeof (sd_prout_t), &vd_scsi_len);
6568 
6569         /* set parameters */
6570         scsi_prout = (sd_prout_t *)VD_SCSI_DATA_OUT(vd_scsi);
6571         bcopy(mhd_regi.newkey.key, scsi_prout->service_key,
6572             MHIOC_RESV_KEY_SIZE);
6573         scsi_prout->aptpl = (uchar_t)mhd_regi.aptpl;
6574 
6575         /* submit the request */
6576         rv = vdc_do_sync_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6577             0, 0, VIO_both_dir, B_FALSE);
6578 
6579         if (rv == 0)
6580                 rv = vdc_scsi_status(vdc, vd_scsi, B_FALSE);
6581 
6582         kmem_free(vd_scsi, vd_scsi_len);
6583         return (rv);
6584 }
6585 
6586 /*
6587  * This function is used to send a (simple) SCSI command and check errors.
6588  */
6589 static int
6590 vdc_eio_scsi_cmd(vdc_t *vdc, uchar_t scmd, int flags)
6591 {
6592         int cdb_len, sense_len, vd_scsi_len;
6593         vd_scsi_t *vd_scsi;
6594         union scsi_cdb *cdb;
6595         int rv;
6596 
6597         ASSERT(scmd == SCMD_TEST_UNIT_READY || scmd == SCMD_WRITE_G1);
6598 
6599         if (scmd == SCMD_WRITE_G1)
6600                 cdb_len = CDB_GROUP1;
6601         else
6602                 cdb_len = CDB_GROUP0;
6603 
6604         sense_len = sizeof (struct scsi_extended_sense);
6605 
6606         vd_scsi = vdc_scsi_alloc(cdb_len, sense_len, 0, 0, &vd_scsi_len);
6607 
6608         /* set cdb */
6609         cdb = VD_SCSI_DATA_CDB(vd_scsi);
6610         cdb->scc_cmd = scmd;
6611 
6612         vd_scsi->timeout = vdc_scsi_timeout;
6613 
6614         /*
6615          * Submit the request. Note the operation should not request that any
6616          * error is checked because this function is precisely called when
6617          * checking errors.
6618          */
6619         ASSERT((flags & VDC_OP_ERRCHK) == 0);
6620 
6621         rv = vdc_do_op(vdc, VD_OP_SCSICMD, (caddr_t)vd_scsi, vd_scsi_len,
6622             0, 0, NULL, VIO_both_dir, flags);
6623 
6624         if (rv == 0)
6625                 rv = vdc_scsi_status(vdc, vd_scsi, B_FALSE);
6626 
6627         kmem_free(vd_scsi, vd_scsi_len);
6628         return (rv);
6629 }
6630 
6631 /*
6632  * This function is used to check if a SCSI backend is accessible. It will
6633  * also detect reservation conflict if failfast is enabled, and panic the
6634  * system in that case.
6635  *
6636  * Returned Code:
6637  *      0       - disk is accessible
6638  *      != 0    - disk is inaccessible or unable to check if disk is accessible
6639  */
6640 static int
6641 vdc_eio_scsi_check(vdc_t *vdc, int flags)
6642 {
6643         int failure = 0;
6644         int rv;
6645 
6646         /*
6647          * Send a TEST UNIT READY command. The command will panic
6648          * the system if it fails with a reservation conflict and
6649          * failfast is enabled. If there is a reservation conflict
6650          * and failfast is not enabled then the function will return
6651          * EACCES. In that case, there's no problem with accessing
6652          * the backend, it is just reserved.
6653          */
6654         rv = vdc_eio_scsi_cmd(vdc, SCMD_TEST_UNIT_READY, flags);
6655         if (rv != 0 && rv != EACCES)
6656                 failure++;
6657 
6658         /* we don't need to do more checking if failfast is not enabled */
6659         if (vdc->failfast_interval == 0)
6660                 return (failure);
6661 
6662         /*
6663          * With SPC-3 compliant devices TEST UNIT READY will succeed on
6664          * a reserved device, so we also do a WRITE(10) of zero byte in
6665          * order to provoke a Reservation Conflict status on those newer
6666          * devices.
6667          */
6668         if (vdc_eio_scsi_cmd(vdc, SCMD_WRITE_G1, flags) != 0)
6669                 failure++;
6670 
6671         return (failure);
6672 }
6673 
6674 /*
6675  * This function is used to check if a backend is effectively accessible.
6676  *
6677  * Returned Code:
6678  *      0       - disk is accessible
6679  *      != 0    - disk is inaccessible or unable to check if disk is accessible
6680  */
6681 static int
6682 vdc_eio_check(vdc_t *vdc, int flags)
6683 {
6684         char *buffer;
6685         diskaddr_t blkno;
6686         int rv;
6687 
6688         ASSERT((flags & VDC_OP_ERRCHK) == 0);
6689 
6690         flags |= VDC_OP_DRING_RESERVED;
6691 
6692         if (VD_OP_SUPPORTED(vdc->operations, VD_OP_SCSICMD))
6693                 return (vdc_eio_scsi_check(vdc, flags));
6694 
6695         ASSERT(vdc->failfast_interval == 0);
6696 
6697         /*
6698          * If the backend does not support SCSI operations then we simply
6699          * check if the backend is accessible by reading some data blocks.
6700          * We first try to read a random block, to try to avoid getting
6701          * a block that might have been cached on the service domain. Then
6702          * we try the last block, and finally the first block.
6703          *
6704          * We return success as soon as we are able to read any block.
6705          */
6706         buffer = kmem_alloc(vdc->vdisk_bsize, KM_SLEEP);
6707 
6708         if (vdc->vdisk_size > 0) {
6709 
6710                 /* try a random block */
6711                 (void) random_get_pseudo_bytes((uint8_t *)&blkno,
6712                     sizeof (diskaddr_t));
6713                 blkno = blkno % vdc->vdisk_size;
6714                 rv = vdc_do_op(vdc, VD_OP_BREAD, (caddr_t)buffer,
6715                     vdc->vdisk_bsize, VD_SLICE_NONE, blkno, NULL,
6716                     VIO_read_dir, flags);
6717 
6718                 if (rv == 0)
6719                         goto done;
6720 
6721                 /* try the last block */
6722                 blkno = vdc->vdisk_size - 1;
6723                 rv = vdc_do_op(vdc, VD_OP_BREAD, (caddr_t)buffer,
6724                     vdc->vdisk_bsize, VD_SLICE_NONE, blkno, NULL,
6725                     VIO_read_dir, flags);
6726 
6727                 if (rv == 0)
6728                         goto done;
6729         }
6730 
6731         /* try block 0 */
6732         blkno = 0;
6733         rv = vdc_do_op(vdc, VD_OP_BREAD, (caddr_t)buffer, vdc->vdisk_bsize,
6734             VD_SLICE_NONE, blkno, NULL, VIO_read_dir, flags);
6735 
6736 done:
6737         kmem_free(buffer, vdc->vdisk_bsize);
6738         return (rv);
6739 }
6740 
6741 /*
6742  * Add a pending I/O to the eio queue. An I/O is added to this queue
6743  * when it has failed and failfast is enabled or the vdisk has multiple
6744  * servers. It will then be handled by the eio thread (vdc_eio_thread).
6745  * The eio queue is ordered starting with the most recent I/O added.
6746  */
6747 static vdc_io_t *
6748 vdc_eio_queue(vdc_t *vdc, int index)
6749 {
6750         vdc_io_t *vio;
6751 
6752         ASSERT(MUTEX_HELD(&vdc->lock));
6753 
6754         vio = kmem_alloc(sizeof (vdc_io_t), KM_SLEEP);
6755         vio->vio_next = vdc->eio_queue;
6756         vio->vio_index = index;
6757         vio->vio_qtime = ddi_get_lbolt();
6758 
6759         vdc->eio_queue = vio;
6760 
6761         /* notify the eio thread that a new I/O is queued */
6762         cv_signal(&vdc->eio_cv);
6763 
6764         return (vio);
6765 }
6766 
6767 /*
6768  * Remove I/Os added before the indicated deadline from the eio queue. A
6769  * deadline of 0 means that all I/Os have to be unqueued. The complete_io
6770  * boolean specifies if unqueued I/Os should be marked as completed or not.
6771  */
6772 static void
6773 vdc_eio_unqueue(vdc_t *vdc, clock_t deadline, boolean_t complete_io)
6774 {
6775         struct buf *buf;
6776         vdc_io_t *vio, *vio_tmp;
6777         int index, op;
6778 
6779         ASSERT(MUTEX_HELD(&vdc->lock));
6780 
6781         vio_tmp = NULL;
6782         vio = vdc->eio_queue;
6783 
6784         if (deadline != 0) {
6785                 /*
6786                  * Skip any io queued after the deadline. The eio queue is
6787                  * ordered starting with the last I/O added to the queue.
6788                  */
6789                 while (vio != NULL && vio->vio_qtime > deadline) {
6790                         vio_tmp = vio;
6791                         vio = vio->vio_next;
6792                 }
6793         }
6794 
6795         if (vio == NULL)
6796                 /* nothing to unqueue */
6797                 return;
6798 
6799         /* update the queue */
6800         if (vio_tmp == NULL)
6801                 vdc->eio_queue = NULL;
6802         else
6803                 vio_tmp->vio_next = NULL;
6804 
6805         /*
6806          * Free and complete unqueued I/Os if this was requested. All I/Os
6807          * have a block I/O data transfer structure (buf) and they are
6808          * completed by calling biodone().
6809          */
6810         while (vio != NULL) {
6811                 vio_tmp = vio->vio_next;
6812 
6813                 if (complete_io) {
6814                         index = vio->vio_index;
6815                         op = vdc->local_dring[index].operation;
6816                         buf = vdc->local_dring[index].buf;
6817                         (void) vdc_depopulate_descriptor(vdc, index);
6818                         ASSERT(buf->b_flags & B_ERROR);
6819                         if (op == VD_OP_BREAD || op == VD_OP_BWRITE) {
6820                                 VD_UPDATE_ERR_STATS(vdc, vd_softerrs);
6821                                 VD_KSTAT_RUNQ_EXIT(vdc);
6822                                 DTRACE_IO1(done, buf_t *, buf);
6823                         }
6824                         biodone(buf);
6825                 }
6826 
6827                 kmem_free(vio, sizeof (vdc_io_t));
6828                 vio = vio_tmp;
6829         }
6830 }
6831 
6832 /*
6833  * Error I/O Thread.  There is one eio thread for each virtual disk that
6834  * has multiple servers or for which failfast is enabled. Failfast can only
6835  * be enabled for vdisk supporting SCSI commands.
6836  *
6837  * While failfast is enabled, the eio thread sends a TEST UNIT READY
6838  * and a zero size WRITE(10) SCSI commands on a regular basis to check that
6839  * we still have access to the disk. If a command fails with a RESERVATION
6840  * CONFLICT error then the system will immediatly panic.
6841  *
6842  * The eio thread is also woken up when an I/O has failed. It then checks
6843  * the access to the disk to ensure that the I/O failure was not due to a
6844  * reservation conflict or to the backend been inaccessible.
6845  *
6846  */
6847 static void
6848 vdc_eio_thread(void *arg)
6849 {
6850         int status;
6851         vdc_t *vdc = (vdc_t *)arg;
6852         clock_t starttime, timeout = drv_usectohz(vdc->failfast_interval);
6853 
6854         mutex_enter(&vdc->lock);
6855 
6856         while (vdc->failfast_interval != 0 || vdc->num_servers > 1) {
6857                 /*
6858                  * Wait if there is nothing in the eio queue or if the state
6859                  * is not VDC_STATE_RUNNING.
6860                  */
6861                 if (vdc->eio_queue == NULL || vdc->state != VDC_STATE_RUNNING) {
6862                         if (vdc->failfast_interval != 0) {
6863                                 timeout = ddi_get_lbolt() +
6864                                     drv_usectohz(vdc->failfast_interval);
6865                                 (void) cv_timedwait(&vdc->eio_cv, &vdc->lock,
6866                                     timeout);
6867                         } else {
6868                                 ASSERT(vdc->num_servers > 1);
6869                                 (void) cv_wait(&vdc->eio_cv, &vdc->lock);
6870                         }
6871 
6872                         if (vdc->state != VDC_STATE_RUNNING)
6873                                 continue;
6874                 }
6875 
6876                 mutex_exit(&vdc->lock);
6877 
6878                 starttime = ddi_get_lbolt();
6879 
6880                 /* check error */
6881                 status = vdc_eio_check(vdc, VDC_OP_STATE_RUNNING);
6882 
6883                 mutex_enter(&vdc->lock);
6884                 /*
6885                  * We have dropped the lock to check the backend so we have
6886                  * to check that the eio thread is still enabled.
6887                  */
6888                 if (vdc->failfast_interval == 0 && vdc->num_servers <= 1)
6889                         break;
6890 
6891                 /*
6892                  * If the eio queue is empty or we are not in running state
6893                  * anymore then there is nothing to do.
6894                  */
6895                 if (vdc->state != VDC_STATE_RUNNING || vdc->eio_queue == NULL)
6896                         continue;
6897 
6898                 if (status == 0) {
6899                         /*
6900                          * The backend access has been successfully checked,
6901                          * we can complete any I/O queued before the last check.
6902                          */
6903                         vdc_eio_unqueue(vdc, starttime, B_TRUE);
6904 
6905                 } else if (vdc->num_servers > 1) {
6906                         /*
6907                          * The backend is inaccessible for a disk with multiple
6908                          * servers. So we force a reset to switch to another
6909                          * server. The reset will also clear the eio queue and
6910                          * resubmit all pending I/Os.
6911                          */
6912                         mutex_enter(&vdc->read_lock);
6913                         vdc->read_state = VDC_READ_RESET;
6914                         cv_signal(&vdc->read_cv);
6915                         mutex_exit(&vdc->read_lock);
6916                 } else {
6917                         /*
6918                          * There is only one path and the backend is not
6919                          * accessible, so I/Os are actually failing because
6920                          * of that. So we can complete I/O queued before the
6921                          * last check.
6922                          */
6923                         vdc_eio_unqueue(vdc, starttime, B_TRUE);
6924                 }
6925         }
6926 
6927         /*
6928          * The thread is being stopped so we can complete any queued I/O.
6929          */
6930         vdc_eio_unqueue(vdc, 0, B_TRUE);
6931         vdc->eio_thread = NULL;
6932         mutex_exit(&vdc->lock);
6933         thread_exit();
6934 }
6935 
6936 /*
6937  * Implement the MHIOCENFAILFAST mhd(7i) ioctl.
6938  */
6939 static int
6940 vdc_failfast(vdc_t *vdc, caddr_t arg, int mode)
6941 {
6942         unsigned int mh_time;
6943 
6944         if (ddi_copyin((void *)arg, &mh_time, sizeof (int), mode))
6945                 return (EFAULT);
6946 
6947         mutex_enter(&vdc->lock);
6948         if (mh_time != 0 && vdc->eio_thread == NULL) {
6949                 vdc->eio_thread = thread_create(NULL, 0,
6950                     vdc_eio_thread, vdc, 0, &p0, TS_RUN,
6951                     v.v_maxsyspri - 2);
6952         }
6953 
6954         vdc->failfast_interval = ((long)mh_time) * MILLISEC;
6955         cv_signal(&vdc->eio_cv);
6956         mutex_exit(&vdc->lock);
6957 
6958         return (0);
6959 }
6960 
6961 /*
6962  * Implement the MHIOCTKOWN and MHIOCRELEASE mhd(7i) ioctls. These ioctls are
6963  * converted to VD_OP_SET_ACCESS operations.
6964  */
6965 static int
6966 vdc_access_set(vdc_t *vdc, uint64_t flags)
6967 {
6968         int rv;
6969 
6970         /* submit owership command request */
6971         rv = vdc_do_sync_op(vdc, VD_OP_SET_ACCESS, (caddr_t)&flags,
6972             sizeof (uint64_t), 0, 0, VIO_both_dir, B_TRUE);
6973 
6974         return (rv);
6975 }
6976 
6977 /*
6978  * Implement the MHIOCSTATUS mhd(7i) ioctl. This ioctl is converted to a
6979  * VD_OP_GET_ACCESS operation.
6980  */
6981 static int
6982 vdc_access_get(vdc_t *vdc, uint64_t *status)
6983 {
6984         int rv;
6985 
6986         /* submit owership command request */
6987         rv = vdc_do_sync_op(vdc, VD_OP_GET_ACCESS, (caddr_t)status,
6988             sizeof (uint64_t), 0, 0, VIO_both_dir, B_TRUE);
6989 
6990         return (rv);
6991 }
6992 
6993 /*
6994  * Disk Ownership Thread.
6995  *
6996  * When we have taken the ownership of a disk, this thread waits to be
6997  * notified when the LDC channel is reset so that it can recover the
6998  * ownership.
6999  *
7000  * Note that the thread handling the LDC reset (vdc_process_msg_thread())
7001  * can not be used to do the ownership recovery because it has to be
7002  * running to handle the reply message to the ownership operation.
7003  */
7004 static void
7005 vdc_ownership_thread(void *arg)
7006 {
7007         vdc_t *vdc = (vdc_t *)arg;
7008         clock_t timeout;
7009         uint64_t status;
7010 
7011         mutex_enter(&vdc->ownership_lock);
7012         mutex_enter(&vdc->lock);
7013 
7014         while (vdc->ownership & VDC_OWNERSHIP_WANTED) {
7015 
7016                 if ((vdc->ownership & VDC_OWNERSHIP_RESET) ||
7017                     !(vdc->ownership & VDC_OWNERSHIP_GRANTED)) {
7018                         /*
7019                          * There was a reset so the ownership has been lost,
7020                          * try to recover. We do this without using the preempt
7021                          * option so that we don't steal the ownership from
7022                          * someone who has preempted us.
7023                          */
7024                         DMSG(vdc, 0, "[%d] Ownership lost, recovering",
7025                             vdc->instance);
7026 
7027                         vdc->ownership &= ~(VDC_OWNERSHIP_RESET |
7028                             VDC_OWNERSHIP_GRANTED);
7029 
7030                         mutex_exit(&vdc->lock);
7031 
7032                         status = vdc_access_set(vdc, VD_ACCESS_SET_EXCLUSIVE |
7033                             VD_ACCESS_SET_PRESERVE);
7034 
7035                         mutex_enter(&vdc->lock);
7036 
7037                         if (status == 0) {
7038                                 DMSG(vdc, 0, "[%d] Ownership recovered",
7039                                     vdc->instance);
7040                                 vdc->ownership |= VDC_OWNERSHIP_GRANTED;
7041                         } else {
7042                                 DMSG(vdc, 0, "[%d] Fail to recover ownership",
7043                                     vdc->instance);
7044                         }
7045 
7046                 }
7047 
7048                 /*
7049                  * If we have the ownership then we just wait for an event
7050                  * to happen (LDC reset), otherwise we will retry to recover
7051                  * after a delay.
7052                  */
7053                 if (vdc->ownership & VDC_OWNERSHIP_GRANTED)
7054                         timeout = 0;
7055                 else
7056                         timeout = drv_usectohz(vdc_ownership_delay);
7057 
7058                 /* Release the ownership_lock and wait on the vdc lock */
7059                 mutex_exit(&vdc->ownership_lock);
7060 
7061                 if (timeout == 0)
7062                         (void) cv_wait(&vdc->ownership_cv, &vdc->lock);
7063                 else
7064                         (void) cv_reltimedwait(&vdc->ownership_cv, &vdc->lock,
7065                             timeout, TR_CLOCK_TICK);
7066 
7067                 mutex_exit(&vdc->lock);
7068 
7069                 mutex_enter(&vdc->ownership_lock);
7070                 mutex_enter(&vdc->lock);
7071         }
7072 
7073         vdc->ownership_thread = NULL;
7074         mutex_exit(&vdc->lock);
7075         mutex_exit(&vdc->ownership_lock);
7076 
7077         thread_exit();
7078 }
7079 
7080 static void
7081 vdc_ownership_update(vdc_t *vdc, int ownership_flags)
7082 {
7083         ASSERT(MUTEX_HELD(&vdc->ownership_lock));
7084 
7085         mutex_enter(&vdc->lock);
7086         vdc->ownership = ownership_flags;
7087         if ((vdc->ownership & VDC_OWNERSHIP_WANTED) &&
7088             vdc->ownership_thread == NULL) {
7089                 /* start ownership thread */
7090                 vdc->ownership_thread = thread_create(NULL, 0,
7091                     vdc_ownership_thread, vdc, 0, &p0, TS_RUN,
7092                     v.v_maxsyspri - 2);
7093         } else {
7094                 /* notify the ownership thread */
7095                 cv_signal(&vdc->ownership_cv);
7096         }
7097         mutex_exit(&vdc->lock);
7098 }
7099 
7100 /*
7101  * Get the size and the block size of a virtual disk from the vdisk server.
7102  */
7103 static int
7104 vdc_get_capacity(vdc_t *vdc, size_t *dsk_size, size_t *blk_size)
7105 {
7106         int rv = 0;
7107         size_t alloc_len;
7108         vd_capacity_t *vd_cap;
7109 
7110         ASSERT(MUTEX_NOT_HELD(&vdc->lock));
7111 
7112         alloc_len = P2ROUNDUP(sizeof (vd_capacity_t), sizeof (uint64_t));
7113 
7114         vd_cap = kmem_zalloc(alloc_len, KM_SLEEP);
7115 
7116         rv = vdc_do_sync_op(vdc, VD_OP_GET_CAPACITY, (caddr_t)vd_cap, alloc_len,
7117             0, 0, VIO_both_dir, B_TRUE);
7118 
7119         *dsk_size = vd_cap->vdisk_size;
7120         *blk_size = vd_cap->vdisk_block_size;
7121 
7122         kmem_free(vd_cap, alloc_len);
7123         return (rv);
7124 }
7125 
7126 /*
7127  * Check the disk capacity. Disk size information is updated if size has
7128  * changed.
7129  *
7130  * Return 0 if the disk capacity is available, or non-zero if it is not.
7131  */
7132 static int
7133 vdc_check_capacity(vdc_t *vdc)
7134 {
7135         size_t dsk_size, blk_size;
7136         int rv;
7137 
7138         /*
7139          * If the vdisk does not support the VD_OP_GET_CAPACITY operation
7140          * then the disk capacity has been retrieved during the handshake
7141          * and there's nothing more to do here.
7142          */
7143         if (!VD_OP_SUPPORTED(vdc->operations, VD_OP_GET_CAPACITY))
7144                 return (0);
7145 
7146         if ((rv = vdc_get_capacity(vdc, &dsk_size, &blk_size)) != 0)
7147                 return (rv);
7148 
7149         if (dsk_size == VD_SIZE_UNKNOWN || dsk_size == 0 || blk_size == 0)
7150                 return (EINVAL);
7151 
7152         mutex_enter(&vdc->lock);
7153         /*
7154          * First try to update the VIO block size (which is the same as the
7155          * vdisk block size). If this returns an error then that means that
7156          * we can not use that block size so basically the vdisk is unusable
7157          * and we return an error.
7158          */
7159         rv = vdc_update_vio_bsize(vdc, blk_size);
7160         if (rv == 0)
7161                 vdc_update_size(vdc, dsk_size, blk_size, vdc->max_xfer_sz);
7162 
7163         mutex_exit(&vdc->lock);
7164 
7165         return (rv);
7166 }
7167 
7168 /*
7169  * This structure is used in the DKIO(7I) array below.
7170  */
7171 typedef struct vdc_dk_ioctl {
7172         uint8_t         op;             /* VD_OP_XXX value */
7173         int             cmd;            /* Solaris ioctl operation number */
7174         size_t          nbytes;         /* size of structure to be copied */
7175 
7176         /* function to convert between vDisk and Solaris structure formats */
7177         int     (*convert)(vdc_t *vdc, void *vd_buf, void *ioctl_arg,
7178             int mode, int dir);
7179 } vdc_dk_ioctl_t;
7180 
7181 /*
7182  * Subset of DKIO(7I) operations currently supported
7183  */
7184 static vdc_dk_ioctl_t   dk_ioctl[] = {
7185         {VD_OP_FLUSH,           DKIOCFLUSHWRITECACHE,   0,
7186                 vdc_null_copy_func},
7187         {VD_OP_GET_WCE,         DKIOCGETWCE,            sizeof (int),
7188                 vdc_get_wce_convert},
7189         {VD_OP_SET_WCE,         DKIOCSETWCE,            sizeof (int),
7190                 vdc_set_wce_convert},
7191         {VD_OP_GET_VTOC,        DKIOCGVTOC,             sizeof (vd_vtoc_t),
7192                 vdc_get_vtoc_convert},
7193         {VD_OP_SET_VTOC,        DKIOCSVTOC,             sizeof (vd_vtoc_t),
7194                 vdc_set_vtoc_convert},
7195         {VD_OP_GET_VTOC,        DKIOCGEXTVTOC,          sizeof (vd_vtoc_t),
7196                 vdc_get_extvtoc_convert},
7197         {VD_OP_SET_VTOC,        DKIOCSEXTVTOC,          sizeof (vd_vtoc_t),
7198                 vdc_set_extvtoc_convert},
7199         {VD_OP_GET_DISKGEOM,    DKIOCGGEOM,             sizeof (vd_geom_t),
7200                 vdc_get_geom_convert},
7201         {VD_OP_GET_DISKGEOM,    DKIOCG_PHYGEOM,         sizeof (vd_geom_t),
7202                 vdc_get_geom_convert},
7203         {VD_OP_GET_DISKGEOM,    DKIOCG_VIRTGEOM,        sizeof (vd_geom_t),
7204                 vdc_get_geom_convert},
7205         {VD_OP_SET_DISKGEOM,    DKIOCSGEOM,             sizeof (vd_geom_t),
7206                 vdc_set_geom_convert},
7207         {VD_OP_GET_EFI,         DKIOCGETEFI,            0,
7208                 vdc_get_efi_convert},
7209         {VD_OP_SET_EFI,         DKIOCSETEFI,            0,
7210                 vdc_set_efi_convert},
7211 
7212         /* DIOCTL_RWCMD is converted to a read or a write */
7213         {0, DIOCTL_RWCMD,  sizeof (struct dadkio_rwcmd), NULL},
7214 
7215         /* mhd(7I) non-shared multihost disks ioctls */
7216         {0, MHIOCTKOWN,                         0, vdc_null_copy_func},
7217         {0, MHIOCRELEASE,                       0, vdc_null_copy_func},
7218         {0, MHIOCSTATUS,                        0, vdc_null_copy_func},
7219         {0, MHIOCQRESERVE,                      0, vdc_null_copy_func},
7220 
7221         /* mhd(7I) shared multihost disks ioctls */
7222         {0, MHIOCGRP_INKEYS,                    0, vdc_null_copy_func},
7223         {0, MHIOCGRP_INRESV,                    0, vdc_null_copy_func},
7224         {0, MHIOCGRP_REGISTER,                  0, vdc_null_copy_func},
7225         {0, MHIOCGRP_RESERVE,                   0, vdc_null_copy_func},
7226         {0, MHIOCGRP_PREEMPTANDABORT,           0, vdc_null_copy_func},
7227         {0, MHIOCGRP_REGISTERANDIGNOREKEY,      0, vdc_null_copy_func},
7228 
7229         /* mhd(7I) failfast ioctl */
7230         {0, MHIOCENFAILFAST,                    0, vdc_null_copy_func},
7231 
7232         /*
7233          * These particular ioctls are not sent to the server - vdc fakes up
7234          * the necessary info.
7235          */
7236         {0, DKIOCINFO, sizeof (struct dk_cinfo), vdc_null_copy_func},
7237         {0, DKIOCGMEDIAINFO, sizeof (struct dk_minfo), vdc_null_copy_func},
7238         {0, USCSICMD,   sizeof (struct uscsi_cmd), vdc_null_copy_func},
7239         {0, DKIOCPARTITION, 0, vdc_null_copy_func },
7240         {0, DKIOCGAPART, 0, vdc_null_copy_func },
7241         {0, DKIOCREMOVABLE, 0, vdc_null_copy_func},
7242         {0, CDROMREADOFFSET, 0, vdc_null_copy_func}
7243 };
7244 
7245 /*
7246  * This function handles ioctl requests from the vd_efi_alloc_and_read()
7247  * function and forward them to the vdisk.
7248  */
7249 static int
7250 vd_process_efi_ioctl(void *vdisk, int cmd, uintptr_t arg)
7251 {
7252         vdc_t *vdc = (vdc_t *)vdisk;
7253         dev_t dev;
7254         int rval;
7255 
7256         dev = makedevice(ddi_driver_major(vdc->dip),
7257             VD_MAKE_DEV(vdc->instance, 0));
7258 
7259         return (vd_process_ioctl(dev, cmd, (caddr_t)arg, FKIOCTL, &rval));
7260 }
7261 
7262 /*
7263  * Function:
7264  *      vd_process_ioctl()
7265  *
7266  * Description:
7267  *      This routine processes disk specific ioctl calls
7268  *
7269  * Arguments:
7270  *      dev     - the device number
7271  *      cmd     - the operation [dkio(7I)] to be processed
7272  *      arg     - pointer to user provided structure
7273  *                (contains data to be set or reference parameter for get)
7274  *      mode    - bit flag, indicating open settings, 32/64 bit type, etc
7275  *      rvalp   - pointer to return value for calling process.
7276  *
7277  * Return Code:
7278  *      0
7279  *      EFAULT
7280  *      ENXIO
7281  *      EIO
7282  *      ENOTSUP
7283  */
7284 static int
7285 vd_process_ioctl(dev_t dev, int cmd, caddr_t arg, int mode, int *rvalp)
7286 {
7287         int             instance = VDCUNIT(dev);
7288         vdc_t           *vdc = NULL;
7289         int             rv = -1;
7290         int             idx = 0;                /* index into dk_ioctl[] */
7291         size_t          len = 0;                /* #bytes to send to vds */
7292         size_t          alloc_len = 0;          /* #bytes to allocate mem for */
7293         caddr_t         mem_p = NULL;
7294         size_t          nioctls = (sizeof (dk_ioctl)) / (sizeof (dk_ioctl[0]));
7295         vdc_dk_ioctl_t  *iop;
7296 
7297         vdc = ddi_get_soft_state(vdc_state, instance);
7298         if (vdc == NULL) {
7299                 cmn_err(CE_NOTE, "![%d] Could not get soft state structure",
7300                     instance);
7301                 return (ENXIO);
7302         }
7303 
7304         DMSG(vdc, 0, "[%d] Processing ioctl(%x) for dev %lx : model %x\n",
7305             instance, cmd, dev, ddi_model_convert_from(mode & FMODELS));
7306 
7307         if (rvalp != NULL) {
7308                 /* the return value of the ioctl is 0 by default */
7309                 *rvalp = 0;
7310         }
7311 
7312         /*
7313          * Validate the ioctl operation to be performed.
7314          *
7315          * If we have looped through the array without finding a match then we
7316          * don't support this ioctl.
7317          */
7318         for (idx = 0; idx < nioctls; idx++) {
7319                 if (cmd == dk_ioctl[idx].cmd)
7320                         break;
7321         }
7322 
7323         if (idx >= nioctls) {
7324                 DMSG(vdc, 0, "[%d] Unsupported ioctl (0x%x)\n",
7325                     vdc->instance, cmd);
7326                 return (ENOTSUP);
7327         }
7328 
7329         iop = &(dk_ioctl[idx]);
7330 
7331         if (cmd == DKIOCGETEFI || cmd == DKIOCSETEFI) {
7332                 /* size is not fixed for EFI ioctls, it depends on ioctl arg */
7333                 dk_efi_t        dk_efi;
7334 
7335                 rv = ddi_copyin(arg, &dk_efi, sizeof (dk_efi_t), mode);
7336                 if (rv != 0)
7337                         return (EFAULT);
7338 
7339                 len = sizeof (vd_efi_t) - 1 + dk_efi.dki_length;
7340         } else {
7341                 len = iop->nbytes;
7342         }
7343 
7344         /* check if the ioctl is applicable */
7345         switch (cmd) {
7346         case CDROMREADOFFSET:
7347         case DKIOCREMOVABLE:
7348                 return (ENOTTY);
7349 
7350         case USCSICMD:
7351         case MHIOCTKOWN:
7352         case MHIOCSTATUS:
7353         case MHIOCQRESERVE:
7354         case MHIOCRELEASE:
7355         case MHIOCGRP_INKEYS:
7356         case MHIOCGRP_INRESV:
7357         case MHIOCGRP_REGISTER:
7358         case MHIOCGRP_RESERVE:
7359         case MHIOCGRP_PREEMPTANDABORT:
7360         case MHIOCGRP_REGISTERANDIGNOREKEY:
7361         case MHIOCENFAILFAST:
7362                 if (vdc->cinfo == NULL)
7363                         return (ENXIO);
7364                 if (vdc->cinfo->dki_ctype != DKC_SCSI_CCS)
7365                         return (ENOTTY);
7366                 break;
7367 
7368         case DIOCTL_RWCMD:
7369                 if (vdc->cinfo == NULL)
7370                         return (ENXIO);
7371                 if (vdc->cinfo->dki_ctype != DKC_DIRECT)
7372                         return (ENOTTY);
7373                 break;
7374 
7375         case DKIOCINFO:
7376                 if (vdc->cinfo == NULL)
7377                         return (ENXIO);
7378                 break;
7379 
7380         case DKIOCGMEDIAINFO:
7381                 if (vdc->minfo == NULL)
7382                         return (ENXIO);
7383                 if (vdc_check_capacity(vdc) != 0)
7384                         /* disk capacity is not available */
7385                         return (EIO);
7386                 break;
7387         }
7388 
7389         /*
7390          * Deal with ioctls which require a processing different than
7391          * converting ioctl arguments and sending a corresponding
7392          * VD operation.
7393          */
7394         switch (cmd) {
7395 
7396         case USCSICMD:
7397         {
7398                 return (vdc_uscsi_cmd(vdc, arg, mode));
7399         }
7400 
7401         case MHIOCTKOWN:
7402         {
7403                 mutex_enter(&vdc->ownership_lock);
7404                 /*
7405                  * We have to set VDC_OWNERSHIP_WANTED now so that the ownership
7406                  * can be flagged with VDC_OWNERSHIP_RESET if the LDC is reset
7407                  * while we are processing the ioctl.
7408                  */
7409                 vdc_ownership_update(vdc, VDC_OWNERSHIP_WANTED);
7410 
7411                 rv = vdc_access_set(vdc, VD_ACCESS_SET_EXCLUSIVE |
7412                     VD_ACCESS_SET_PREEMPT | VD_ACCESS_SET_PRESERVE);
7413                 if (rv == 0) {
7414                         vdc_ownership_update(vdc, VDC_OWNERSHIP_WANTED |
7415                             VDC_OWNERSHIP_GRANTED);
7416                 } else {
7417                         vdc_ownership_update(vdc, VDC_OWNERSHIP_NONE);
7418                 }
7419                 mutex_exit(&vdc->ownership_lock);
7420                 return (rv);
7421         }
7422 
7423         case MHIOCRELEASE:
7424         {
7425                 mutex_enter(&vdc->ownership_lock);
7426                 rv = vdc_access_set(vdc, VD_ACCESS_SET_CLEAR);
7427                 if (rv == 0) {
7428                         vdc_ownership_update(vdc, VDC_OWNERSHIP_NONE);
7429                 }
7430                 mutex_exit(&vdc->ownership_lock);
7431                 return (rv);
7432         }
7433 
7434         case MHIOCSTATUS:
7435         {
7436                 uint64_t status;
7437 
7438                 rv = vdc_access_get(vdc, &status);
7439                 if (rv == 0 && rvalp != NULL)
7440                         *rvalp = (status & VD_ACCESS_ALLOWED)? 0 : 1;
7441                 return (rv);
7442         }
7443 
7444         case MHIOCQRESERVE:
7445         {
7446                 rv = vdc_access_set(vdc, VD_ACCESS_SET_EXCLUSIVE);
7447                 return (rv);
7448         }
7449 
7450         case MHIOCGRP_INKEYS:
7451         {
7452                 return (vdc_mhd_inkeys(vdc, arg, mode));
7453         }
7454 
7455         case MHIOCGRP_INRESV:
7456         {
7457                 return (vdc_mhd_inresv(vdc, arg, mode));
7458         }
7459 
7460         case MHIOCGRP_REGISTER:
7461         {
7462                 return (vdc_mhd_register(vdc, arg, mode));
7463         }
7464 
7465         case MHIOCGRP_RESERVE:
7466         {
7467                 return (vdc_mhd_reserve(vdc, arg, mode));
7468         }
7469 
7470         case MHIOCGRP_PREEMPTANDABORT:
7471         {
7472                 return (vdc_mhd_preemptabort(vdc, arg, mode));
7473         }
7474 
7475         case MHIOCGRP_REGISTERANDIGNOREKEY:
7476         {
7477                 return (vdc_mhd_registerignore(vdc, arg, mode));
7478         }
7479 
7480         case MHIOCENFAILFAST:
7481         {
7482                 rv = vdc_failfast(vdc, arg, mode);
7483                 return (rv);
7484         }
7485 
7486         case DIOCTL_RWCMD:
7487         {
7488                 return (vdc_dioctl_rwcmd(vdc, arg, mode));
7489         }
7490 
7491         case DKIOCGAPART:
7492         {
7493                 return (vdc_dkio_gapart(vdc, arg, mode));
7494         }
7495 
7496         case DKIOCPARTITION:
7497         {
7498                 return (vdc_dkio_partition(vdc, arg, mode));
7499         }
7500 
7501         case DKIOCINFO:
7502         {
7503                 struct dk_cinfo cinfo;
7504 
7505                 bcopy(vdc->cinfo, &cinfo, sizeof (struct dk_cinfo));
7506                 cinfo.dki_partition = VDCPART(dev);
7507 
7508                 rv = ddi_copyout(&cinfo, (void *)arg,
7509                     sizeof (struct dk_cinfo), mode);
7510                 if (rv != 0)
7511                         return (EFAULT);
7512 
7513                 return (0);
7514         }
7515 
7516         case DKIOCGMEDIAINFO:
7517         {
7518                 ASSERT(vdc->vdisk_size != 0);
7519                 ASSERT(vdc->minfo->dki_capacity != 0);
7520                 rv = ddi_copyout(vdc->minfo, (void *)arg,
7521                     sizeof (struct dk_minfo), mode);
7522                 if (rv != 0)
7523                         return (EFAULT);
7524 
7525                 return (0);
7526         }
7527 
7528         case DKIOCFLUSHWRITECACHE:
7529                 {
7530                         struct dk_callback *dkc =
7531                             (struct dk_callback *)(uintptr_t)arg;
7532                         vdc_dk_arg_t    *dkarg = NULL;
7533 
7534                         DMSG(vdc, 1, "[%d] Flush W$: mode %x\n",
7535                             instance, mode);
7536 
7537                         /*
7538                          * If arg is NULL, then there is no callback function
7539                          * registered and the call operates synchronously; we
7540                          * break and continue with the rest of the function and
7541                          * wait for vds to return (i.e. after the request to
7542                          * vds returns successfully, all writes completed prior
7543                          * to the ioctl will have been flushed from the disk
7544                          * write cache to persistent media.
7545                          *
7546                          * If a callback function is registered, we dispatch
7547                          * the request on a task queue and return immediately.
7548                          * The callback will deal with informing the calling
7549                          * thread that the flush request is completed.
7550                          */
7551                         if (dkc == NULL)
7552                                 break;
7553 
7554                         /*
7555                          * the asynchronous callback is only supported if
7556                          * invoked from within the kernel
7557                          */
7558                         if ((mode & FKIOCTL) == 0)
7559                                 return (ENOTSUP);
7560 
7561                         dkarg = kmem_zalloc(sizeof (vdc_dk_arg_t), KM_SLEEP);
7562 
7563                         dkarg->mode = mode;
7564                         dkarg->dev = dev;
7565                         bcopy(dkc, &dkarg->dkc, sizeof (*dkc));
7566 
7567                         mutex_enter(&vdc->lock);
7568                         vdc->dkio_flush_pending++;
7569                         dkarg->vdc = vdc;
7570                         mutex_exit(&vdc->lock);
7571 
7572                         /* put the request on a task queue */
7573                         rv = taskq_dispatch(system_taskq, vdc_dkio_flush_cb,
7574                             (void *)dkarg, DDI_SLEEP);
7575                         if (rv == NULL) {
7576                                 /* clean up if dispatch fails */
7577                                 mutex_enter(&vdc->lock);
7578                                 vdc->dkio_flush_pending--;
7579                                 mutex_exit(&vdc->lock);
7580                                 kmem_free(dkarg, sizeof (vdc_dk_arg_t));
7581                         }
7582 
7583                         return (rv == NULL ? ENOMEM : 0);
7584                 }
7585         }
7586 
7587         /* catch programming error in vdc - should be a VD_OP_XXX ioctl */
7588         ASSERT(iop->op != 0);
7589 
7590         /* check if the vDisk server handles the operation for this vDisk */
7591         if (VD_OP_SUPPORTED(vdc->operations, iop->op) == B_FALSE) {
7592                 DMSG(vdc, 0, "[%d] Unsupported VD_OP operation (0x%x)\n",
7593                     vdc->instance, iop->op);
7594                 return (ENOTSUP);
7595         }
7596 
7597         /* LDC requires that the memory being mapped is 8-byte aligned */
7598         alloc_len = P2ROUNDUP(len, sizeof (uint64_t));
7599         DMSG(vdc, 1, "[%d] struct size %ld alloc %ld\n",
7600             instance, len, alloc_len);
7601 
7602         if (alloc_len > 0)
7603                 mem_p = kmem_zalloc(alloc_len, KM_SLEEP);
7604 
7605         /*
7606          * Call the conversion function for this ioctl which, if necessary,
7607          * converts from the Solaris format to the format ARC'ed
7608          * as part of the vDisk protocol (FWARC 2006/195)
7609          */
7610         ASSERT(iop->convert != NULL);
7611         rv = (iop->convert)(vdc, arg, mem_p, mode, VD_COPYIN);
7612         if (rv != 0) {
7613                 DMSG(vdc, 0, "[%d] convert func returned %d for ioctl 0x%x\n",
7614                     instance, rv, cmd);
7615                 if (mem_p != NULL)
7616                         kmem_free(mem_p, alloc_len);
7617                 return (rv);
7618         }
7619 
7620         /*
7621          * send request to vds to service the ioctl.
7622          */
7623         rv = vdc_do_sync_op(vdc, iop->op, mem_p, alloc_len,
7624             VDCPART(dev), 0, VIO_both_dir, B_TRUE);
7625 
7626         if (rv != 0) {
7627                 /*
7628                  * This is not necessarily an error. The ioctl could
7629                  * be returning a value such as ENOTTY to indicate
7630                  * that the ioctl is not applicable.
7631                  */
7632                 DMSG(vdc, 0, "[%d] vds returned %d for ioctl 0x%x\n",
7633                     instance, rv, cmd);
7634                 if (mem_p != NULL)
7635                         kmem_free(mem_p, alloc_len);
7636 
7637                 return (rv);
7638         }
7639 
7640         /*
7641          * Call the conversion function (if it exists) for this ioctl
7642          * which converts from the format ARC'ed as part of the vDisk
7643          * protocol (FWARC 2006/195) back to a format understood by
7644          * the rest of Solaris.
7645          */
7646         rv = (iop->convert)(vdc, mem_p, arg, mode, VD_COPYOUT);
7647         if (rv != 0) {
7648                 DMSG(vdc, 0, "[%d] convert func returned %d for ioctl 0x%x\n",
7649                     instance, rv, cmd);
7650                 if (mem_p != NULL)
7651                         kmem_free(mem_p, alloc_len);
7652                 return (rv);
7653         }
7654 
7655         if (mem_p != NULL)
7656                 kmem_free(mem_p, alloc_len);
7657 
7658         return (rv);
7659 }
7660 
7661 /*
7662  * Function:
7663  *
7664  * Description:
7665  *      This is an empty conversion function used by ioctl calls which
7666  *      do not need to convert the data being passed in/out to userland
7667  */
7668 static int
7669 vdc_null_copy_func(vdc_t *vdc, void *from, void *to, int mode, int dir)
7670 {
7671         _NOTE(ARGUNUSED(vdc))
7672         _NOTE(ARGUNUSED(from))
7673         _NOTE(ARGUNUSED(to))
7674         _NOTE(ARGUNUSED(mode))
7675         _NOTE(ARGUNUSED(dir))
7676 
7677         return (0);
7678 }
7679 
7680 static int
7681 vdc_get_wce_convert(vdc_t *vdc, void *from, void *to,
7682     int mode, int dir)
7683 {
7684         _NOTE(ARGUNUSED(vdc))
7685 
7686         if (dir == VD_COPYIN)
7687                 return (0);             /* nothing to do */
7688 
7689         if (ddi_copyout(from, to, sizeof (int), mode) != 0)
7690                 return (EFAULT);
7691 
7692         return (0);
7693 }
7694 
7695 static int
7696 vdc_set_wce_convert(vdc_t *vdc, void *from, void *to,
7697     int mode, int dir)
7698 {
7699         _NOTE(ARGUNUSED(vdc))
7700 
7701         if (dir == VD_COPYOUT)
7702                 return (0);             /* nothing to do */
7703 
7704         if (ddi_copyin(from, to, sizeof (int), mode) != 0)
7705                 return (EFAULT);
7706 
7707         return (0);
7708 }
7709 
7710 /*
7711  * Function:
7712  *      vdc_get_vtoc_convert()
7713  *
7714  * Description:
7715  *      This routine performs the necessary convertions from the DKIOCGVTOC
7716  *      Solaris structure to the format defined in FWARC 2006/195.
7717  *
7718  *      In the struct vtoc definition, the timestamp field is marked as not
7719  *      supported so it is not part of vDisk protocol (FWARC 2006/195).
7720  *      However SVM uses that field to check it can write into the VTOC,
7721  *      so we fake up the info of that field.
7722  *
7723  * Arguments:
7724  *      vdc     - the vDisk client
7725  *      from    - the buffer containing the data to be copied from
7726  *      to      - the buffer to be copied to
7727  *      mode    - flags passed to ioctl() call
7728  *      dir     - the "direction" of the copy - VD_COPYIN or VD_COPYOUT
7729  *
7730  * Return Code:
7731  *      0       - Success
7732  *      ENXIO   - incorrect buffer passed in.
7733  *      EFAULT  - ddi_copyout routine encountered an error.
7734  */
7735 static int
7736 vdc_get_vtoc_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
7737 {
7738         int             i;
7739         struct vtoc     vtoc;
7740         struct vtoc32   vtoc32;
7741         struct extvtoc  evtoc;
7742         int             rv;
7743 
7744         if (dir != VD_COPYOUT)
7745                 return (0);     /* nothing to do */
7746 
7747         if ((from == NULL) || (to == NULL))
7748                 return (ENXIO);
7749 
7750         if (vdc->vdisk_size > VD_OLDVTOC_LIMIT)
7751                 return (EOVERFLOW);
7752 
7753         VD_VTOC2VTOC((vd_vtoc_t *)from, &evtoc);
7754 
7755         /* fake the VTOC timestamp field */
7756         for (i = 0; i < V_NUMPAR; i++) {
7757                 evtoc.timestamp[i] = vdc->vtoc->timestamp[i];
7758         }
7759 
7760         if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
7761                 /* LINTED E_ASSIGN_NARROW_CONV */
7762                 extvtoctovtoc32(evtoc, vtoc32);
7763                 rv = ddi_copyout(&vtoc32, to, sizeof (vtoc32), mode);
7764                 if (rv != 0)
7765                         rv = EFAULT;
7766         } else {
7767                 extvtoctovtoc(evtoc, vtoc);
7768                 rv = ddi_copyout(&vtoc, to, sizeof (vtoc), mode);
7769                 if (rv != 0)
7770                         rv = EFAULT;
7771         }
7772 
7773         return (rv);
7774 }
7775 
7776 /*
7777  * Function:
7778  *      vdc_set_vtoc_convert()
7779  *
7780  * Description:
7781  *      This routine performs the necessary convertions from the DKIOCSVTOC
7782  *      Solaris structure to the format defined in FWARC 2006/195.
7783  *
7784  * Arguments:
7785  *      vdc     - the vDisk client
7786  *      from    - Buffer with data
7787  *      to      - Buffer where data is to be copied to
7788  *      mode    - flags passed to ioctl
7789  *      dir     - direction of copy (in or out)
7790  *
7791  * Return Code:
7792  *      0       - Success
7793  *      ENXIO   - Invalid buffer passed in
7794  *      EFAULT  - ddi_copyin of data failed
7795  */
7796 static int
7797 vdc_set_vtoc_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
7798 {
7799         void            *uvtoc;
7800         struct vtoc     vtoc;
7801         struct vtoc32   vtoc32;
7802         struct extvtoc  evtoc;
7803         int             i, rv;
7804 
7805         if ((from == NULL) || (to == NULL))
7806                 return (ENXIO);
7807 
7808         if (vdc->vdisk_size > VD_OLDVTOC_LIMIT)
7809                 return (EOVERFLOW);
7810 
7811         uvtoc = (dir == VD_COPYIN)? from : to;
7812 
7813         if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
7814                 rv = ddi_copyin(uvtoc, &vtoc32, sizeof (vtoc32), mode);
7815                 if (rv != 0)
7816                         return (EFAULT);
7817                 vtoc32toextvtoc(vtoc32, evtoc);
7818         } else {
7819                 rv = ddi_copyin(uvtoc, &vtoc, sizeof (vtoc), mode);
7820                 if (rv != 0)
7821                         return (EFAULT);
7822                 vtoctoextvtoc(vtoc, evtoc);
7823         }
7824 
7825         if (dir == VD_COPYOUT) {
7826                 /*
7827                  * The disk label may have changed. Revalidate the disk
7828                  * geometry. This will also update the device nodes.
7829                  */
7830                 vdc_validate(vdc);
7831 
7832                 /*
7833                  * We also need to keep track of the timestamp fields.
7834                  */
7835                 for (i = 0; i < V_NUMPAR; i++) {
7836                         vdc->vtoc->timestamp[i] = evtoc.timestamp[i];
7837                 }
7838 
7839         } else {
7840                 VTOC2VD_VTOC(&evtoc, (vd_vtoc_t *)to);
7841         }
7842 
7843         return (0);
7844 }
7845 
7846 static int
7847 vdc_get_extvtoc_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
7848 {
7849         int             i, rv;
7850         struct extvtoc  evtoc;
7851 
7852         if (dir != VD_COPYOUT)
7853                 return (0);     /* nothing to do */
7854 
7855         if ((from == NULL) || (to == NULL))
7856                 return (ENXIO);
7857 
7858         VD_VTOC2VTOC((vd_vtoc_t *)from, &evtoc);
7859 
7860         /* fake the VTOC timestamp field */
7861         for (i = 0; i < V_NUMPAR; i++) {
7862                 evtoc.timestamp[i] = vdc->vtoc->timestamp[i];
7863         }
7864 
7865         rv = ddi_copyout(&evtoc, to, sizeof (struct extvtoc), mode);
7866         if (rv != 0)
7867                 rv = EFAULT;
7868 
7869         return (rv);
7870 }
7871 
7872 static int
7873 vdc_set_extvtoc_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
7874 {
7875         void            *uvtoc;
7876         struct extvtoc  evtoc;
7877         int             i, rv;
7878 
7879         if ((from == NULL) || (to == NULL))
7880                 return (ENXIO);
7881 
7882         uvtoc = (dir == VD_COPYIN)? from : to;
7883 
7884         rv = ddi_copyin(uvtoc, &evtoc, sizeof (struct extvtoc), mode);
7885         if (rv != 0)
7886                 return (EFAULT);
7887 
7888         if (dir == VD_COPYOUT) {
7889                 /*
7890                  * The disk label may have changed. Revalidate the disk
7891                  * geometry. This will also update the device nodes.
7892                  */
7893                 vdc_validate(vdc);
7894 
7895                 /*
7896                  * We also need to keep track of the timestamp fields.
7897                  */
7898                 for (i = 0; i < V_NUMPAR; i++) {
7899                         vdc->vtoc->timestamp[i] = evtoc.timestamp[i];
7900                 }
7901 
7902         } else {
7903                 VTOC2VD_VTOC(&evtoc, (vd_vtoc_t *)to);
7904         }
7905 
7906         return (0);
7907 }
7908 
7909 /*
7910  * Function:
7911  *      vdc_get_geom_convert()
7912  *
7913  * Description:
7914  *      This routine performs the necessary convertions from the DKIOCGGEOM,
7915  *      DKIOCG_PHYSGEOM and DKIOG_VIRTGEOM Solaris structures to the format
7916  *      defined in FWARC 2006/195
7917  *
7918  * Arguments:
7919  *      vdc     - the vDisk client
7920  *      from    - Buffer with data
7921  *      to      - Buffer where data is to be copied to
7922  *      mode    - flags passed to ioctl
7923  *      dir     - direction of copy (in or out)
7924  *
7925  * Return Code:
7926  *      0       - Success
7927  *      ENXIO   - Invalid buffer passed in
7928  *      EFAULT  - ddi_copyout of data failed
7929  */
7930 static int
7931 vdc_get_geom_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
7932 {
7933         _NOTE(ARGUNUSED(vdc))
7934 
7935         struct dk_geom  geom;
7936         int     copy_len = sizeof (struct dk_geom);
7937         int     rv = 0;
7938 
7939         if (dir != VD_COPYOUT)
7940                 return (0);     /* nothing to do */
7941 
7942         if ((from == NULL) || (to == NULL))
7943                 return (ENXIO);
7944 
7945         VD_GEOM2DK_GEOM((vd_geom_t *)from, &geom);
7946         rv = ddi_copyout(&geom, to, copy_len, mode);
7947         if (rv != 0)
7948                 rv = EFAULT;
7949 
7950         return (rv);
7951 }
7952 
7953 /*
7954  * Function:
7955  *      vdc_set_geom_convert()
7956  *
7957  * Description:
7958  *      This routine performs the necessary convertions from the DKIOCSGEOM
7959  *      Solaris structure to the format defined in FWARC 2006/195.
7960  *
7961  * Arguments:
7962  *      vdc     - the vDisk client
7963  *      from    - Buffer with data
7964  *      to      - Buffer where data is to be copied to
7965  *      mode    - flags passed to ioctl
7966  *      dir     - direction of copy (in or out)
7967  *
7968  * Return Code:
7969  *      0       - Success
7970  *      ENXIO   - Invalid buffer passed in
7971  *      EFAULT  - ddi_copyin of data failed
7972  */
7973 static int
7974 vdc_set_geom_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
7975 {
7976         _NOTE(ARGUNUSED(vdc))
7977 
7978         vd_geom_t       vdgeom;
7979         void            *tmp_mem = NULL;
7980         int             copy_len = sizeof (struct dk_geom);
7981         int             rv = 0;
7982 
7983         if (dir != VD_COPYIN)
7984                 return (0);     /* nothing to do */
7985 
7986         if ((from == NULL) || (to == NULL))
7987                 return (ENXIO);
7988 
7989         tmp_mem = kmem_alloc(copy_len, KM_SLEEP);
7990 
7991         rv = ddi_copyin(from, tmp_mem, copy_len, mode);
7992         if (rv != 0) {
7993                 kmem_free(tmp_mem, copy_len);
7994                 return (EFAULT);
7995         }
7996         DK_GEOM2VD_GEOM((struct dk_geom *)tmp_mem, &vdgeom);
7997         bcopy(&vdgeom, to, sizeof (vdgeom));
7998         kmem_free(tmp_mem, copy_len);
7999 
8000         return (0);
8001 }
8002 
8003 static int
8004 vdc_get_efi_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
8005 {
8006         _NOTE(ARGUNUSED(vdc))
8007 
8008         vd_efi_t        *vd_efi;
8009         dk_efi_t        dk_efi;
8010         int             rv = 0;
8011         void            *uaddr;
8012 
8013         if ((from == NULL) || (to == NULL))
8014                 return (ENXIO);
8015 
8016         if (dir == VD_COPYIN) {
8017 
8018                 vd_efi = (vd_efi_t *)to;
8019 
8020                 rv = ddi_copyin(from, &dk_efi, sizeof (dk_efi_t), mode);
8021                 if (rv != 0)
8022                         return (EFAULT);
8023 
8024                 vd_efi->lba = dk_efi.dki_lba;
8025                 vd_efi->length = dk_efi.dki_length;
8026                 bzero(vd_efi->data, vd_efi->length);
8027 
8028         } else {
8029 
8030                 rv = ddi_copyin(to, &dk_efi, sizeof (dk_efi_t), mode);
8031                 if (rv != 0)
8032                         return (EFAULT);
8033 
8034                 uaddr = dk_efi.dki_data;
8035 
8036                 dk_efi.dki_data = kmem_alloc(dk_efi.dki_length, KM_SLEEP);
8037 
8038                 VD_EFI2DK_EFI((vd_efi_t *)from, &dk_efi);
8039 
8040                 rv = ddi_copyout(dk_efi.dki_data, uaddr, dk_efi.dki_length,
8041                     mode);
8042                 if (rv != 0)
8043                         return (EFAULT);
8044 
8045                 kmem_free(dk_efi.dki_data, dk_efi.dki_length);
8046         }
8047 
8048         return (0);
8049 }
8050 
8051 static int
8052 vdc_set_efi_convert(vdc_t *vdc, void *from, void *to, int mode, int dir)
8053 {
8054         _NOTE(ARGUNUSED(vdc))
8055 
8056         dk_efi_t        dk_efi;
8057         void            *uaddr;
8058 
8059         if (dir == VD_COPYOUT) {
8060                 /*
8061                  * The disk label may have changed. Revalidate the disk
8062                  * geometry. This will also update the device nodes.
8063                  */
8064                 vdc_validate(vdc);
8065                 return (0);
8066         }
8067 
8068         if ((from == NULL) || (to == NULL))
8069                 return (ENXIO);
8070 
8071         if (ddi_copyin(from, &dk_efi, sizeof (dk_efi_t), mode) != 0)
8072                 return (EFAULT);
8073 
8074         uaddr = dk_efi.dki_data;
8075 
8076         dk_efi.dki_data = kmem_alloc(dk_efi.dki_length, KM_SLEEP);
8077 
8078         if (ddi_copyin(uaddr, dk_efi.dki_data, dk_efi.dki_length, mode) != 0)
8079                 return (EFAULT);
8080 
8081         DK_EFI2VD_EFI(&dk_efi, (vd_efi_t *)to);
8082 
8083         kmem_free(dk_efi.dki_data, dk_efi.dki_length);
8084 
8085         return (0);
8086 }
8087 
8088 
8089 /* -------------------------------------------------------------------------- */
8090 
8091 /*
8092  * Function:
8093  *      vdc_create_fake_geometry()
8094  *
8095  * Description:
8096  *      This routine fakes up the disk info needed for some DKIO ioctls such
8097  *      as DKIOCINFO and DKIOCGMEDIAINFO [just like lofi(7D) and ramdisk(7D) do]
8098  *
8099  *      Note: This function must not be called until the vDisk attributes have
8100  *      been exchanged as part of the handshake with the vDisk server.
8101  *
8102  * Arguments:
8103  *      vdc     - soft state pointer for this instance of the device driver.
8104  *
8105  * Return Code:
8106  *      none.
8107  */
8108 static void
8109 vdc_create_fake_geometry(vdc_t *vdc)
8110 {
8111         ASSERT(vdc != NULL);
8112         ASSERT(vdc->max_xfer_sz != 0);
8113 
8114         /*
8115          * DKIOCINFO support
8116          */
8117         if (vdc->cinfo == NULL)
8118                 vdc->cinfo = kmem_zalloc(sizeof (struct dk_cinfo), KM_SLEEP);
8119 
8120         (void) strcpy(vdc->cinfo->dki_cname, VDC_DRIVER_NAME);
8121         (void) strcpy(vdc->cinfo->dki_dname, VDC_DRIVER_NAME);
8122         /* max_xfer_sz is #blocks so we don't need to divide by vdisk_bsize */
8123         vdc->cinfo->dki_maxtransfer = vdc->max_xfer_sz;
8124 
8125         /*
8126          * We set the controller type to DKC_SCSI_CCS only if the VD_OP_SCSICMD
8127          * operation is supported, otherwise the controller type is DKC_DIRECT.
8128          * Version 1.0 does not support the VD_OP_SCSICMD operation, so the
8129          * controller type is always DKC_DIRECT in that case.
8130          *
8131          * If the virtual disk is backed by a physical CD/DVD device or
8132          * an ISO image, modify the controller type to indicate this
8133          */
8134         switch (vdc->vdisk_media) {
8135         case VD_MEDIA_CD:
8136         case VD_MEDIA_DVD:
8137                 vdc->cinfo->dki_ctype = DKC_CDROM;
8138                 break;
8139         case VD_MEDIA_FIXED:
8140                 if (VD_OP_SUPPORTED(vdc->operations, VD_OP_SCSICMD))
8141                         vdc->cinfo->dki_ctype = DKC_SCSI_CCS;
8142                 else
8143                         vdc->cinfo->dki_ctype = DKC_DIRECT;
8144                 break;
8145         default:
8146                 /* in the case of v1.0 we default to a fixed disk */
8147                 vdc->cinfo->dki_ctype = DKC_DIRECT;
8148                 break;
8149         }
8150         vdc->cinfo->dki_flags = DKI_FMTVOL;
8151         vdc->cinfo->dki_cnum = 0;
8152         vdc->cinfo->dki_addr = 0;
8153         vdc->cinfo->dki_space = 0;
8154         vdc->cinfo->dki_prio = 0;
8155         vdc->cinfo->dki_vec = 0;
8156         vdc->cinfo->dki_unit = vdc->instance;
8157         vdc->cinfo->dki_slave = 0;
8158         /*
8159          * The partition number will be created on the fly depending on the
8160          * actual slice (i.e. minor node) that is used to request the data.
8161          */
8162         vdc->cinfo->dki_partition = 0;
8163 
8164         /*
8165          * DKIOCGMEDIAINFO support
8166          */
8167         if (vdc->minfo == NULL)
8168                 vdc->minfo = kmem_zalloc(sizeof (struct dk_minfo), KM_SLEEP);
8169 
8170         if (vio_ver_is_supported(vdc->ver, 1, 1)) {
8171                 vdc->minfo->dki_media_type =
8172                     VD_MEDIATYPE2DK_MEDIATYPE(vdc->vdisk_media);
8173         } else {
8174                 vdc->minfo->dki_media_type = DK_FIXED_DISK;
8175         }
8176 
8177         vdc->minfo->dki_capacity = vdc->vdisk_size;
8178         vdc->minfo->dki_lbsize = vdc->vdisk_bsize;
8179 }
8180 
8181 static ushort_t
8182 vdc_lbl2cksum(struct dk_label *label)
8183 {
8184         int     count;
8185         ushort_t sum, *sp;
8186 
8187         count = (sizeof (struct dk_label)) / (sizeof (short)) - 1;
8188         sp = (ushort_t *)label;
8189         sum = 0;
8190         while (count--) {
8191                 sum ^= *sp++;
8192         }
8193 
8194         return (sum);
8195 }
8196 
8197 static void
8198 vdc_update_size(vdc_t *vdc, size_t dsk_size, size_t blk_size, size_t xfr_size)
8199 {
8200         vd_err_stats_t  *stp;
8201 
8202         ASSERT(MUTEX_HELD(&vdc->lock));
8203         ASSERT(xfr_size != 0);
8204 
8205         /*
8206          * If the disk size is unknown or sizes are unchanged then don't
8207          * update anything.
8208          */
8209         if (dsk_size == VD_SIZE_UNKNOWN || dsk_size == 0 ||
8210             (blk_size == vdc->vdisk_bsize && dsk_size == vdc->vdisk_size &&
8211             xfr_size == vdc->max_xfer_sz))
8212                 return;
8213 
8214         /*
8215          * We don't know at compile time what the vDisk server will think
8216          * are good values but we apply a large (arbitrary) upper bound to
8217          * prevent memory exhaustion in vdc if it was allocating a DRing
8218          * based of huge values sent by the server. We probably will never
8219          * exceed this except if the message was garbage.
8220          */
8221         if ((xfr_size * blk_size) > (PAGESIZE * DEV_BSIZE)) {
8222                 DMSG(vdc, 0, "[%d] vds block transfer size too big;"
8223                     " using max supported by vdc", vdc->instance);
8224                 xfr_size = maxphys / blk_size;
8225         }
8226 
8227         vdc->max_xfer_sz = xfr_size;
8228         vdc->vdisk_bsize = blk_size;
8229         vdc->vdisk_size = dsk_size;
8230 
8231         stp = (vd_err_stats_t *)vdc->err_stats->ks_data;
8232         stp->vd_capacity.value.ui64 = dsk_size * blk_size;
8233 
8234         vdc->minfo->dki_capacity = dsk_size;
8235         vdc->minfo->dki_lbsize = (uint_t)blk_size;
8236 }
8237 
8238 /*
8239  * Update information about the VIO block size. The VIO block size is the
8240  * same as the vdisk block size which is stored in vdc->vdisk_bsize so we
8241  * do not store that information again.
8242  *
8243  * However, buf structures will always use a logical block size of 512 bytes
8244  * (DEV_BSIZE) and we will need to convert logical block numbers to VIO block
8245  * numbers for each read or write operation using vdc_strategy(). To speed up
8246  * this conversion, we expect the VIO block size to be a power of 2 and a
8247  * multiple 512 bytes (DEV_BSIZE), and we cache some useful information.
8248  *
8249  * The function return EINVAL if the new VIO block size (blk_size) is not a
8250  * power of 2 or not a multiple of 512 bytes, otherwise it returns 0.
8251  */
8252 static int
8253 vdc_update_vio_bsize(vdc_t *vdc, uint32_t blk_size)
8254 {
8255         uint32_t ratio, n;
8256         int nshift = 0;
8257 
8258         vdc->vio_bmask = 0;
8259         vdc->vio_bshift = 0;
8260 
8261         ASSERT(blk_size > 0);
8262 
8263         if ((blk_size % DEV_BSIZE) != 0)
8264                 return (EINVAL);
8265 
8266         ratio = blk_size / DEV_BSIZE;
8267 
8268         for (n = ratio; n > 1; n >>= 1) {
8269                 if ((n & 0x1) != 0) {
8270                         /* blk_size is not a power of 2 */
8271                         return (EINVAL);
8272                 }
8273                 nshift++;
8274         }
8275 
8276         vdc->vio_bshift = nshift;
8277         vdc->vio_bmask = ratio - 1;
8278 
8279         return (0);
8280 }
8281 
8282 /*
8283  * Function:
8284  *      vdc_validate_geometry
8285  *
8286  * Description:
8287  *      This routine discovers the label and geometry of the disk. It stores
8288  *      the disk label and related information in the vdc structure. If it
8289  *      fails to validate the geometry or to discover the disk label then
8290  *      the label is marked as unknown (VD_DISK_LABEL_UNK).
8291  *
8292  * Arguments:
8293  *      vdc     - soft state pointer for this instance of the device driver.
8294  *
8295  * Return Code:
8296  *      0       - success.
8297  *      EINVAL  - unknown disk label.
8298  *      ENOTSUP - geometry not applicable (EFI label).
8299  *      EIO     - error accessing the disk.
8300  */
8301 static int
8302 vdc_validate_geometry(vdc_t *vdc)
8303 {
8304         dev_t   dev;
8305         int     rv, rval;
8306         struct dk_label *label;
8307         struct dk_geom geom;
8308         struct extvtoc vtoc;
8309         efi_gpt_t *gpt;
8310         efi_gpe_t *gpe;
8311         vd_efi_dev_t edev;
8312 
8313         ASSERT(vdc != NULL);
8314         ASSERT(vdc->vtoc != NULL && vdc->geom != NULL);
8315         ASSERT(MUTEX_HELD(&vdc->lock));
8316 
8317         mutex_exit(&vdc->lock);
8318         /*
8319          * Check the disk capacity in case it has changed. If that fails then
8320          * we proceed and we will be using the disk size we currently have.
8321          */
8322         (void) vdc_check_capacity(vdc);
8323         dev = makedevice(ddi_driver_major(vdc->dip),
8324             VD_MAKE_DEV(vdc->instance, 0));
8325 
8326         rv = vd_process_ioctl(dev, DKIOCGGEOM, (caddr_t)&geom, FKIOCTL, &rval);
8327         if (rv == 0)
8328                 rv = vd_process_ioctl(dev, DKIOCGEXTVTOC, (caddr_t)&vtoc,
8329                     FKIOCTL, &rval);
8330 
8331         if (rv == ENOTSUP) {
8332                 /*
8333                  * If the device does not support VTOC then we try
8334                  * to read an EFI label.
8335                  *
8336                  * We need to know the block size and the disk size to
8337                  * be able to read an EFI label.
8338                  */
8339                 if (vdc->vdisk_size == 0) {
8340                         mutex_enter(&vdc->lock);
8341                         vdc_store_label_unk(vdc);
8342                         return (EIO);
8343                 }
8344 
8345                 VDC_EFI_DEV_SET(edev, vdc, vd_process_efi_ioctl);
8346 
8347                 rv = vd_efi_alloc_and_read(&edev, &gpt, &gpe);
8348 
8349                 if (rv) {
8350                         DMSG(vdc, 0, "[%d] Failed to get EFI (err=%d)",
8351                             vdc->instance, rv);
8352                         mutex_enter(&vdc->lock);
8353                         vdc_store_label_unk(vdc);
8354                         return (EIO);
8355                 }
8356 
8357                 mutex_enter(&vdc->lock);
8358                 vdc_store_label_efi(vdc, gpt, gpe);
8359                 vd_efi_free(&edev, gpt, gpe);
8360                 return (ENOTSUP);
8361         }
8362 
8363         if (rv != 0) {
8364                 DMSG(vdc, 0, "[%d] Failed to get VTOC (err=%d)",
8365                     vdc->instance, rv);
8366                 mutex_enter(&vdc->lock);
8367                 vdc_store_label_unk(vdc);
8368                 if (rv != EINVAL)
8369                         rv = EIO;
8370                 return (rv);
8371         }
8372 
8373         /* check that geometry and vtoc are valid */
8374         if (geom.dkg_nhead == 0 || geom.dkg_nsect == 0 ||
8375             vtoc.v_sanity != VTOC_SANE) {
8376                 mutex_enter(&vdc->lock);
8377                 vdc_store_label_unk(vdc);
8378                 return (EINVAL);
8379         }
8380 
8381         /*
8382          * We have a disk and a valid VTOC. However this does not mean
8383          * that the disk currently have a VTOC label. The returned VTOC may
8384          * be a default VTOC to be used for configuring the disk (this is
8385          * what is done for disk image). So we read the label from the
8386          * beginning of the disk to ensure we really have a VTOC label.
8387          *
8388          * FUTURE: This could be the default way for reading the VTOC
8389          * from the disk as opposed to sending the VD_OP_GET_VTOC
8390          * to the server. This will be the default if vdc is implemented
8391          * ontop of cmlb.
8392          */
8393 
8394         /*
8395          * Single slice disk does not support read using an absolute disk
8396          * offset so we just rely on the DKIOCGVTOC ioctl in that case.
8397          */
8398         if (vdc->vdisk_type == VD_DISK_TYPE_SLICE) {
8399                 mutex_enter(&vdc->lock);
8400                 if (vtoc.v_nparts != 1) {
8401                         vdc_store_label_unk(vdc);
8402                         return (EINVAL);
8403                 }
8404                 vdc_store_label_vtoc(vdc, &geom, &vtoc);
8405                 return (0);
8406         }
8407 
8408         if (vtoc.v_nparts != V_NUMPAR) {
8409                 mutex_enter(&vdc->lock);
8410                 vdc_store_label_unk(vdc);
8411                 return (EINVAL);
8412         }
8413 
8414         /*
8415          * Most CD/DVDs do not have a disk label and the label is
8416          * generated by the disk driver.  So the on-disk label check
8417          * below may fail and we return now to avoid this problem.
8418          */
8419         if (vdc->vdisk_media == VD_MEDIA_CD ||
8420             vdc->vdisk_media == VD_MEDIA_DVD) {
8421                 mutex_enter(&vdc->lock);
8422                 vdc_store_label_vtoc(vdc, &geom, &vtoc);
8423                 return (0);
8424         }
8425 
8426         /*
8427          * Read disk label from start of disk
8428          */
8429         label = kmem_alloc(vdc->vdisk_bsize, KM_SLEEP);
8430 
8431         rv = vdc_do_op(vdc, VD_OP_BREAD, (caddr_t)label, vdc->vdisk_bsize,
8432             VD_SLICE_NONE, 0, NULL, VIO_read_dir, VDC_OP_NORMAL);
8433 
8434         if (rv != 0 || label->dkl_magic != DKL_MAGIC ||
8435             label->dkl_cksum != vdc_lbl2cksum(label)) {
8436                 DMSG(vdc, 1, "[%d] Got VTOC with invalid label\n",
8437                     vdc->instance);
8438                 kmem_free(label, vdc->vdisk_bsize);
8439                 mutex_enter(&vdc->lock);
8440                 vdc_store_label_unk(vdc);
8441                 return (EINVAL);
8442         }
8443 
8444         kmem_free(label, vdc->vdisk_bsize);
8445         mutex_enter(&vdc->lock);
8446         vdc_store_label_vtoc(vdc, &geom, &vtoc);
8447         return (0);
8448 }
8449 
8450 /*
8451  * Function:
8452  *      vdc_validate
8453  *
8454  * Description:
8455  *      This routine discovers the label of the disk and create the
8456  *      appropriate device nodes if the label has changed.
8457  *
8458  * Arguments:
8459  *      vdc     - soft state pointer for this instance of the device driver.
8460  *
8461  * Return Code:
8462  *      none.
8463  */
8464 static void
8465 vdc_validate(vdc_t *vdc)
8466 {
8467         vd_disk_label_t old_label;
8468         vd_slice_t old_slice[V_NUMPAR];
8469         int rv;
8470 
8471         ASSERT(!MUTEX_HELD(&vdc->lock));
8472 
8473         mutex_enter(&vdc->lock);
8474 
8475         /* save the current label and vtoc */
8476         old_label = vdc->vdisk_label;
8477         bcopy(vdc->slice, &old_slice, sizeof (vd_slice_t) * V_NUMPAR);
8478 
8479         /* check the geometry */
8480         (void) vdc_validate_geometry(vdc);
8481 
8482         /* if the disk label has changed, update device nodes */
8483         if (vdc->vdisk_type == VD_DISK_TYPE_DISK &&
8484             vdc->vdisk_label != old_label) {
8485 
8486                 if (vdc->vdisk_label == VD_DISK_LABEL_EFI)
8487                         rv = vdc_create_device_nodes_efi(vdc);
8488                 else
8489                         rv = vdc_create_device_nodes_vtoc(vdc);
8490 
8491                 if (rv != 0) {
8492                         DMSG(vdc, 0, "![%d] Failed to update device nodes",
8493                             vdc->instance);
8494                 }
8495         }
8496 
8497         mutex_exit(&vdc->lock);
8498 }
8499 
8500 static void
8501 vdc_validate_task(void *arg)
8502 {
8503         vdc_t *vdc = (vdc_t *)arg;
8504 
8505         vdc_validate(vdc);
8506 
8507         mutex_enter(&vdc->lock);
8508         ASSERT(vdc->validate_pending > 0);
8509         vdc->validate_pending--;
8510         mutex_exit(&vdc->lock);
8511 }
8512 
8513 /*
8514  * Function:
8515  *      vdc_setup_devid()
8516  *
8517  * Description:
8518  *      This routine discovers the devid of a vDisk. It requests the devid of
8519  *      the underlying device from the vDisk server, builds an encapsulated
8520  *      devid based on the retrieved devid and registers that new devid to
8521  *      the vDisk.
8522  *
8523  * Arguments:
8524  *      vdc     - soft state pointer for this instance of the device driver.
8525  *
8526  * Return Code:
8527  *      0       - A devid was succesfully registered for the vDisk
8528  */
8529 static int
8530 vdc_setup_devid(vdc_t *vdc)
8531 {
8532         int rv;
8533         vd_devid_t *vd_devid;
8534         size_t bufsize, bufid_len;
8535         ddi_devid_t vdisk_devid;
8536         char *devid_str;
8537 
8538         /*
8539          * At first sight, we don't know the size of the devid that the
8540          * server will return but this size will be encoded into the
8541          * reply. So we do a first request using a default size then we
8542          * check if this size was large enough. If not then we do a second
8543          * request with the correct size returned by the server. Note that
8544          * ldc requires size to be 8-byte aligned.
8545          */
8546         bufsize = P2ROUNDUP(VD_DEVID_SIZE(VD_DEVID_DEFAULT_LEN),
8547             sizeof (uint64_t));
8548         vd_devid = kmem_zalloc(bufsize, KM_SLEEP);
8549         bufid_len = bufsize - sizeof (vd_efi_t) - 1;
8550 
8551         rv = vdc_do_op(vdc, VD_OP_GET_DEVID, (caddr_t)vd_devid,
8552             bufsize, 0, 0, NULL, VIO_both_dir, 0);
8553 
8554         DMSG(vdc, 2, "do_op returned %d\n", rv);
8555 
8556         if (rv) {
8557                 kmem_free(vd_devid, bufsize);
8558                 return (rv);
8559         }
8560 
8561         if (vd_devid->length > bufid_len) {
8562                 /*
8563                  * The returned devid is larger than the buffer used. Try again
8564                  * with a buffer with the right size.
8565                  */
8566                 kmem_free(vd_devid, bufsize);
8567                 bufsize = P2ROUNDUP(VD_DEVID_SIZE(vd_devid->length),
8568                     sizeof (uint64_t));
8569                 vd_devid = kmem_zalloc(bufsize, KM_SLEEP);
8570                 bufid_len = bufsize - sizeof (vd_efi_t) - 1;
8571 
8572                 rv = vdc_do_sync_op(vdc, VD_OP_GET_DEVID, (caddr_t)vd_devid,
8573                     bufsize, 0, 0, VIO_both_dir, B_TRUE);
8574 
8575                 if (rv) {
8576                         kmem_free(vd_devid, bufsize);
8577                         return (rv);
8578                 }
8579         }
8580 
8581         /*
8582          * The virtual disk should have the same device id as the one associated
8583          * with the physical disk it is mapped on, otherwise sharing a disk
8584          * between a LDom and a non-LDom may not work (for example for a shared
8585          * SVM disk set).
8586          *
8587          * The DDI framework does not allow creating a device id with any
8588          * type so we first create a device id of type DEVID_ENCAP and then
8589          * we restore the orignal type of the physical device.
8590          */
8591 
8592         DMSG(vdc, 2, ": devid length = %d\n", vd_devid->length);
8593 
8594         /* build an encapsulated devid based on the returned devid */
8595         if (ddi_devid_init(vdc->dip, DEVID_ENCAP, vd_devid->length,
8596             vd_devid->id, &vdisk_devid) != DDI_SUCCESS) {
8597                 DMSG(vdc, 1, "[%d] Fail to created devid\n", vdc->instance);
8598                 kmem_free(vd_devid, bufsize);
8599                 return (1);
8600         }
8601 
8602         DEVID_FORMTYPE((impl_devid_t *)vdisk_devid, vd_devid->type);
8603 
8604         ASSERT(ddi_devid_valid(vdisk_devid) == DDI_SUCCESS);
8605 
8606         kmem_free(vd_devid, bufsize);
8607 
8608         if (vdc->devid != NULL) {
8609                 /* check that the devid hasn't changed */
8610                 if (ddi_devid_compare(vdisk_devid, vdc->devid) == 0) {
8611                         ddi_devid_free(vdisk_devid);
8612                         return (0);
8613                 }
8614 
8615                 cmn_err(CE_WARN, "vdisk@%d backend devid has changed",
8616                     vdc->instance);
8617 
8618                 devid_str = ddi_devid_str_encode(vdc->devid, NULL);
8619 
8620                 cmn_err(CE_CONT, "vdisk@%d backend initial devid: %s",
8621                     vdc->instance,
8622                     (devid_str)? devid_str : "<encoding error>");
8623 
8624                 if (devid_str)
8625                         ddi_devid_str_free(devid_str);
8626 
8627                 devid_str = ddi_devid_str_encode(vdisk_devid, NULL);
8628 
8629                 cmn_err(CE_CONT, "vdisk@%d backend current devid: %s",
8630                     vdc->instance,
8631                     (devid_str)? devid_str : "<encoding error>");
8632 
8633                 if (devid_str)
8634                         ddi_devid_str_free(devid_str);
8635 
8636                 ddi_devid_free(vdisk_devid);
8637                 return (1);
8638         }
8639 
8640         if (ddi_devid_register(vdc->dip, vdisk_devid) != DDI_SUCCESS) {
8641                 DMSG(vdc, 1, "[%d] Fail to register devid\n", vdc->instance);
8642                 ddi_devid_free(vdisk_devid);
8643                 return (1);
8644         }
8645 
8646         vdc->devid = vdisk_devid;
8647 
8648         return (0);
8649 }
8650 
8651 static void
8652 vdc_store_label_efi(vdc_t *vdc, efi_gpt_t *gpt, efi_gpe_t *gpe)
8653 {
8654         int i, nparts;
8655 
8656         ASSERT(MUTEX_HELD(&vdc->lock));
8657 
8658         vdc->vdisk_label = VD_DISK_LABEL_EFI;
8659         bzero(vdc->vtoc, sizeof (struct extvtoc));
8660         bzero(vdc->geom, sizeof (struct dk_geom));
8661         bzero(vdc->slice, sizeof (vd_slice_t) * V_NUMPAR);
8662 
8663         nparts = gpt->efi_gpt_NumberOfPartitionEntries;
8664 
8665         for (i = 0; i < nparts && i < VD_EFI_WD_SLICE; i++) {
8666 
8667                 if (gpe[i].efi_gpe_StartingLBA == 0 &&
8668                     gpe[i].efi_gpe_EndingLBA == 0) {
8669                         continue;
8670                 }
8671 
8672                 vdc->slice[i].start = gpe[i].efi_gpe_StartingLBA;
8673                 vdc->slice[i].nblocks = gpe[i].efi_gpe_EndingLBA -
8674                     gpe[i].efi_gpe_StartingLBA + 1;
8675         }
8676 
8677         ASSERT(vdc->vdisk_size != 0);
8678         vdc->slice[VD_EFI_WD_SLICE].start = 0;
8679         vdc->slice[VD_EFI_WD_SLICE].nblocks = vdc->vdisk_size;
8680 
8681 }
8682 
8683 static void
8684 vdc_store_label_vtoc(vdc_t *vdc, struct dk_geom *geom, struct extvtoc *vtoc)
8685 {
8686         int i;
8687 
8688         ASSERT(MUTEX_HELD(&vdc->lock));
8689         ASSERT(vdc->vdisk_bsize == vtoc->v_sectorsz);
8690 
8691         vdc->vdisk_label = VD_DISK_LABEL_VTOC;
8692         bcopy(vtoc, vdc->vtoc, sizeof (struct extvtoc));
8693         bcopy(geom, vdc->geom, sizeof (struct dk_geom));
8694         bzero(vdc->slice, sizeof (vd_slice_t) * V_NUMPAR);
8695 
8696         for (i = 0; i < vtoc->v_nparts; i++) {
8697                 vdc->slice[i].start = vtoc->v_part[i].p_start;
8698                 vdc->slice[i].nblocks = vtoc->v_part[i].p_size;
8699         }
8700 }
8701 
8702 static void
8703 vdc_store_label_unk(vdc_t *vdc)
8704 {
8705         ASSERT(MUTEX_HELD(&vdc->lock));
8706 
8707         vdc->vdisk_label = VD_DISK_LABEL_UNK;
8708         bzero(vdc->vtoc, sizeof (struct extvtoc));
8709         bzero(vdc->geom, sizeof (struct dk_geom));
8710         bzero(vdc->slice, sizeof (vd_slice_t) * V_NUMPAR);
8711 }