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  * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24 /*
  25  * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
  26  */
  27 
  28 /*
  29  * Multiplexed I/O SCSI vHCI implementation
  30  */
  31 
  32 #include <sys/conf.h>
  33 #include <sys/file.h>
  34 #include <sys/ddi.h>
  35 #include <sys/sunddi.h>
  36 #include <sys/scsi/scsi.h>
  37 #include <sys/scsi/impl/scsi_reset_notify.h>
  38 #include <sys/scsi/impl/services.h>
  39 #include <sys/sunmdi.h>
  40 #include <sys/mdi_impldefs.h>
  41 #include <sys/scsi/adapters/scsi_vhci.h>
  42 #include <sys/disp.h>
  43 #include <sys/byteorder.h>
  44 
  45 extern uintptr_t scsi_callback_id;
  46 extern ddi_dma_attr_t scsi_alloc_attr;
  47 
  48 #ifdef  DEBUG
  49 int     vhci_debug = VHCI_DEBUG_DEFAULT_VAL;
  50 #endif
  51 
  52 /* retry for the vhci_do_prout command when a not ready is returned */
  53 int vhci_prout_not_ready_retry = 180;
  54 
  55 /*
  56  * These values are defined to support the internal retry of
  57  * SCSI packets for better sense code handling.
  58  */
  59 #define VHCI_CMD_CMPLT  0
  60 #define VHCI_CMD_RETRY  1
  61 #define VHCI_CMD_ERROR  -1
  62 
  63 #define PROPFLAGS (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM)
  64 #define VHCI_SCSI_PERR          0x47
  65 #define VHCI_PGR_ILLEGALOP      -2
  66 #define VHCI_NUM_UPDATE_TASKQ   8
  67 /* changed to 132 to accomodate HDS */
  68 
  69 /*
  70  * Version Macros
  71  */
  72 #define VHCI_NAME_VERSION       "SCSI VHCI Driver"
  73 char            vhci_version_name[] = VHCI_NAME_VERSION;
  74 
  75 int             vhci_first_time = 0;
  76 clock_t         vhci_to_ticks = 0;
  77 int             vhci_init_wait_timeout = VHCI_INIT_WAIT_TIMEOUT;
  78 kcondvar_t      vhci_cv;
  79 kmutex_t        vhci_global_mutex;
  80 void            *vhci_softstate = NULL; /* for soft state */
  81 
  82 /*
  83  * Flag to delay the retry of the reserve command
  84  */
  85 int             vhci_reserve_delay = 100000;
  86 static int      vhci_path_quiesce_timeout = 60;
  87 static uchar_t  zero_key[MHIOC_RESV_KEY_SIZE];
  88 
  89 /* uscsi delay for a TRAN_BUSY */
  90 static int vhci_uscsi_delay = 100000;
  91 static int vhci_uscsi_retry_count = 180;
  92 /* uscsi_restart_sense timeout id in case it needs to get canceled */
  93 static timeout_id_t vhci_restart_timeid = 0;
  94 
  95 static int      vhci_bus_config_debug = 0;
  96 
  97 /*
  98  * Bidirectional map of 'target-port' to port id <pid> for support of
  99  * iostat(1M) '-Xx' and '-Yx' output.
 100  */
 101 static kmutex_t         vhci_targetmap_mutex;
 102 static uint_t           vhci_targetmap_pid = 1;
 103 static mod_hash_t       *vhci_targetmap_bypid;  /* <pid> -> 'target-port' */
 104 static mod_hash_t       *vhci_targetmap_byport; /* 'target-port' -> <pid> */
 105 
 106 /*
 107  * functions exported by scsi_vhci struct cb_ops
 108  */
 109 static int vhci_open(dev_t *, int, int, cred_t *);
 110 static int vhci_close(dev_t, int, int, cred_t *);
 111 static int vhci_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
 112 
 113 /*
 114  * functions exported by scsi_vhci struct dev_ops
 115  */
 116 static int vhci_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
 117 static int vhci_attach(dev_info_t *, ddi_attach_cmd_t);
 118 static int vhci_detach(dev_info_t *, ddi_detach_cmd_t);
 119 
 120 /*
 121  * functions exported by scsi_vhci scsi_hba_tran_t transport table
 122  */
 123 static int vhci_scsi_tgt_init(dev_info_t *, dev_info_t *,
 124     scsi_hba_tran_t *, struct scsi_device *);
 125 static void vhci_scsi_tgt_free(dev_info_t *, dev_info_t *, scsi_hba_tran_t *,
 126     struct scsi_device *);
 127 static int vhci_pgr_register_start(scsi_vhci_lun_t *, struct scsi_pkt *);
 128 static int vhci_scsi_start(struct scsi_address *, struct scsi_pkt *);
 129 static int vhci_scsi_abort(struct scsi_address *, struct scsi_pkt *);
 130 static int vhci_scsi_reset(struct scsi_address *, int);
 131 static int vhci_scsi_reset_target(struct scsi_address *, int level,
 132     uint8_t select_path);
 133 static int vhci_scsi_reset_bus(struct scsi_address *);
 134 static int vhci_scsi_getcap(struct scsi_address *, char *, int);
 135 static int vhci_scsi_setcap(struct scsi_address *, char *, int, int);
 136 static int vhci_commoncap(struct scsi_address *, char *, int, int, int);
 137 static int vhci_pHCI_cap(struct scsi_address *ap, char *cap, int val, int whom,
 138     mdi_pathinfo_t *pip);
 139 static struct scsi_pkt *vhci_scsi_init_pkt(struct scsi_address *,
 140     struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(), caddr_t);
 141 static void vhci_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *);
 142 static void vhci_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);
 143 static void vhci_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *);
 144 static int vhci_scsi_reset_notify(struct scsi_address *, int, void (*)(caddr_t),
 145     caddr_t);
 146 static int vhci_scsi_get_bus_addr(struct scsi_device *, char *, int);
 147 static int vhci_scsi_get_name(struct scsi_device *, char *, int);
 148 static int vhci_scsi_bus_power(dev_info_t *, void *, pm_bus_power_op_t,
 149     void *, void *);
 150 static int vhci_scsi_bus_config(dev_info_t *, uint_t, ddi_bus_config_op_t,
 151     void *, dev_info_t **);
 152 static int vhci_scsi_bus_unconfig(dev_info_t *, uint_t, ddi_bus_config_op_t,
 153     void *);
 154 static struct scsi_failover_ops *vhci_dev_fo(dev_info_t *, struct scsi_device *,
 155     void **, char **);
 156 
 157 /*
 158  * functions registered with the mpxio framework via mdi_vhci_ops_t
 159  */
 160 static int vhci_pathinfo_init(dev_info_t *, mdi_pathinfo_t *, int);
 161 static int vhci_pathinfo_uninit(dev_info_t *, mdi_pathinfo_t *, int);
 162 static int vhci_pathinfo_state_change(dev_info_t *, mdi_pathinfo_t *,
 163                 mdi_pathinfo_state_t, uint32_t, int);
 164 static int vhci_pathinfo_online(dev_info_t *, mdi_pathinfo_t *, int);
 165 static int vhci_pathinfo_offline(dev_info_t *, mdi_pathinfo_t *, int);
 166 static int vhci_failover(dev_info_t *, dev_info_t *, int);
 167 static void vhci_client_attached(dev_info_t *);
 168 static int vhci_is_dev_supported(dev_info_t *, dev_info_t *, void *);
 169 
 170 static int vhci_ctl(dev_t, int, intptr_t, int, cred_t *, int *);
 171 static int vhci_devctl(dev_t, int, intptr_t, int, cred_t *, int *);
 172 static int vhci_ioc_get_phci_path(sv_iocdata_t *, caddr_t, int, caddr_t);
 173 static int vhci_ioc_get_client_path(sv_iocdata_t *, caddr_t, int, caddr_t);
 174 static int vhci_ioc_get_paddr(sv_iocdata_t *, caddr_t, int, caddr_t);
 175 static int vhci_ioc_send_client_path(caddr_t, sv_iocdata_t *, int, caddr_t);
 176 static void vhci_ioc_devi_to_path(dev_info_t *, caddr_t);
 177 static int vhci_get_phci_path_list(dev_info_t *, sv_path_info_t *, uint_t);
 178 static int vhci_get_client_path_list(dev_info_t *, sv_path_info_t *, uint_t);
 179 static int vhci_get_iocdata(const void *, sv_iocdata_t *, int, caddr_t);
 180 static int vhci_get_iocswitchdata(const void *, sv_switch_to_cntlr_iocdata_t *,
 181     int, caddr_t);
 182 static int vhci_ioc_alloc_pathinfo(sv_path_info_t **, sv_path_info_t **,
 183     uint_t, sv_iocdata_t *, int, caddr_t);
 184 static void vhci_ioc_free_pathinfo(sv_path_info_t *, sv_path_info_t *, uint_t);
 185 static int vhci_ioc_send_pathinfo(sv_path_info_t *, sv_path_info_t *, uint_t,
 186     sv_iocdata_t *, int, caddr_t);
 187 static int vhci_handle_ext_fo(struct scsi_pkt *, int);
 188 static int vhci_efo_watch_cb(caddr_t, struct scsi_watch_result *);
 189 static int vhci_quiesce_lun(struct scsi_vhci_lun *);
 190 static int vhci_pgr_validate_and_register(scsi_vhci_priv_t *);
 191 static void vhci_dispatch_scsi_start(void *);
 192 static void vhci_efo_done(void *);
 193 static void vhci_initiate_auto_failback(void *);
 194 static void vhci_update_pHCI_pkt(struct vhci_pkt *, struct scsi_pkt *);
 195 static int vhci_update_pathinfo(struct scsi_device *, mdi_pathinfo_t *,
 196     struct scsi_failover_ops *, scsi_vhci_lun_t *, struct scsi_vhci *);
 197 static void vhci_kstat_create_pathinfo(mdi_pathinfo_t *);
 198 static int vhci_quiesce_paths(dev_info_t *, dev_info_t *,
 199     scsi_vhci_lun_t *, char *, char *);
 200 
 201 static char *vhci_devnm_to_guid(char *);
 202 static int vhci_bind_transport(struct scsi_address *, struct vhci_pkt *,
 203     int, int (*func)(caddr_t));
 204 static void vhci_intr(struct scsi_pkt *);
 205 static int vhci_do_prout(scsi_vhci_priv_t *);
 206 static void vhci_run_cmd(void *);
 207 static int vhci_do_prin(struct vhci_pkt **);
 208 static struct scsi_pkt *vhci_create_retry_pkt(struct vhci_pkt *);
 209 static struct vhci_pkt *vhci_sync_retry_pkt(struct vhci_pkt *);
 210 static struct scsi_vhci_lun *vhci_lun_lookup(dev_info_t *);
 211 static struct scsi_vhci_lun *vhci_lun_lookup_alloc(dev_info_t *, char *, int *);
 212 static void vhci_lun_free(struct scsi_vhci_lun *dvlp, struct scsi_device *sd);
 213 static int vhci_recovery_reset(scsi_vhci_lun_t *, struct scsi_address *,
 214     uint8_t, uint8_t);
 215 void vhci_update_pathstates(void *);
 216 
 217 #ifdef DEBUG
 218 static void vhci_print_prin_keys(vhci_prin_readkeys_t *, int);
 219 static void vhci_print_cdb(dev_info_t *dip, uint_t level,
 220     char *title, uchar_t *cdb);
 221 static void vhci_clean_print(dev_info_t *dev, uint_t level,
 222     char *title, uchar_t *data, int len);
 223 #endif
 224 static void vhci_print_prout_keys(scsi_vhci_lun_t *, char *);
 225 static void vhci_uscsi_iodone(struct scsi_pkt *pkt);
 226 static void vhci_invalidate_mpapi_lu(struct scsi_vhci *, scsi_vhci_lun_t *);
 227 
 228 /*
 229  * MP-API related functions
 230  */
 231 extern int vhci_mpapi_init(struct scsi_vhci *);
 232 extern void vhci_mpapi_add_dev_prod(struct scsi_vhci *, char *);
 233 extern int vhci_mpapi_ctl(dev_t, int, intptr_t, int, cred_t *, int *);
 234 extern void vhci_update_mpapi_data(struct scsi_vhci *,
 235     scsi_vhci_lun_t *, mdi_pathinfo_t *);
 236 extern void* vhci_get_mpapi_item(struct scsi_vhci *, mpapi_list_header_t *,
 237     uint8_t, void*);
 238 extern void vhci_mpapi_set_path_state(dev_info_t *, mdi_pathinfo_t *, int);
 239 extern int vhci_mpapi_update_tpg_acc_state_for_lu(struct scsi_vhci *,
 240     scsi_vhci_lun_t *);
 241 
 242 #define VHCI_DMA_MAX_XFER_CAP   INT_MAX
 243 
 244 #define VHCI_MAX_PGR_RETRIES    3
 245 
 246 /*
 247  * Macros for the device-type mpxio options
 248  */
 249 #define LOAD_BALANCE_OPTIONS            "load-balance-options"
 250 #define LOGICAL_BLOCK_REGION_SIZE       "region-size"
 251 #define MPXIO_OPTIONS_LIST              "device-type-mpxio-options-list"
 252 #define DEVICE_TYPE_STR                 "device-type"
 253 #define isdigit(ch)                     ((ch) >= '0' && (ch) <= '9')
 254 
 255 static struct cb_ops vhci_cb_ops = {
 256         vhci_open,                      /* open */
 257         vhci_close,                     /* close */
 258         nodev,                          /* strategy */
 259         nodev,                          /* print */
 260         nodev,                          /* dump */
 261         nodev,                          /* read */
 262         nodev,                          /* write */
 263         vhci_ioctl,                     /* ioctl */
 264         nodev,                          /* devmap */
 265         nodev,                          /* mmap */
 266         nodev,                          /* segmap */
 267         nochpoll,                       /* chpoll */
 268         ddi_prop_op,                    /* cb_prop_op */
 269         0,                              /* streamtab */
 270         D_NEW | D_MP,                   /* cb_flag */
 271         CB_REV,                         /* rev */
 272         nodev,                          /* aread */
 273         nodev                           /* awrite */
 274 };
 275 
 276 static struct dev_ops vhci_ops = {
 277         DEVO_REV,
 278         0,
 279         vhci_getinfo,
 280         nulldev,                /* identify */
 281         nulldev,                /* probe */
 282         vhci_attach,            /* attach and detach are mandatory */
 283         vhci_detach,
 284         nodev,                  /* reset */
 285         &vhci_cb_ops,               /* cb_ops */
 286         NULL,                   /* bus_ops */
 287         NULL,                   /* power */
 288         ddi_quiesce_not_needed, /* quiesce */
 289 };
 290 
 291 extern struct mod_ops mod_driverops;
 292 
 293 static struct modldrv modldrv = {
 294         &mod_driverops,
 295         vhci_version_name,      /* module name */
 296         &vhci_ops
 297 };
 298 
 299 static struct modlinkage modlinkage = {
 300         MODREV_1,
 301         &modldrv,
 302         NULL
 303 };
 304 
 305 static mdi_vhci_ops_t vhci_opinfo = {
 306         MDI_VHCI_OPS_REV,
 307         vhci_pathinfo_init,             /* Pathinfo node init callback */
 308         vhci_pathinfo_uninit,           /* Pathinfo uninit callback */
 309         vhci_pathinfo_state_change,     /* Pathinfo node state change */
 310         vhci_failover,                  /* failover callback */
 311         vhci_client_attached,           /* client attached callback     */
 312         vhci_is_dev_supported           /* is device supported by mdi */
 313 };
 314 
 315 /*
 316  * The scsi_failover table defines an ordered set of 'fops' modules supported
 317  * by scsi_vhci.  Currently, initialize this table from the 'ddi-forceload'
 318  * property specified in scsi_vhci.conf.
 319  */
 320 static struct scsi_failover {
 321         ddi_modhandle_t                 sf_mod;
 322         struct scsi_failover_ops        *sf_sfo;
 323 } *scsi_failover_table;
 324 static uint_t   scsi_nfailover;
 325 
 326 int
 327 _init(void)
 328 {
 329         int     rval;
 330 
 331         /*
 332          * Allocate soft state and prepare to do ddi_soft_state_zalloc()
 333          * before registering with the transport first.
 334          */
 335         if ((rval = ddi_soft_state_init(&vhci_softstate,
 336             sizeof (struct scsi_vhci), 1)) != 0) {
 337                 VHCI_DEBUG(1, (CE_NOTE, NULL,
 338                     "!_init:soft state init failed\n"));
 339                 return (rval);
 340         }
 341 
 342         if ((rval = scsi_hba_init(&modlinkage)) != 0) {
 343                 VHCI_DEBUG(1, (CE_NOTE, NULL,
 344                     "!_init: scsi hba init failed\n"));
 345                 ddi_soft_state_fini(&vhci_softstate);
 346                 return (rval);
 347         }
 348 
 349         mutex_init(&vhci_global_mutex, NULL, MUTEX_DRIVER, NULL);
 350         cv_init(&vhci_cv, NULL, CV_DRIVER, NULL);
 351 
 352         mutex_init(&vhci_targetmap_mutex, NULL, MUTEX_DRIVER, NULL);
 353         vhci_targetmap_byport = mod_hash_create_strhash(
 354             "vhci_targetmap_byport", 256, mod_hash_null_valdtor);
 355         vhci_targetmap_bypid = mod_hash_create_idhash(
 356             "vhci_targetmap_bypid", 256, mod_hash_null_valdtor);
 357 
 358         if ((rval = mod_install(&modlinkage)) != 0) {
 359                 VHCI_DEBUG(1, (CE_NOTE, NULL, "!_init: mod_install failed\n"));
 360                 if (vhci_targetmap_bypid)
 361                         mod_hash_destroy_idhash(vhci_targetmap_bypid);
 362                 if (vhci_targetmap_byport)
 363                         mod_hash_destroy_strhash(vhci_targetmap_byport);
 364                 mutex_destroy(&vhci_targetmap_mutex);
 365                 cv_destroy(&vhci_cv);
 366                 mutex_destroy(&vhci_global_mutex);
 367                 scsi_hba_fini(&modlinkage);
 368                 ddi_soft_state_fini(&vhci_softstate);
 369         }
 370         return (rval);
 371 }
 372 
 373 
 374 /*
 375  * the system is done with us as a driver, so clean up
 376  */
 377 int
 378 _fini(void)
 379 {
 380         int rval;
 381 
 382         /*
 383          * don't start cleaning up until we know that the module remove
 384          * has worked  -- if this works, then we know that each instance
 385          * has successfully been DDI_DETACHed
 386          */
 387         if ((rval = mod_remove(&modlinkage)) != 0) {
 388                 VHCI_DEBUG(4, (CE_NOTE, NULL, "!_fini: mod_remove failed\n"));
 389                 return (rval);
 390         }
 391 
 392         if (vhci_targetmap_bypid)
 393                 mod_hash_destroy_idhash(vhci_targetmap_bypid);
 394         if (vhci_targetmap_byport)
 395                 mod_hash_destroy_strhash(vhci_targetmap_byport);
 396         mutex_destroy(&vhci_targetmap_mutex);
 397         cv_destroy(&vhci_cv);
 398         mutex_destroy(&vhci_global_mutex);
 399         scsi_hba_fini(&modlinkage);
 400         ddi_soft_state_fini(&vhci_softstate);
 401 
 402         return (rval);
 403 }
 404 
 405 int
 406 _info(struct modinfo *modinfop)
 407 {
 408         return (mod_info(&modlinkage, modinfop));
 409 }
 410 
 411 /*
 412  * Lookup scsi_failover by "short name" of failover module.
 413  */
 414 struct scsi_failover_ops *
 415 vhci_failover_ops_by_name(char *name)
 416 {
 417         struct scsi_failover    *sf;
 418 
 419         for (sf = scsi_failover_table; sf->sf_mod; sf++) {
 420                 if (sf->sf_sfo == NULL)
 421                         continue;
 422                 if (strcmp(sf->sf_sfo->sfo_name, name) == 0)
 423                         return (sf->sf_sfo);
 424         }
 425         return (NULL);
 426 }
 427 
 428 /*
 429  * Load all scsi_failover_ops 'fops' modules.
 430  */
 431 static void
 432 vhci_failover_modopen(struct scsi_vhci *vhci)
 433 {
 434         char                    **module;
 435         int                     i;
 436         struct scsi_failover    *sf;
 437         char                    **dt;
 438         int                     e;
 439 
 440         if (scsi_failover_table)
 441                 return;
 442 
 443         /* Get the list of modules from scsi_vhci.conf */
 444         if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY,
 445             vhci->vhci_dip, DDI_PROP_DONTPASS, "ddi-forceload",
 446             &module, &scsi_nfailover) != DDI_PROP_SUCCESS) {
 447                 cmn_err(CE_WARN, "scsi_vhci: "
 448                     "scsi_vhci.conf is missing 'ddi-forceload'");
 449                 return;
 450         }
 451         if (scsi_nfailover == 0) {
 452                 cmn_err(CE_WARN, "scsi_vhci: "
 453                     "scsi_vhci.conf has empty 'ddi-forceload'");
 454                 ddi_prop_free(module);
 455                 return;
 456         }
 457 
 458         /* allocate failover table based on number of modules */
 459         scsi_failover_table = (struct scsi_failover *)
 460             kmem_zalloc(sizeof (struct scsi_failover) * (scsi_nfailover + 1),
 461             KM_SLEEP);
 462 
 463         /* loop over modules specified in scsi_vhci.conf and open each module */
 464         for (i = 0, sf = scsi_failover_table; i < scsi_nfailover; i++) {
 465                 if (module[i] == NULL)
 466                         continue;
 467 
 468                 sf->sf_mod = ddi_modopen(module[i], KRTLD_MODE_FIRST, &e);
 469                 if (sf->sf_mod == NULL) {
 470                         /*
 471                          * A module returns EEXIST if other software is
 472                          * supporting the intended function: for example
 473                          * the scsi_vhci_f_sum_emc module returns EEXIST
 474                          * from _init if EMC powerpath software is installed.
 475                          */
 476                         if (e != EEXIST)
 477                                 cmn_err(CE_WARN, "scsi_vhci: unable to open "
 478                                     "module '%s', error %d", module[i], e);
 479                         continue;
 480                 }
 481                 sf->sf_sfo = ddi_modsym(sf->sf_mod,
 482                     "scsi_vhci_failover_ops", &e);
 483                 if (sf->sf_sfo == NULL) {
 484                         cmn_err(CE_WARN, "scsi_vhci: "
 485                             "unable to import 'scsi_failover_ops' from '%s', "
 486                             "error %d", module[i], e);
 487                         (void) ddi_modclose(sf->sf_mod);
 488                         sf->sf_mod = NULL;
 489                         continue;
 490                 }
 491 
 492                 /* register vid/pid of devices supported with mpapi */
 493                 for (dt = sf->sf_sfo->sfo_devices; *dt; dt++)
 494                         vhci_mpapi_add_dev_prod(vhci, *dt);
 495                 sf++;
 496         }
 497 
 498         /* verify that at least the "well-known" modules were there */
 499         if (vhci_failover_ops_by_name(SFO_NAME_SYM) == NULL)
 500                 cmn_err(CE_WARN, "scsi_vhci: well-known module \""
 501                     SFO_NAME_SYM "\" not defined in scsi_vhci.conf's "
 502                     "'ddi-forceload'");
 503         if (vhci_failover_ops_by_name(SFO_NAME_TPGS) == NULL)
 504                 cmn_err(CE_WARN, "scsi_vhci: well-known module \""
 505                     SFO_NAME_TPGS "\" not defined in scsi_vhci.conf's "
 506                     "'ddi-forceload'");
 507 
 508         /* call sfo_init for modules that need it */
 509         for (sf = scsi_failover_table; sf->sf_mod; sf++) {
 510                 if (sf->sf_sfo && sf->sf_sfo->sfo_init)
 511                         sf->sf_sfo->sfo_init();
 512         }
 513 
 514         ddi_prop_free(module);
 515 }
 516 
 517 /*
 518  * unload all loaded scsi_failover_ops modules
 519  */
 520 static void
 521 vhci_failover_modclose()
 522 {
 523         struct scsi_failover    *sf;
 524 
 525         for (sf = scsi_failover_table; sf->sf_mod; sf++) {
 526                 if ((sf->sf_mod == NULL) || (sf->sf_sfo == NULL))
 527                         continue;
 528                 (void) ddi_modclose(sf->sf_mod);
 529                 sf->sf_mod = NULL;
 530                 sf->sf_sfo = NULL;
 531         }
 532 
 533         if (scsi_failover_table && scsi_nfailover)
 534                 kmem_free(scsi_failover_table,
 535                     sizeof (struct scsi_failover) * (scsi_nfailover + 1));
 536         scsi_failover_table = NULL;
 537         scsi_nfailover = 0;
 538 }
 539 
 540 /* ARGSUSED */
 541 static int
 542 vhci_open(dev_t *devp, int flag, int otype, cred_t *credp)
 543 {
 544         struct scsi_vhci        *vhci;
 545 
 546         if (otype != OTYP_CHR) {
 547                 return (EINVAL);
 548         }
 549 
 550         vhci = ddi_get_soft_state(vhci_softstate, MINOR2INST(getminor(*devp)));
 551         if (vhci == NULL) {
 552                 VHCI_DEBUG(1, (CE_NOTE, NULL, "vhci_open: failed ENXIO\n"));
 553                 return (ENXIO);
 554         }
 555 
 556         mutex_enter(&vhci->vhci_mutex);
 557         if ((flag & FEXCL) && (vhci->vhci_state & VHCI_STATE_OPEN)) {
 558                 mutex_exit(&vhci->vhci_mutex);
 559                 vhci_log(CE_NOTE, vhci->vhci_dip,
 560                     "!vhci%d: Already open\n", getminor(*devp));
 561                 return (EBUSY);
 562         }
 563 
 564         vhci->vhci_state |= VHCI_STATE_OPEN;
 565         mutex_exit(&vhci->vhci_mutex);
 566         return (0);
 567 }
 568 
 569 
 570 /* ARGSUSED */
 571 static int
 572 vhci_close(dev_t dev, int flag, int otype, cred_t *credp)
 573 {
 574         struct scsi_vhci        *vhci;
 575 
 576         if (otype != OTYP_CHR) {
 577                 return (EINVAL);
 578         }
 579 
 580         vhci = ddi_get_soft_state(vhci_softstate, MINOR2INST(getminor(dev)));
 581         if (vhci == NULL) {
 582                 VHCI_DEBUG(1, (CE_NOTE, NULL, "vhci_close: failed ENXIO\n"));
 583                 return (ENXIO);
 584         }
 585 
 586         mutex_enter(&vhci->vhci_mutex);
 587         vhci->vhci_state &= ~VHCI_STATE_OPEN;
 588         mutex_exit(&vhci->vhci_mutex);
 589 
 590         return (0);
 591 }
 592 
 593 /* ARGSUSED */
 594 static int
 595 vhci_ioctl(dev_t dev, int cmd, intptr_t data, int mode,
 596         cred_t *credp, int *rval)
 597 {
 598         if (IS_DEVCTL(cmd)) {
 599                 return (vhci_devctl(dev, cmd, data, mode, credp, rval));
 600         } else if (cmd == MP_CMD) {
 601                 return (vhci_mpapi_ctl(dev, cmd, data, mode, credp, rval));
 602         } else {
 603                 return (vhci_ctl(dev, cmd, data, mode, credp, rval));
 604         }
 605 }
 606 
 607 /*
 608  * attach the module
 609  */
 610 static int
 611 vhci_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
 612 {
 613         int                     rval = DDI_FAILURE;
 614         int                     scsi_hba_attached = 0;
 615         int                     vhci_attached = 0;
 616         int                     mutex_initted = 0;
 617         int                     instance;
 618         struct scsi_vhci        *vhci;
 619         scsi_hba_tran_t         *tran;
 620         char                    cache_name_buf[64];
 621         char                    *data;
 622 
 623         VHCI_DEBUG(4, (CE_NOTE, NULL, "vhci_attach: cmd=0x%x\n", cmd));
 624 
 625         instance = ddi_get_instance(dip);
 626 
 627         switch (cmd) {
 628         case DDI_ATTACH:
 629                 break;
 630 
 631         case DDI_RESUME:
 632         case DDI_PM_RESUME:
 633                 VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_attach: resume not yet"
 634                     "implemented\n"));
 635                 return (rval);
 636 
 637         default:
 638                 VHCI_DEBUG(1, (CE_NOTE, NULL,
 639                     "!vhci_attach: unknown ddi command\n"));
 640                 return (rval);
 641         }
 642 
 643         /*
 644          * Allocate vhci data structure.
 645          */
 646         if (ddi_soft_state_zalloc(vhci_softstate, instance) != DDI_SUCCESS) {
 647                 VHCI_DEBUG(1, (CE_NOTE, dip, "!vhci_attach:"
 648                     "soft state alloc failed\n"));
 649                 return (DDI_FAILURE);
 650         }
 651 
 652         if ((vhci = ddi_get_soft_state(vhci_softstate, instance)) == NULL) {
 653                 VHCI_DEBUG(1, (CE_NOTE, dip, "!vhci_attach:"
 654                     "bad soft state\n"));
 655                 ddi_soft_state_free(vhci_softstate, instance);
 656                 return (DDI_FAILURE);
 657         }
 658 
 659         /* Allocate packet cache */
 660         (void) snprintf(cache_name_buf, sizeof (cache_name_buf),
 661             "vhci%d_cache", instance);
 662 
 663         mutex_init(&vhci->vhci_mutex, NULL, MUTEX_DRIVER, NULL);
 664         mutex_initted++;
 665 
 666         /*
 667          * Allocate a transport structure
 668          */
 669         tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);
 670         ASSERT(tran != NULL);
 671 
 672         vhci->vhci_tran              = tran;
 673         vhci->vhci_dip               = dip;
 674         vhci->vhci_instance  = instance;
 675 
 676         tran->tran_hba_private       = vhci;
 677         tran->tran_tgt_init  = vhci_scsi_tgt_init;
 678         tran->tran_tgt_probe = NULL;
 679         tran->tran_tgt_free  = vhci_scsi_tgt_free;
 680 
 681         tran->tran_start     = vhci_scsi_start;
 682         tran->tran_abort     = vhci_scsi_abort;
 683         tran->tran_reset     = vhci_scsi_reset;
 684         tran->tran_getcap    = vhci_scsi_getcap;
 685         tran->tran_setcap    = vhci_scsi_setcap;
 686         tran->tran_init_pkt  = vhci_scsi_init_pkt;
 687         tran->tran_destroy_pkt       = vhci_scsi_destroy_pkt;
 688         tran->tran_dmafree   = vhci_scsi_dmafree;
 689         tran->tran_sync_pkt  = vhci_scsi_sync_pkt;
 690         tran->tran_reset_notify = vhci_scsi_reset_notify;
 691 
 692         tran->tran_get_bus_addr      = vhci_scsi_get_bus_addr;
 693         tran->tran_get_name  = vhci_scsi_get_name;
 694         tran->tran_bus_reset = NULL;
 695         tran->tran_quiesce   = NULL;
 696         tran->tran_unquiesce = NULL;
 697 
 698         /*
 699          * register event notification routines with scsa
 700          */
 701         tran->tran_get_eventcookie = NULL;
 702         tran->tran_add_eventcall = NULL;
 703         tran->tran_remove_eventcall = NULL;
 704         tran->tran_post_event        = NULL;
 705 
 706         tran->tran_bus_power = vhci_scsi_bus_power;
 707 
 708         tran->tran_bus_config        = vhci_scsi_bus_config;
 709         tran->tran_bus_unconfig      = vhci_scsi_bus_unconfig;
 710 
 711         /*
 712          * Attach this instance with the mpxio framework
 713          */
 714         if (mdi_vhci_register(MDI_HCI_CLASS_SCSI, dip, &vhci_opinfo, 0)
 715             != MDI_SUCCESS) {
 716                 VHCI_DEBUG(1, (CE_NOTE, dip, "!vhci_attach:"
 717                     "mdi_vhci_register failed\n"));
 718                 goto attach_fail;
 719         }
 720         vhci_attached++;
 721 
 722         /*
 723          * Attach this instance of the hba.
 724          *
 725          * Regarding dma attributes: Since scsi_vhci is a virtual scsi HBA
 726          * driver, it has nothing to do with DMA. However, when calling
 727          * scsi_hba_attach_setup() we need to pass something valid in the
 728          * dma attributes parameter. So we just use scsi_alloc_attr.
 729          * SCSA itself seems to care only for dma_attr_minxfer and
 730          * dma_attr_burstsizes fields of dma attributes structure.
 731          * It expects those fileds to be non-zero.
 732          */
 733         if (scsi_hba_attach_setup(dip, &scsi_alloc_attr, tran,
 734             SCSI_HBA_ADDR_COMPLEX) != DDI_SUCCESS) {
 735                 VHCI_DEBUG(1, (CE_NOTE, dip, "!vhci_attach:"
 736                     "hba attach failed\n"));
 737                 goto attach_fail;
 738         }
 739         scsi_hba_attached++;
 740 
 741         if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
 742             INST2DEVCTL(instance), DDI_NT_SCSI_NEXUS, 0) != DDI_SUCCESS) {
 743                 VHCI_DEBUG(1, (CE_NOTE, dip, "!vhci_attach:"
 744                     " ddi_create_minor_node failed\n"));
 745                 goto attach_fail;
 746         }
 747 
 748         /*
 749          * Set pm-want-child-notification property for
 750          * power management of the phci and client
 751          */
 752         if (ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP,
 753             "pm-want-child-notification?", NULL, NULL) != DDI_PROP_SUCCESS) {
 754                 cmn_err(CE_WARN,
 755                     "%s%d fail to create pm-want-child-notification? prop",
 756                     ddi_driver_name(dip), ddi_get_instance(dip));
 757                 goto attach_fail;
 758         }
 759 
 760         vhci->vhci_taskq = taskq_create("vhci_taskq", 1, MINCLSYSPRI, 1, 4, 0);
 761         vhci->vhci_update_pathstates_taskq =
 762             taskq_create("vhci_update_pathstates", VHCI_NUM_UPDATE_TASKQ,
 763             MINCLSYSPRI, 1, 4, 0);
 764         ASSERT(vhci->vhci_taskq);
 765         ASSERT(vhci->vhci_update_pathstates_taskq);
 766 
 767         /*
 768          * Set appropriate configuration flags based on options set in
 769          * conf file.
 770          */
 771         vhci->vhci_conf_flags = 0;
 772         if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, PROPFLAGS,
 773             "auto-failback", &data) == DDI_SUCCESS) {
 774                 if (strcmp(data, "enable") == 0)
 775                         vhci->vhci_conf_flags |= VHCI_CONF_FLAGS_AUTO_FAILBACK;
 776                 ddi_prop_free(data);
 777         }
 778 
 779         if (!(vhci->vhci_conf_flags & VHCI_CONF_FLAGS_AUTO_FAILBACK))
 780                 vhci_log(CE_NOTE, dip, "!Auto-failback capability "
 781                     "disabled through scsi_vhci.conf file.");
 782 
 783         /*
 784          * Allocate an mpapi private structure
 785          */
 786         vhci->mp_priv = kmem_zalloc(sizeof (mpapi_priv_t), KM_SLEEP);
 787         if (vhci_mpapi_init(vhci) != 0) {
 788                 VHCI_DEBUG(1, (CE_WARN, NULL, "!vhci_attach: "
 789                     "vhci_mpapi_init() failed"));
 790         }
 791 
 792         vhci_failover_modopen(vhci);            /* load failover modules */
 793 
 794         ddi_report_dev(dip);
 795         return (DDI_SUCCESS);
 796 
 797 attach_fail:
 798         if (vhci_attached)
 799                 (void) mdi_vhci_unregister(dip, 0);
 800 
 801         if (scsi_hba_attached)
 802                 (void) scsi_hba_detach(dip);
 803 
 804         if (vhci->vhci_tran)
 805                 scsi_hba_tran_free(vhci->vhci_tran);
 806 
 807         if (mutex_initted) {
 808                 mutex_destroy(&vhci->vhci_mutex);
 809         }
 810 
 811         ddi_soft_state_free(vhci_softstate, instance);
 812         return (DDI_FAILURE);
 813 }
 814 
 815 
 816 /*ARGSUSED*/
 817 static int
 818 vhci_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
 819 {
 820         int                     instance = ddi_get_instance(dip);
 821         scsi_hba_tran_t         *tran;
 822         struct scsi_vhci        *vhci;
 823 
 824         VHCI_DEBUG(4, (CE_NOTE, NULL, "vhci_detach: cmd=0x%x\n", cmd));
 825 
 826         if ((tran = ddi_get_driver_private(dip)) == NULL)
 827                 return (DDI_FAILURE);
 828 
 829         vhci = TRAN2HBAPRIVATE(tran);
 830         if (!vhci) {
 831                 return (DDI_FAILURE);
 832         }
 833 
 834         switch (cmd) {
 835         case DDI_DETACH:
 836                 break;
 837 
 838         case DDI_SUSPEND:
 839         case DDI_PM_SUSPEND:
 840                 VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_detach: suspend/pm not yet"
 841                     "implemented\n"));
 842                 return (DDI_FAILURE);
 843 
 844         default:
 845                 VHCI_DEBUG(1, (CE_NOTE, NULL,
 846                     "!vhci_detach: unknown ddi command\n"));
 847                 return (DDI_FAILURE);
 848         }
 849 
 850         (void) mdi_vhci_unregister(dip, 0);
 851         (void) scsi_hba_detach(dip);
 852         scsi_hba_tran_free(tran);
 853 
 854         if (ddi_prop_remove(DDI_DEV_T_NONE, dip,
 855             "pm-want-child-notification?") != DDI_PROP_SUCCESS) {
 856                 cmn_err(CE_WARN,
 857                     "%s%d unable to remove prop pm-want_child_notification?",
 858                     ddi_driver_name(dip), ddi_get_instance(dip));
 859         }
 860         if (vhci_restart_timeid != 0) {
 861                 (void) untimeout(vhci_restart_timeid);
 862         }
 863         vhci_restart_timeid = 0;
 864 
 865         mutex_destroy(&vhci->vhci_mutex);
 866         vhci->vhci_dip = NULL;
 867         vhci->vhci_tran = NULL;
 868         taskq_destroy(vhci->vhci_taskq);
 869         taskq_destroy(vhci->vhci_update_pathstates_taskq);
 870         ddi_remove_minor_node(dip, NULL);
 871         ddi_soft_state_free(vhci_softstate, instance);
 872 
 873         vhci_failover_modclose();               /* unload failover modules */
 874         return (DDI_SUCCESS);
 875 }
 876 
 877 /*
 878  * vhci_getinfo()
 879  * Given the device number, return the devinfo pointer or the
 880  * instance number.
 881  * Note: always succeed DDI_INFO_DEVT2INSTANCE, even before attach.
 882  */
 883 
 884 /*ARGSUSED*/
 885 static int
 886 vhci_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
 887 {
 888         struct scsi_vhci        *vhcip;
 889         int                     instance = MINOR2INST(getminor((dev_t)arg));
 890 
 891         switch (cmd) {
 892         case DDI_INFO_DEVT2DEVINFO:
 893                 vhcip = ddi_get_soft_state(vhci_softstate, instance);
 894                 if (vhcip != NULL)
 895                         *result = vhcip->vhci_dip;
 896                 else {
 897                         *result = NULL;
 898                         return (DDI_FAILURE);
 899                 }
 900                 break;
 901 
 902         case DDI_INFO_DEVT2INSTANCE:
 903                 *result = (void *)(uintptr_t)instance;
 904                 break;
 905 
 906         default:
 907                 return (DDI_FAILURE);
 908         }
 909 
 910         return (DDI_SUCCESS);
 911 }
 912 
 913 /*ARGSUSED*/
 914 static int
 915 vhci_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
 916         scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
 917 {
 918         char                    *guid;
 919         scsi_vhci_lun_t         *vlun;
 920         struct scsi_vhci        *vhci;
 921         clock_t                 from_ticks;
 922         mdi_pathinfo_t          *pip;
 923         int                     rval;
 924 
 925         ASSERT(hba_dip != NULL);
 926         ASSERT(tgt_dip != NULL);
 927 
 928         if (ddi_prop_lookup_string(DDI_DEV_T_ANY, tgt_dip, PROPFLAGS,
 929             MDI_CLIENT_GUID_PROP, &guid) != DDI_SUCCESS) {
 930                 /*
 931                  * This must be the .conf node without GUID property.
 932                  * The node under fp already inserts a delay, so we
 933                  * just return from here. We rely on this delay to have
 934                  * all dips be posted to the ndi hotplug thread's newdev
 935                  * list. This is necessary for the deferred attach
 936                  * mechanism to work and opens() done soon after boot to
 937                  * succeed.
 938                  */
 939                 VHCI_DEBUG(4, (CE_WARN, hba_dip, "tgt_init: lun guid "
 940                     "property failed"));
 941                 return (DDI_NOT_WELL_FORMED);
 942         }
 943 
 944         if (ndi_dev_is_persistent_node(tgt_dip) == 0) {
 945                 /*
 946                  * This must be .conf node with the GUID property. We don't
 947                  * merge property by ndi_merge_node() here  because the
 948                  * devi_addr_buf of .conf node is "" always according the
 949                  * implementation of vhci_scsi_get_name_bus_addr().
 950                  */
 951                 ddi_set_name_addr(tgt_dip, NULL);
 952                 return (DDI_FAILURE);
 953         }
 954 
 955         vhci = ddi_get_soft_state(vhci_softstate, ddi_get_instance(hba_dip));
 956         ASSERT(vhci != NULL);
 957 
 958         VHCI_DEBUG(4, (CE_NOTE, hba_dip,
 959             "!tgt_init: called for %s (instance %d)\n",
 960             ddi_driver_name(tgt_dip), ddi_get_instance(tgt_dip)));
 961 
 962         vlun = vhci_lun_lookup(tgt_dip);
 963 
 964         mutex_enter(&vhci_global_mutex);
 965 
 966         from_ticks = ddi_get_lbolt();
 967         if (vhci_to_ticks == 0) {
 968                 vhci_to_ticks = from_ticks +
 969                     drv_usectohz(vhci_init_wait_timeout);
 970         }
 971 
 972 #if DEBUG
 973         if (vlun) {
 974                 VHCI_DEBUG(1, (CE_WARN, hba_dip, "tgt_init: "
 975                     "vhci_scsi_tgt_init: guid %s : found vlun 0x%p "
 976                     "from_ticks %lx to_ticks %lx",
 977                     guid, (void *)vlun, from_ticks, vhci_to_ticks));
 978         } else {
 979                 VHCI_DEBUG(1, (CE_WARN, hba_dip, "tgt_init: "
 980                     "vhci_scsi_tgt_init: guid %s : vlun not found "
 981                     "from_ticks %lx to_ticks %lx", guid, from_ticks,
 982                     vhci_to_ticks));
 983         }
 984 #endif
 985 
 986         rval = mdi_select_path(tgt_dip, NULL,
 987             (MDI_SELECT_ONLINE_PATH | MDI_SELECT_STANDBY_PATH), NULL, &pip);
 988         if (rval == MDI_SUCCESS) {
 989                 mdi_rele_path(pip);
 990         }
 991 
 992         /*
 993          * Wait for the following conditions :
 994          *      1. no vlun available yet
 995          *      2. no path established
 996          *      3. timer did not expire
 997          */
 998         while ((vlun == NULL) || (mdi_client_get_path_count(tgt_dip) == 0) ||
 999             (rval != MDI_SUCCESS)) {
1000                 if (vlun && vlun->svl_not_supported) {
1001                         VHCI_DEBUG(1, (CE_WARN, hba_dip, "tgt_init: "
1002                             "vlun 0x%p lun guid %s not supported!",
1003                             (void *)vlun, guid));
1004                         mutex_exit(&vhci_global_mutex);
1005                         ddi_prop_free(guid);
1006                         return (DDI_NOT_WELL_FORMED);
1007                 }
1008                 if ((vhci_first_time == 0) && (from_ticks >= vhci_to_ticks)) {
1009                         vhci_first_time = 1;
1010                 }
1011                 if (vhci_first_time == 1) {
1012                         VHCI_DEBUG(1, (CE_WARN, hba_dip, "vhci_scsi_tgt_init: "
1013                             "no wait for %s. from_tick %lx, to_tick %lx",
1014                             guid, from_ticks, vhci_to_ticks));
1015                         mutex_exit(&vhci_global_mutex);
1016                         ddi_prop_free(guid);
1017                         return (DDI_NOT_WELL_FORMED);
1018                 }
1019 
1020                 if (cv_timedwait(&vhci_cv,
1021                     &vhci_global_mutex, vhci_to_ticks) == -1) {
1022                         /* Timed out */
1023 #ifdef DEBUG
1024                         if (vlun == NULL) {
1025                                 VHCI_DEBUG(1, (CE_WARN, hba_dip,
1026                                     "tgt_init: no vlun for %s!", guid));
1027                         } else if (mdi_client_get_path_count(tgt_dip) == 0) {
1028                                 VHCI_DEBUG(1, (CE_WARN, hba_dip,
1029                                     "tgt_init: client path count is "
1030                                     "zero for %s!", guid));
1031                         } else {
1032                                 VHCI_DEBUG(1, (CE_WARN, hba_dip,
1033                                     "tgt_init: client path not "
1034                                     "available yet for %s!", guid));
1035                         }
1036 #endif /* DEBUG */
1037                         mutex_exit(&vhci_global_mutex);
1038                         ddi_prop_free(guid);
1039                         return (DDI_NOT_WELL_FORMED);
1040                 }
1041                 vlun = vhci_lun_lookup(tgt_dip);
1042                 rval = mdi_select_path(tgt_dip, NULL,
1043                     (MDI_SELECT_ONLINE_PATH | MDI_SELECT_STANDBY_PATH),
1044                     NULL, &pip);
1045                 if (rval == MDI_SUCCESS) {
1046                         mdi_rele_path(pip);
1047                 }
1048                 from_ticks = ddi_get_lbolt();
1049         }
1050         mutex_exit(&vhci_global_mutex);
1051 
1052         ASSERT(vlun != NULL);
1053         ddi_prop_free(guid);
1054 
1055         scsi_device_hba_private_set(sd, vlun);
1056 
1057         return (DDI_SUCCESS);
1058 }
1059 
1060 /*ARGSUSED*/
1061 static void
1062 vhci_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
1063         scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
1064 {
1065         struct scsi_vhci_lun *dvlp;
1066         ASSERT(mdi_client_get_path_count(tgt_dip) <= 0);
1067         dvlp = (struct scsi_vhci_lun *)scsi_device_hba_private_get(sd);
1068         ASSERT(dvlp != NULL);
1069 
1070         vhci_lun_free(dvlp, sd);
1071 }
1072 
1073 /*
1074  * a PGR register command has started; copy the info we need
1075  */
1076 int
1077 vhci_pgr_register_start(scsi_vhci_lun_t *vlun, struct scsi_pkt *pkt)
1078 {
1079         struct vhci_pkt         *vpkt = TGTPKT2VHCIPKT(pkt);
1080         void                    *addr;
1081 
1082         if (!vpkt->vpkt_tgt_init_bp)
1083                 return (TRAN_BADPKT);
1084 
1085         addr = bp_mapin_common(vpkt->vpkt_tgt_init_bp,
1086             (vpkt->vpkt_flags & CFLAG_NOWAIT) ? VM_NOSLEEP : VM_SLEEP);
1087         if (addr == NULL)
1088                 return (TRAN_BUSY);
1089 
1090         mutex_enter(&vlun->svl_mutex);
1091 
1092         vhci_print_prout_keys(vlun, "v_pgr_reg_start: before bcopy:");
1093 
1094         bcopy(addr, &vlun->svl_prout, sizeof (vhci_prout_t) -
1095             (2 * MHIOC_RESV_KEY_SIZE*sizeof (char)));
1096         bcopy(pkt->pkt_cdbp, vlun->svl_cdb, sizeof (vlun->svl_cdb));
1097 
1098         vhci_print_prout_keys(vlun, "v_pgr_reg_start: after bcopy:");
1099 
1100         vlun->svl_time = pkt->pkt_time;
1101         vlun->svl_bcount = vpkt->vpkt_tgt_init_bp->b_bcount;
1102         vlun->svl_first_path = vpkt->vpkt_path;
1103         mutex_exit(&vlun->svl_mutex);
1104         return (0);
1105 }
1106 
1107 /*
1108  * Function name : vhci_scsi_start()
1109  *
1110  * Return Values : TRAN_FATAL_ERROR     - vhci has been shutdown
1111  *                                        or other fatal failure
1112  *                                        preventing packet transportation
1113  *                 TRAN_BUSY            - request queue is full
1114  *                 TRAN_ACCEPT          - pkt has been submitted to phci
1115  *                                        (or is held in the waitQ)
1116  * Description   : Implements SCSA's tran_start() entry point for
1117  *                 packet transport
1118  *
1119  */
1120 static int
1121 vhci_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt)
1122 {
1123         int                     rval = TRAN_ACCEPT;
1124         int                     instance, held;
1125         struct scsi_vhci        *vhci = ADDR2VHCI(ap);
1126         struct scsi_vhci_lun    *vlun = ADDR2VLUN(ap);
1127         struct vhci_pkt         *vpkt = TGTPKT2VHCIPKT(pkt);
1128         int                     flags = 0;
1129         scsi_vhci_priv_t        *svp, *svp_resrv;
1130         dev_info_t              *cdip;
1131         client_lb_t             lbp;
1132         int                     restore_lbp = 0;
1133         /* set if pkt is SCSI-II RESERVE cmd */
1134         int                     pkt_reserve_cmd = 0;
1135         int                     reserve_failed = 0;
1136         int                     resrv_instance = 0;
1137         mdi_pathinfo_t          *pip;
1138         struct scsi_pkt         *rel_pkt;
1139 
1140         ASSERT(vhci != NULL);
1141         ASSERT(vpkt != NULL);
1142         ASSERT(vpkt->vpkt_state != VHCI_PKT_ISSUED);
1143         cdip = ADDR2DIP(ap);
1144 
1145         /*
1146          * Block IOs if LUN is held or QUIESCED for IOs.
1147          */
1148         if ((VHCI_LUN_IS_HELD(vlun)) ||
1149             ((vlun->svl_flags & VLUN_QUIESCED_FLG) == VLUN_QUIESCED_FLG)) {
1150                 return (TRAN_BUSY);
1151         }
1152 
1153         /*
1154          * vhci_lun needs to be quiesced before SCSI-II RESERVE command
1155          * can be issued.  This may require a cv_timedwait, which is
1156          * dangerous to perform in an interrupt context.  So if this
1157          * is a RESERVE command a taskq is dispatched to service it.
1158          * This taskq shall again call vhci_scsi_start, but we shall be
1159          * sure its not in an interrupt context.
1160          */
1161         if ((pkt->pkt_cdbp[0] == SCMD_RESERVE) ||
1162             (pkt->pkt_cdbp[0] == SCMD_RESERVE_G1)) {
1163                 if (!(vpkt->vpkt_state & VHCI_PKT_THRU_TASKQ)) {
1164                         if (taskq_dispatch(vhci->vhci_taskq,
1165                             vhci_dispatch_scsi_start, (void *) vpkt,
1166                             KM_NOSLEEP)) {
1167                                 return (TRAN_ACCEPT);
1168                         } else {
1169                                 return (TRAN_BUSY);
1170                         }
1171                 }
1172 
1173                 /*
1174                  * Here we ensure that simultaneous SCSI-II RESERVE cmds don't
1175                  * get serviced for a lun.
1176                  */
1177                 VHCI_HOLD_LUN(vlun, VH_NOSLEEP, held);
1178                 if (!held) {
1179                         return (TRAN_BUSY);
1180                 } else if ((vlun->svl_flags & VLUN_QUIESCED_FLG) ==
1181                     VLUN_QUIESCED_FLG) {
1182                         VHCI_RELEASE_LUN(vlun);
1183                         return (TRAN_BUSY);
1184                 }
1185 
1186                 /*
1187                  * To ensure that no IOs occur for this LUN for the duration
1188                  * of this pkt set the VLUN_QUIESCED_FLG.
1189                  * In case this routine needs to exit on error make sure that
1190                  * this flag is cleared.
1191                  */
1192                 vlun->svl_flags |= VLUN_QUIESCED_FLG;
1193                 pkt_reserve_cmd = 1;
1194 
1195                 /*
1196                  * if this is a SCSI-II RESERVE command, set load balancing
1197                  * policy to be ALTERNATE PATH to ensure that all subsequent
1198                  * IOs are routed on the same path.  This is because if commands
1199                  * are routed across multiple paths then IOs on paths other than
1200                  * the one on which the RESERVE was executed will get a
1201                  * RESERVATION CONFLICT
1202                  */
1203                 lbp = mdi_get_lb_policy(cdip);
1204                 if (lbp != LOAD_BALANCE_NONE) {
1205                         if (vhci_quiesce_lun(vlun) != 1) {
1206                                 vlun->svl_flags &= ~VLUN_QUIESCED_FLG;
1207                                 VHCI_RELEASE_LUN(vlun);
1208                                 return (TRAN_FATAL_ERROR);
1209                         }
1210                         vlun->svl_lb_policy_save = lbp;
1211                         if (mdi_set_lb_policy(cdip, LOAD_BALANCE_NONE) !=
1212                             MDI_SUCCESS) {
1213                                 vlun->svl_flags &= ~VLUN_QUIESCED_FLG;
1214                                 VHCI_RELEASE_LUN(vlun);
1215                                 return (TRAN_FATAL_ERROR);
1216                         }
1217                         restore_lbp = 1;
1218                 }
1219 
1220                 VHCI_DEBUG(2, (CE_NOTE, vhci->vhci_dip,
1221                     "!vhci_scsi_start: sending SCSI-2 RESERVE, vlun 0x%p, "
1222                     "svl_resrv_pip 0x%p, svl_flags: %x, lb_policy %x",
1223                     (void *)vlun, (void *)vlun->svl_resrv_pip, vlun->svl_flags,
1224                     mdi_get_lb_policy(cdip)));
1225 
1226                 /*
1227                  * See comments for VLUN_RESERVE_ACTIVE_FLG in scsi_vhci.h
1228                  * To narrow this window where a reserve command may be sent
1229                  * down an inactive path the path states first need to be
1230                  * updated.  Before calling vhci_update_pathstates reset
1231                  * VLUN_RESERVE_ACTIVE_FLG, just in case it was already set
1232                  * for this lun.  This shall prevent an unnecessary reset
1233                  * from being sent out.  Also remember currently reserved path
1234                  * just for a case the new reservation will go to another path.
1235                  */
1236                 if (vlun->svl_flags & VLUN_RESERVE_ACTIVE_FLG) {
1237                         resrv_instance = mdi_pi_get_path_instance(
1238                             vlun->svl_resrv_pip);
1239                 }
1240                 vlun->svl_flags &= ~VLUN_RESERVE_ACTIVE_FLG;
1241                 vhci_update_pathstates((void *)vlun);
1242         }
1243 
1244         instance = ddi_get_instance(vhci->vhci_dip);
1245 
1246         /*
1247          * If the command is PRIN with action of zero, then the cmd
1248          * is reading PR keys which requires filtering on completion.
1249          * Data cache sync must be guaranteed.
1250          */
1251         if ((pkt->pkt_cdbp[0] == SCMD_PRIN) && (pkt->pkt_cdbp[1] == 0) &&
1252             (vpkt->vpkt_org_vpkt == NULL)) {
1253                 vpkt->vpkt_tgt_init_pkt_flags |= PKT_CONSISTENT;
1254         }
1255 
1256         /*
1257          * Do not defer bind for PKT_DMA_PARTIAL
1258          */
1259         if ((vpkt->vpkt_flags & CFLAG_DMA_PARTIAL) == 0) {
1260 
1261                 /* This is a non pkt_dma_partial case */
1262                 if ((rval = vhci_bind_transport(
1263                     ap, vpkt, vpkt->vpkt_tgt_init_pkt_flags, NULL_FUNC))
1264                     != TRAN_ACCEPT) {
1265                         VHCI_DEBUG(6, (CE_WARN, vhci->vhci_dip,
1266                             "!vhci%d %x: failed to bind transport: "
1267                             "vlun 0x%p pkt_reserved %x restore_lbp %x,"
1268                             "lbp %x", instance, rval, (void *)vlun,
1269                             pkt_reserve_cmd, restore_lbp, lbp));
1270                         if (restore_lbp)
1271                                 (void) mdi_set_lb_policy(cdip, lbp);
1272                         if (pkt_reserve_cmd)
1273                                 vlun->svl_flags &= ~VLUN_QUIESCED_FLG;
1274                         return (rval);
1275                 }
1276                 VHCI_DEBUG(8, (CE_NOTE, NULL,
1277                     "vhci_scsi_start: v_b_t called 0x%p\n", (void *)vpkt));
1278         }
1279         ASSERT(vpkt->vpkt_hba_pkt != NULL);
1280         ASSERT(vpkt->vpkt_path != NULL);
1281 
1282         /*
1283          * This is the chance to adjust the pHCI's pkt and other information
1284          * from target driver's pkt.
1285          */
1286         VHCI_DEBUG(8, (CE_NOTE, vhci->vhci_dip, "vhci_scsi_start vpkt %p\n",
1287             (void *)vpkt));
1288         vhci_update_pHCI_pkt(vpkt, pkt);
1289 
1290         if (vlun->svl_flags & VLUN_RESERVE_ACTIVE_FLG) {
1291                 if (vpkt->vpkt_path != vlun->svl_resrv_pip) {
1292                         VHCI_DEBUG(1, (CE_WARN, vhci->vhci_dip,
1293                             "!vhci_bind: reserve flag set for vlun 0x%p, but, "
1294                             "pktpath 0x%p resrv path 0x%p differ. lb_policy %x",
1295                             (void *)vlun, (void *)vpkt->vpkt_path,
1296                             (void *)vlun->svl_resrv_pip,
1297                             mdi_get_lb_policy(cdip)));
1298                         reserve_failed = 1;
1299                 }
1300         }
1301 
1302         svp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(vpkt->vpkt_path);
1303         if (svp == NULL || reserve_failed) {
1304                 if (pkt_reserve_cmd) {
1305                         VHCI_DEBUG(6, (CE_WARN, vhci->vhci_dip,
1306                             "!vhci_bind returned null svp vlun 0x%p",
1307                             (void *)vlun));
1308                         vlun->svl_flags &= ~VLUN_QUIESCED_FLG;
1309                         if (restore_lbp)
1310                                 (void) mdi_set_lb_policy(cdip, lbp);
1311                 }
1312 pkt_cleanup:
1313                 if ((vpkt->vpkt_flags & CFLAG_DMA_PARTIAL) == 0) {
1314                         scsi_destroy_pkt(vpkt->vpkt_hba_pkt);
1315                         vpkt->vpkt_hba_pkt = NULL;
1316                         if (vpkt->vpkt_path) {
1317                                 mdi_rele_path(vpkt->vpkt_path);
1318                                 vpkt->vpkt_path = NULL;
1319                         }
1320                 }
1321                 if ((pkt->pkt_cdbp[0] == SCMD_PROUT) &&
1322                     (((pkt->pkt_cdbp[1] & 0x1f) == VHCI_PROUT_REGISTER) ||
1323                     ((pkt->pkt_cdbp[1] & 0x1f) == VHCI_PROUT_R_AND_IGNORE))) {
1324                         sema_v(&vlun->svl_pgr_sema);
1325                 }
1326                 return (TRAN_BUSY);
1327         }
1328 
1329         if ((resrv_instance != 0) && (resrv_instance !=
1330             mdi_pi_get_path_instance(vpkt->vpkt_path))) {
1331                 /*
1332                  * This is an attempt to reserve vpkt->vpkt_path.  But the
1333                  * previously reserved path referred by resrv_instance might
1334                  * still be reserved.  Hence we will send a release command
1335                  * there in order to avoid a reservation conflict.
1336                  */
1337                 VHCI_DEBUG(1, (CE_NOTE, vhci->vhci_dip, "!vhci_scsi_start: "
1338                     "conflicting reservation on another path, vlun 0x%p, "
1339                     "reserved instance %d, new instance: %d, pip: 0x%p",
1340                     (void *)vlun, resrv_instance,
1341                     mdi_pi_get_path_instance(vpkt->vpkt_path),
1342                     (void *)vpkt->vpkt_path));
1343 
1344                 /*
1345                  * In rare cases, the path referred by resrv_instance could
1346                  * disappear in the meantime. Calling mdi_select_path() below
1347                  * is an attempt to find out if the path still exists. It also
1348                  * ensures that the path will be held when the release is sent.
1349                  */
1350                 rval = mdi_select_path(cdip, NULL, MDI_SELECT_PATH_INSTANCE,
1351                     (void *)(intptr_t)resrv_instance, &pip);
1352 
1353                 if ((rval == MDI_SUCCESS) && (pip != NULL)) {
1354                         svp_resrv = (scsi_vhci_priv_t *)
1355                             mdi_pi_get_vhci_private(pip);
1356                         rel_pkt = scsi_init_pkt(&svp_resrv->svp_psd->sd_address,
1357                             NULL, NULL, CDB_GROUP0,
1358                             sizeof (struct scsi_arq_status), 0, 0, SLEEP_FUNC,
1359                             NULL);
1360 
1361                         if (rel_pkt == NULL) {
1362                                 char    *p_path;
1363 
1364                                 /*
1365                                  * This is very unlikely.
1366                                  * scsi_init_pkt(SLEEP_FUNC) does not fail
1367                                  * because of resources. But in theory it could
1368                                  * fail for some other reason. There is not an
1369                                  * easy way how to recover though. Log a warning
1370                                  * and return.
1371                                  */
1372                                 p_path = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
1373                                 vhci_log(CE_WARN, vhci->vhci_dip, "!Sending "
1374                                     "RELEASE(6) to %s failed, a potential "
1375                                     "reservation conflict ahead.",
1376                                     ddi_pathname(mdi_pi_get_phci(pip), p_path));
1377                                 kmem_free(p_path, MAXPATHLEN);
1378 
1379                                 if (restore_lbp)
1380                                         (void) mdi_set_lb_policy(cdip, lbp);
1381 
1382                                 /* no need to check pkt_reserve_cmd here */
1383                                 vlun->svl_flags &= ~VLUN_QUIESCED_FLG;
1384                                 return (TRAN_FATAL_ERROR);
1385                         }
1386 
1387                         rel_pkt->pkt_cdbp[0] = SCMD_RELEASE;
1388                         rel_pkt->pkt_time = 60;
1389 
1390                         /*
1391                          * Ignore the return value.  If it will fail
1392                          * then most likely it is no longer reserved
1393                          * anyway.
1394                          */
1395                         (void) vhci_do_scsi_cmd(rel_pkt);
1396                         VHCI_DEBUG(1, (CE_NOTE, NULL,
1397                             "!vhci_scsi_start: path 0x%p, issued SCSI-2"
1398                             " RELEASE\n", (void *)pip));
1399                         scsi_destroy_pkt(rel_pkt);
1400                         mdi_rele_path(pip);
1401                 }
1402         }
1403 
1404         VHCI_INCR_PATH_CMDCOUNT(svp);
1405 
1406         /*
1407          * Ensure that no other IOs raced ahead, while a RESERVE cmd was
1408          * QUIESCING the same lun.
1409          */
1410         if ((!pkt_reserve_cmd) &&
1411             ((vlun->svl_flags & VLUN_QUIESCED_FLG) == VLUN_QUIESCED_FLG)) {
1412                 VHCI_DECR_PATH_CMDCOUNT(svp);
1413                 goto pkt_cleanup;
1414         }
1415 
1416         if ((pkt->pkt_cdbp[0] == SCMD_PRIN) ||
1417             (pkt->pkt_cdbp[0] == SCMD_PROUT)) {
1418                 /*
1419                  * currently this thread only handles running PGR
1420                  * commands, so don't bother creating it unless
1421                  * something interesting is going to happen (like
1422                  * either a PGR out, or a PGR in with enough space
1423                  * to hold the keys that are getting returned)
1424                  */
1425                 mutex_enter(&vlun->svl_mutex);
1426                 if (((vlun->svl_flags & VLUN_TASK_D_ALIVE_FLG) == 0) &&
1427                     (pkt->pkt_cdbp[0] == SCMD_PROUT)) {
1428                         vlun->svl_taskq = taskq_create("vlun_pgr_task_daemon",
1429                             1, MINCLSYSPRI, 1, 4, 0);
1430                         vlun->svl_flags |= VLUN_TASK_D_ALIVE_FLG;
1431                 }
1432                 mutex_exit(&vlun->svl_mutex);
1433                 if ((pkt->pkt_cdbp[0] == SCMD_PROUT) &&
1434                     (((pkt->pkt_cdbp[1] & 0x1f) == VHCI_PROUT_REGISTER) ||
1435                     ((pkt->pkt_cdbp[1] & 0x1f) == VHCI_PROUT_R_AND_IGNORE))) {
1436                         if (rval = vhci_pgr_register_start(vlun, pkt)) {
1437                                 /* an error */
1438                                 sema_v(&vlun->svl_pgr_sema);
1439                                 return (rval);
1440                         }
1441                 }
1442         }
1443 
1444         /*
1445          * SCSI-II RESERVE cmd is not expected in polled mode.
1446          * If this changes it needs to be handled for the polled scenario.
1447          */
1448         flags = vpkt->vpkt_hba_pkt->pkt_flags;
1449 
1450         /*
1451          * Set the path_instance *before* sending the scsi_pkt down the path
1452          * to mpxio's pHCI so that additional path abstractions at a pHCI
1453          * level (like maybe iSCSI at some point in the future) can update
1454          * the path_instance.
1455          */
1456         if (scsi_pkt_allocated_correctly(vpkt->vpkt_hba_pkt))
1457                 vpkt->vpkt_hba_pkt->pkt_path_instance =
1458                     mdi_pi_get_path_instance(vpkt->vpkt_path);
1459 
1460         rval = scsi_transport(vpkt->vpkt_hba_pkt);
1461         if (rval == TRAN_ACCEPT) {
1462                 if (flags & FLAG_NOINTR) {
1463                         struct scsi_pkt *tpkt = vpkt->vpkt_tgt_pkt;
1464                         struct scsi_pkt *pkt = vpkt->vpkt_hba_pkt;
1465 
1466                         ASSERT(tpkt != NULL);
1467                         *(tpkt->pkt_scbp) = *(pkt->pkt_scbp);
1468                         tpkt->pkt_resid = pkt->pkt_resid;
1469                         tpkt->pkt_state = pkt->pkt_state;
1470                         tpkt->pkt_statistics = pkt->pkt_statistics;
1471                         tpkt->pkt_reason = pkt->pkt_reason;
1472 
1473                         if ((*(pkt->pkt_scbp) == STATUS_CHECK) &&
1474                             (pkt->pkt_state & STATE_ARQ_DONE)) {
1475                                 bcopy(pkt->pkt_scbp, tpkt->pkt_scbp,
1476                                     vpkt->vpkt_tgt_init_scblen);
1477                         }
1478 
1479                         VHCI_DECR_PATH_CMDCOUNT(svp);
1480                         if ((vpkt->vpkt_flags & CFLAG_DMA_PARTIAL) == 0) {
1481                                 scsi_destroy_pkt(vpkt->vpkt_hba_pkt);
1482                                 vpkt->vpkt_hba_pkt = NULL;
1483                                 if (vpkt->vpkt_path) {
1484                                         mdi_rele_path(vpkt->vpkt_path);
1485                                         vpkt->vpkt_path = NULL;
1486                                 }
1487                         }
1488                         /*
1489                          * This path will not automatically retry pkts
1490                          * internally, therefore, vpkt_org_vpkt should
1491                          * never be set.
1492                          */
1493                         ASSERT(vpkt->vpkt_org_vpkt == NULL);
1494                         scsi_hba_pkt_comp(tpkt);
1495                 }
1496                 return (rval);
1497         } else if ((pkt->pkt_cdbp[0] == SCMD_PROUT) &&
1498             (((pkt->pkt_cdbp[1] & 0x1f) == VHCI_PROUT_REGISTER) ||
1499             ((pkt->pkt_cdbp[1] & 0x1f) == VHCI_PROUT_R_AND_IGNORE))) {
1500                 /* the command exited with bad status */
1501                 sema_v(&vlun->svl_pgr_sema);
1502         } else if (vpkt->vpkt_tgt_pkt->pkt_cdbp[0] == SCMD_PRIN) {
1503                 /* the command exited with bad status */
1504                 sema_v(&vlun->svl_pgr_sema);
1505         } else if (pkt_reserve_cmd) {
1506                 VHCI_DEBUG(6, (CE_WARN, vhci->vhci_dip,
1507                     "!vhci_scsi_start: reserve failed vlun 0x%p",
1508                     (void *)vlun));
1509                 vlun->svl_flags &= ~VLUN_QUIESCED_FLG;
1510                 if (restore_lbp)
1511                         (void) mdi_set_lb_policy(cdip, lbp);
1512         }
1513 
1514         ASSERT(vpkt->vpkt_hba_pkt != NULL);
1515         VHCI_DECR_PATH_CMDCOUNT(svp);
1516 
1517         /* Do not destroy phci packet information for PKT_DMA_PARTIAL */
1518         if ((vpkt->vpkt_flags & CFLAG_DMA_PARTIAL) == 0) {
1519                 scsi_destroy_pkt(vpkt->vpkt_hba_pkt);
1520                 vpkt->vpkt_hba_pkt = NULL;
1521                 if (vpkt->vpkt_path) {
1522                         MDI_PI_ERRSTAT(vpkt->vpkt_path, MDI_PI_TRANSERR);
1523                         mdi_rele_path(vpkt->vpkt_path);
1524                         vpkt->vpkt_path = NULL;
1525                 }
1526         }
1527         return (TRAN_BUSY);
1528 }
1529 
1530 /*
1531  * Function name : vhci_scsi_reset()
1532  *
1533  * Return Values : 0 - reset failed
1534  *                 1 - reset succeeded
1535  */
1536 
1537 /* ARGSUSED */
1538 static int
1539 vhci_scsi_reset(struct scsi_address *ap, int level)
1540 {
1541         int rval = 0;
1542 
1543         cmn_err(CE_WARN, "!vhci_scsi_reset 0x%x", level);
1544         if ((level == RESET_TARGET) || (level == RESET_LUN)) {
1545                 return (vhci_scsi_reset_target(ap, level, TRUE));
1546         } else if (level == RESET_ALL) {
1547                 return (vhci_scsi_reset_bus(ap));
1548         }
1549 
1550         return (rval);
1551 }
1552 
1553 /*
1554  * vhci_recovery_reset:
1555  *      Issues reset to the device
1556  * Input:
1557  *      vlun - vhci lun pointer of the device
1558  *      ap - address of the device
1559  *      select_path:
1560  *              If select_path is FALSE, then the address specified in ap is
1561  *              the path on which reset will be issued.
1562  *              If select_path is TRUE, then path is obtained by calling
1563  *              mdi_select_path.
1564  *
1565  *      recovery_depth:
1566  *              Caller can specify the level of reset.
1567  *              VHCI_DEPTH_LUN -
1568  *                      Issues LUN RESET if device supports lun reset.
1569  *              VHCI_DEPTH_TARGET -
1570  *                      If Lun Reset fails or the device does not support
1571  *                      Lun Reset, issues TARGET RESET
1572  *              VHCI_DEPTH_ALL -
1573  *                      If Lun Reset fails or the device does not support
1574  *                      Lun Reset, issues TARGET RESET.
1575  *                      If TARGET RESET does not succeed, issues Bus Reset.
1576  */
1577 
1578 static int
1579 vhci_recovery_reset(scsi_vhci_lun_t *vlun, struct scsi_address *ap,
1580         uint8_t select_path, uint8_t recovery_depth)
1581 {
1582         int     ret = 0;
1583 
1584         ASSERT(ap != NULL);
1585 
1586         if (vlun && vlun->svl_support_lun_reset == 1) {
1587                 ret = vhci_scsi_reset_target(ap, RESET_LUN,
1588                     select_path);
1589         }
1590 
1591         recovery_depth--;
1592 
1593         if ((ret == 0) && recovery_depth) {
1594                 ret = vhci_scsi_reset_target(ap, RESET_TARGET,
1595                     select_path);
1596                 recovery_depth--;
1597         }
1598 
1599         if ((ret == 0) && recovery_depth) {
1600                 (void) scsi_reset(ap, RESET_ALL);
1601         }
1602 
1603         return (ret);
1604 }
1605 
1606 /*
1607  * Note: The scsi_address passed to this routine could be the scsi_address
1608  * for the virtual device or the physical device. No assumptions should be
1609  * made in this routine about the contents of the ap structure.
1610  * Further, note that the child dip would be the dip of the ssd node regardless
1611  * of the scsi_address passed in.
1612  */
1613 static int
1614 vhci_scsi_reset_target(struct scsi_address *ap, int level, uint8_t select_path)
1615 {
1616         dev_info_t              *vdip, *cdip;
1617         mdi_pathinfo_t          *pip = NULL;
1618         mdi_pathinfo_t          *npip = NULL;
1619         int                     rval = -1;
1620         scsi_vhci_priv_t        *svp = NULL;
1621         struct scsi_address     *pap = NULL;
1622         scsi_hba_tran_t         *hba = NULL;
1623         int                     sps;
1624         struct scsi_vhci        *vhci = NULL;
1625 
1626         if (select_path != TRUE) {
1627                 ASSERT(ap != NULL);
1628                 if (level == RESET_LUN) {
1629                         hba = ap->a_hba_tran;
1630                         ASSERT(hba != NULL);
1631                         return (hba->tran_reset(ap, RESET_LUN));
1632                 }
1633                 return (scsi_reset(ap, level));
1634         }
1635 
1636         cdip = ADDR2DIP(ap);
1637         ASSERT(cdip != NULL);
1638         vdip = ddi_get_parent(cdip);
1639         ASSERT(vdip != NULL);
1640         vhci = ddi_get_soft_state(vhci_softstate, ddi_get_instance(vdip));
1641         ASSERT(vhci != NULL);
1642 
1643         rval = mdi_select_path(cdip, NULL, MDI_SELECT_ONLINE_PATH, NULL, &pip);
1644         if ((rval != MDI_SUCCESS) || (pip == NULL)) {
1645                 VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_scsi_reset_target: "
1646                     "Unable to get a path, dip 0x%p", (void *)cdip));
1647                 return (0);
1648         }
1649 again:
1650         svp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(pip);
1651         if (svp == NULL) {
1652                 VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_scsi_reset_target: "
1653                     "priv is NULL, pip 0x%p", (void *)pip));
1654                 mdi_rele_path(pip);
1655                 return (0);
1656         }
1657 
1658         if (svp->svp_psd == NULL) {
1659                 VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_scsi_reset_target: "
1660                     "psd is NULL, pip 0x%p, svp 0x%p",
1661                     (void *)pip, (void *)svp));
1662                 mdi_rele_path(pip);
1663                 return (0);
1664         }
1665 
1666         pap = &svp->svp_psd->sd_address;
1667         hba = pap->a_hba_tran;
1668 
1669         ASSERT(pap != NULL);
1670         ASSERT(hba != NULL);
1671 
1672         if (hba->tran_reset != NULL) {
1673                 if (hba->tran_reset(pap, level) == 0) {
1674                         vhci_log(CE_WARN, vdip, "!%s%d: "
1675                             "path %s, reset %d failed",
1676                             ddi_driver_name(cdip), ddi_get_instance(cdip),
1677                             mdi_pi_spathname(pip), level);
1678 
1679                         /*
1680                          * Select next path and issue the reset, repeat
1681                          * until all paths are exhausted
1682                          */
1683                         sps = mdi_select_path(cdip, NULL,
1684                             MDI_SELECT_ONLINE_PATH, pip, &npip);
1685                         if ((sps != MDI_SUCCESS) || (npip == NULL)) {
1686                                 mdi_rele_path(pip);
1687                                 return (0);
1688                         }
1689                         mdi_rele_path(pip);
1690                         pip = npip;
1691                         goto again;
1692                 }
1693                 mdi_rele_path(pip);
1694                 mutex_enter(&vhci->vhci_mutex);
1695                 scsi_hba_reset_notify_callback(&vhci->vhci_mutex,
1696                     &vhci->vhci_reset_notify_listf);
1697                 mutex_exit(&vhci->vhci_mutex);
1698                 VHCI_DEBUG(6, (CE_NOTE, NULL, "!vhci_scsi_reset_target: "
1699                     "reset %d sent down pip:%p for cdip:%p\n", level,
1700                     (void *)pip, (void *)cdip));
1701                 return (1);
1702         }
1703         mdi_rele_path(pip);
1704         return (0);
1705 }
1706 
1707 
1708 /* ARGSUSED */
1709 static int
1710 vhci_scsi_reset_bus(struct scsi_address *ap)
1711 {
1712         return (1);
1713 }
1714 
1715 
1716 /*
1717  * called by vhci_getcap and vhci_setcap to get and set (respectively)
1718  * SCSI capabilities
1719  */
1720 /* ARGSUSED */
1721 static int
1722 vhci_commoncap(struct scsi_address *ap, char *cap,
1723     int val, int tgtonly, int doset)
1724 {
1725         struct scsi_vhci                *vhci = ADDR2VHCI(ap);
1726         struct scsi_vhci_lun            *vlun = ADDR2VLUN(ap);
1727         int                     cidx;
1728         int                     rval = 0;
1729 
1730         if (cap == (char *)0) {
1731                 VHCI_DEBUG(3, (CE_WARN, vhci->vhci_dip,
1732                     "!vhci_commoncap: invalid arg"));
1733                 return (rval);
1734         }
1735 
1736         if (vlun == NULL) {
1737                 VHCI_DEBUG(3, (CE_WARN, vhci->vhci_dip,
1738                     "!vhci_commoncap: vlun is null"));
1739                 return (rval);
1740         }
1741 
1742         if ((cidx = scsi_hba_lookup_capstr(cap)) == -1) {
1743                 return (UNDEFINED);
1744         }
1745 
1746         /*
1747          * Process setcap request.
1748          */
1749         if (doset) {
1750                 /*
1751                  * At present, we can only set binary (0/1) values
1752                  */
1753                 switch (cidx) {
1754                 case SCSI_CAP_ARQ:
1755                         if (val == 0) {
1756                                 rval = 0;
1757                         } else {
1758                                 rval = 1;
1759                         }
1760                         break;
1761 
1762                 case SCSI_CAP_LUN_RESET:
1763                         if (tgtonly == 0) {
1764                                 VHCI_DEBUG(1, (CE_WARN, vhci->vhci_dip,
1765                                     "scsi_vhci_setcap: "
1766                                     "Returning error since whom = 0"));
1767                                 rval = -1;
1768                                 break;
1769                         }
1770                         /*
1771                          * Set the capability accordingly.
1772                          */
1773                         mutex_enter(&vlun->svl_mutex);
1774                         vlun->svl_support_lun_reset = val;
1775                         rval = val;
1776                         mutex_exit(&vlun->svl_mutex);
1777                         break;
1778 
1779                 case SCSI_CAP_SECTOR_SIZE:
1780                         mutex_enter(&vlun->svl_mutex);
1781                         vlun->svl_sector_size = val;
1782                         vlun->svl_setcap_done = 1;
1783                         mutex_exit(&vlun->svl_mutex);
1784                         (void) vhci_pHCI_cap(ap, cap, val, tgtonly, NULL);
1785 
1786                         /* Always return success */
1787                         rval = 1;
1788                         break;
1789 
1790                 default:
1791                         VHCI_DEBUG(6, (CE_WARN, vhci->vhci_dip,
1792                             "!vhci_setcap: unsupported %d", cidx));
1793                         rval = UNDEFINED;
1794                         break;
1795                 }
1796 
1797                 VHCI_DEBUG(6, (CE_NOTE, vhci->vhci_dip,
1798                     "!set cap: cap=%s, val/tgtonly/doset/rval = "
1799                     "0x%x/0x%x/0x%x/%d\n",
1800                     cap, val, tgtonly, doset, rval));
1801 
1802         } else {
1803                 /*
1804                  * Process getcap request.
1805                  */
1806                 switch (cidx) {
1807                 case SCSI_CAP_DMA_MAX:
1808                         /*
1809                          * For X86 this capability is caught in scsi_ifgetcap().
1810                          * XXX Should this be getting the value from the pHCI?
1811                          */
1812                         rval = (int)VHCI_DMA_MAX_XFER_CAP;
1813                         break;
1814 
1815                 case SCSI_CAP_INITIATOR_ID:
1816                         rval = 0x00;
1817                         break;
1818 
1819                 case SCSI_CAP_ARQ:
1820                 case SCSI_CAP_RESET_NOTIFICATION:
1821                 case SCSI_CAP_TAGGED_QING:
1822                         rval = 1;
1823                         break;
1824 
1825                 case SCSI_CAP_SCSI_VERSION:
1826                         rval = 3;
1827                         break;
1828 
1829                 case SCSI_CAP_INTERCONNECT_TYPE:
1830                         rval = INTERCONNECT_FABRIC;
1831                         break;
1832 
1833                 case SCSI_CAP_LUN_RESET:
1834                         /*
1835                          * scsi_vhci will always return success for LUN reset.
1836                          * When request for doing LUN reset comes
1837                          * through scsi_reset entry point, at that time attempt
1838                          * will be made to do reset through all the possible
1839                          * paths.
1840                          */
1841                         mutex_enter(&vlun->svl_mutex);
1842                         rval = vlun->svl_support_lun_reset;
1843                         mutex_exit(&vlun->svl_mutex);
1844                         VHCI_DEBUG(4, (CE_WARN, vhci->vhci_dip,
1845                             "scsi_vhci_getcap:"
1846                             "Getting the Lun reset capability %d", rval));
1847                         break;
1848 
1849                 case SCSI_CAP_SECTOR_SIZE:
1850                         mutex_enter(&vlun->svl_mutex);
1851                         rval = vlun->svl_sector_size;
1852                         mutex_exit(&vlun->svl_mutex);
1853                         break;
1854 
1855                 case SCSI_CAP_CDB_LEN:
1856                         rval = VHCI_SCSI_CDB_SIZE;
1857                         break;
1858 
1859                 case SCSI_CAP_DMA_MAX_ARCH:
1860                         /*
1861                          * For X86 this capability is caught in scsi_ifgetcap().
1862                          * XXX Should this be getting the value from the pHCI?
1863                          */
1864                         rval = 0;
1865                         break;
1866 
1867                 default:
1868                         VHCI_DEBUG(6, (CE_WARN, vhci->vhci_dip,
1869                             "!vhci_getcap: unsupported %d", cidx));
1870                         rval = UNDEFINED;
1871                         break;
1872                 }
1873 
1874                 VHCI_DEBUG(6, (CE_NOTE, vhci->vhci_dip,
1875                     "!get cap: cap=%s, val/tgtonly/doset/rval = "
1876                     "0x%x/0x%x/0x%x/%d\n",
1877                     cap, val, tgtonly, doset, rval));
1878         }
1879         return (rval);
1880 }
1881 
1882 
1883 /*
1884  * Function name : vhci_scsi_getcap()
1885  *
1886  */
1887 static int
1888 vhci_scsi_getcap(struct scsi_address *ap, char *cap, int whom)
1889 {
1890         return (vhci_commoncap(ap, cap, 0, whom, 0));
1891 }
1892 
1893 static int
1894 vhci_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom)
1895 {
1896         return (vhci_commoncap(ap, cap, value, whom, 1));
1897 }
1898 
1899 /*
1900  * Function name : vhci_scsi_abort()
1901  */
1902 /* ARGSUSED */
1903 static int
1904 vhci_scsi_abort(struct scsi_address *ap, struct scsi_pkt *pkt)
1905 {
1906         return (0);
1907 }
1908 
1909 /*
1910  * Function name : vhci_scsi_init_pkt
1911  *
1912  * Return Values : pointer to scsi_pkt, or NULL
1913  */
1914 /* ARGSUSED */
1915 static struct scsi_pkt *
1916 vhci_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
1917         struct buf *bp, int cmdlen, int statuslen, int tgtlen,
1918         int flags, int (*callback)(caddr_t), caddr_t arg)
1919 {
1920         struct scsi_vhci        *vhci = ADDR2VHCI(ap);
1921         struct vhci_pkt         *vpkt;
1922         int                     rval;
1923         int                     newpkt = 0;
1924         struct scsi_pkt         *pktp;
1925 
1926 
1927         if (pkt == NULL) {
1928                 if (cmdlen > VHCI_SCSI_CDB_SIZE) {
1929                         if ((cmdlen != VHCI_SCSI_OSD_CDB_SIZE) ||
1930                             ((flags & VHCI_SCSI_OSD_PKT_FLAGS) !=
1931                             VHCI_SCSI_OSD_PKT_FLAGS)) {
1932                                 VHCI_DEBUG(1, (CE_NOTE, NULL,
1933                                     "!init pkt: cdb size not supported\n"));
1934                                 return (NULL);
1935                         }
1936                 }
1937 
1938                 pktp = scsi_hba_pkt_alloc(vhci->vhci_dip,
1939                     ap, cmdlen, statuslen, tgtlen, sizeof (*vpkt), callback,
1940                     arg);
1941 
1942                 if (pktp == NULL) {
1943                         return (NULL);
1944                 }
1945 
1946                 /* Get the vhci's private structure */
1947                 vpkt = (struct vhci_pkt *)(pktp->pkt_ha_private);
1948                 ASSERT(vpkt);
1949 
1950                 /* Save the target driver's packet */
1951                 vpkt->vpkt_tgt_pkt = pktp;
1952 
1953                 /*
1954                  * Save pkt_tgt_init_pkt fields if deferred binding
1955                  * is needed or for other purposes.
1956                  */
1957                 vpkt->vpkt_tgt_init_pkt_flags = flags;
1958                 vpkt->vpkt_flags = (callback == NULL_FUNC) ? CFLAG_NOWAIT : 0;
1959                 vpkt->vpkt_state = VHCI_PKT_IDLE;
1960                 vpkt->vpkt_tgt_init_cdblen = cmdlen;
1961                 vpkt->vpkt_tgt_init_scblen = statuslen;
1962                 newpkt = 1;
1963         } else { /* pkt not NULL */
1964                 vpkt = pkt->pkt_ha_private;
1965         }
1966 
1967         VHCI_DEBUG(8, (CE_NOTE, NULL, "vhci_scsi_init_pkt "
1968             "vpkt %p flags %x\n", (void *)vpkt, flags));
1969 
1970         /* Clear any stale error flags */
1971         if (bp) {
1972                 bioerror(bp, 0);
1973         }
1974 
1975         vpkt->vpkt_tgt_init_bp = bp;
1976 
1977         if (flags & PKT_DMA_PARTIAL) {
1978 
1979                 /*
1980                  * Immediate binding is needed.
1981                  * Target driver may not set this flag in next invocation.
1982                  * vhci has to remember this flag was set during first
1983                  * invocation of vhci_scsi_init_pkt.
1984                  */
1985                 vpkt->vpkt_flags |= CFLAG_DMA_PARTIAL;
1986         }
1987 
1988         if (vpkt->vpkt_flags & CFLAG_DMA_PARTIAL) {
1989 
1990                 /*
1991                  * Re-initialize some of the target driver packet state
1992                  * information.
1993                  */
1994                 vpkt->vpkt_tgt_pkt->pkt_state = 0;
1995                 vpkt->vpkt_tgt_pkt->pkt_statistics = 0;
1996                 vpkt->vpkt_tgt_pkt->pkt_reason = 0;
1997 
1998                 /*
1999                  * Binding a vpkt->vpkt_path for this IO at init_time.
2000                  * If an IO error happens later, target driver will clear
2001                  * this vpkt->vpkt_path binding before re-init IO again.
2002                  */
2003                 VHCI_DEBUG(8, (CE_NOTE, NULL,
2004                     "vhci_scsi_init_pkt: calling v_b_t %p, newpkt %d\n",
2005                     (void *)vpkt, newpkt));
2006                 if (pkt && vpkt->vpkt_hba_pkt) {
2007                         VHCI_DEBUG(4, (CE_NOTE, NULL,
2008                             "v_s_i_p calling update_pHCI_pkt resid %ld\n",
2009                             pkt->pkt_resid));
2010                         vhci_update_pHCI_pkt(vpkt, pkt);
2011                 }
2012                 if (callback == SLEEP_FUNC) {
2013                         rval = vhci_bind_transport(
2014                             ap, vpkt, flags, callback);
2015                 } else {
2016                         rval = vhci_bind_transport(
2017                             ap, vpkt, flags, NULL_FUNC);
2018                 }
2019                 VHCI_DEBUG(8, (CE_NOTE, NULL,
2020                     "vhci_scsi_init_pkt: v_b_t called 0x%p rval 0x%x\n",
2021                     (void *)vpkt, rval));
2022                 if (bp) {
2023                         if (rval == TRAN_FATAL_ERROR) {
2024                                 /*
2025                                  * No paths available. Could not bind
2026                                  * any pHCI. Setting EFAULT as a way
2027                                  * to indicate no DMA is mapped.
2028                                  */
2029                                 bioerror(bp, EFAULT);
2030                         } else {
2031                                 /*
2032                                  * Do not indicate any pHCI errors to
2033                                  * target driver otherwise.
2034                                  */
2035                                 bioerror(bp, 0);
2036                         }
2037                 }
2038                 if (rval != TRAN_ACCEPT) {
2039                         VHCI_DEBUG(8, (CE_NOTE, NULL,
2040                             "vhci_scsi_init_pkt: "
2041                             "v_b_t failed 0x%p newpkt %x\n",
2042                             (void *)vpkt, newpkt));
2043                         if (newpkt) {
2044                                 scsi_hba_pkt_free(ap,
2045                                     vpkt->vpkt_tgt_pkt);
2046                         }
2047                         return (NULL);
2048                 }
2049                 ASSERT(vpkt->vpkt_hba_pkt != NULL);
2050                 ASSERT(vpkt->vpkt_path != NULL);
2051 
2052                 /* Update the resid for the target driver */
2053                 vpkt->vpkt_tgt_pkt->pkt_resid =
2054                     vpkt->vpkt_hba_pkt->pkt_resid;
2055         }
2056 
2057         return (vpkt->vpkt_tgt_pkt);
2058 }
2059 
2060 /*
2061  * Function name : vhci_scsi_destroy_pkt
2062  *
2063  * Return Values : none
2064  */
2065 static void
2066 vhci_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
2067 {
2068         struct vhci_pkt         *vpkt = (struct vhci_pkt *)pkt->pkt_ha_private;
2069 
2070         VHCI_DEBUG(8, (CE_NOTE, NULL,
2071             "vhci_scsi_destroy_pkt: vpkt 0x%p\n", (void *)vpkt));
2072 
2073         vpkt->vpkt_tgt_init_pkt_flags = 0;
2074         if (vpkt->vpkt_hba_pkt) {
2075                 scsi_destroy_pkt(vpkt->vpkt_hba_pkt);
2076                 vpkt->vpkt_hba_pkt = NULL;
2077         }
2078         if (vpkt->vpkt_path) {
2079                 mdi_rele_path(vpkt->vpkt_path);
2080                 vpkt->vpkt_path = NULL;
2081         }
2082 
2083         ASSERT(vpkt->vpkt_state != VHCI_PKT_ISSUED);
2084         scsi_hba_pkt_free(ap, vpkt->vpkt_tgt_pkt);
2085 }
2086 
2087 /*
2088  * Function name : vhci_scsi_dmafree()
2089  *
2090  * Return Values : none
2091  */
2092 /*ARGSUSED*/
2093 static void
2094 vhci_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
2095 {
2096         struct vhci_pkt *vpkt = (struct vhci_pkt *)pkt->pkt_ha_private;
2097 
2098         VHCI_DEBUG(6, (CE_NOTE, NULL,
2099             "vhci_scsi_dmafree: vpkt 0x%p\n", (void *)vpkt));
2100 
2101         ASSERT(vpkt != NULL);
2102         if (vpkt->vpkt_hba_pkt) {
2103                 scsi_destroy_pkt(vpkt->vpkt_hba_pkt);
2104                 vpkt->vpkt_hba_pkt = NULL;
2105         }
2106         if (vpkt->vpkt_path) {
2107                 mdi_rele_path(vpkt->vpkt_path);
2108                 vpkt->vpkt_path = NULL;
2109         }
2110 }
2111 
2112 /*
2113  * Function name : vhci_scsi_sync_pkt()
2114  *
2115  * Return Values : none
2116  */
2117 /*ARGSUSED*/
2118 static void
2119 vhci_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
2120 {
2121         struct vhci_pkt *vpkt = (struct vhci_pkt *)pkt->pkt_ha_private;
2122 
2123         ASSERT(vpkt != NULL);
2124         if (vpkt->vpkt_hba_pkt) {
2125                 scsi_sync_pkt(vpkt->vpkt_hba_pkt);
2126         }
2127 }
2128 
2129 /*
2130  * routine for reset notification setup, to register or cancel.
2131  */
2132 static int
2133 vhci_scsi_reset_notify(struct scsi_address *ap, int flag,
2134     void (*callback)(caddr_t), caddr_t arg)
2135 {
2136         struct scsi_vhci *vhci = ADDR2VHCI(ap);
2137         return (scsi_hba_reset_notify_setup(ap, flag, callback, arg,
2138             &vhci->vhci_mutex, &vhci->vhci_reset_notify_listf));
2139 }
2140 
2141 static int
2142 vhci_scsi_get_name_bus_addr(struct scsi_device *sd,
2143     char *name, int len, int bus_addr)
2144 {
2145         dev_info_t              *cdip;
2146         char                    *guid;
2147         scsi_vhci_lun_t         *vlun;
2148 
2149         ASSERT(sd != NULL);
2150         ASSERT(name != NULL);
2151 
2152         *name = 0;
2153         cdip = sd->sd_dev;
2154 
2155         ASSERT(cdip != NULL);
2156 
2157         if (mdi_component_is_client(cdip, NULL) != MDI_SUCCESS)
2158                 return (1);
2159 
2160         if (ddi_prop_lookup_string(DDI_DEV_T_ANY, cdip, PROPFLAGS,
2161             MDI_CLIENT_GUID_PROP, &guid) != DDI_SUCCESS)
2162                 return (1);
2163 
2164         /*
2165          * Message is "sd# at scsi_vhci0: unit-address <guid>: <bus_addr>".
2166          *      <guid>            bus_addr argument == 0
2167          *      <bus_addr>        bus_addr argument != 0
2168          * Since the <guid> is already provided with unit-address, we just
2169          * provide failover module in <bus_addr> to keep output shorter.
2170          */
2171         vlun = ADDR2VLUN(&sd->sd_address);
2172         if (bus_addr == 0) {
2173                 /* report the guid:  */
2174                 (void) snprintf(name, len, "g%s", guid);
2175         } else if (vlun && vlun->svl_fops_name) {
2176                 /* report the name of the failover module */
2177                 (void) snprintf(name, len, "%s", vlun->svl_fops_name);
2178         }
2179 
2180         ddi_prop_free(guid);
2181         return (1);
2182 }
2183 
2184 static int
2185 vhci_scsi_get_bus_addr(struct scsi_device *sd, char *name, int len)
2186 {
2187         return (vhci_scsi_get_name_bus_addr(sd, name, len, 1));
2188 }
2189 
2190 static int
2191 vhci_scsi_get_name(struct scsi_device *sd, char *name, int len)
2192 {
2193         return (vhci_scsi_get_name_bus_addr(sd, name, len, 0));
2194 }
2195 
2196 /*
2197  * Return a pointer to the guid part of the devnm.
2198  * devnm format is "nodename@busaddr", busaddr format is "gGUID".
2199  */
2200 static char *
2201 vhci_devnm_to_guid(char *devnm)
2202 {
2203         char *cp = devnm;
2204 
2205         if (devnm == NULL)
2206                 return (NULL);
2207 
2208         while (*cp != '\0' && *cp != '@')
2209                 cp++;
2210         if (*cp == '@' && *(cp + 1) == 'g')
2211                 return (cp + 2);
2212         return (NULL);
2213 }
2214 
2215 static int
2216 vhci_bind_transport(struct scsi_address *ap, struct vhci_pkt *vpkt, int flags,
2217     int (*func)(caddr_t))
2218 {
2219         struct scsi_vhci        *vhci = ADDR2VHCI(ap);
2220         dev_info_t              *cdip = ADDR2DIP(ap);
2221         mdi_pathinfo_t          *pip = NULL;
2222         mdi_pathinfo_t          *npip = NULL;
2223         scsi_vhci_priv_t        *svp = NULL;
2224         struct scsi_device      *psd = NULL;
2225         struct scsi_address     *address = NULL;
2226         struct scsi_pkt         *pkt = NULL;
2227         int                     rval = -1;
2228         int                     pgr_sema_held = 0;
2229         int                     held;
2230         int                     mps_flag = MDI_SELECT_ONLINE_PATH;
2231         struct scsi_vhci_lun    *vlun;
2232         int                     path_instance = 0;
2233 
2234         vlun = ADDR2VLUN(ap);
2235         ASSERT(vlun != 0);
2236 
2237         if ((vpkt->vpkt_tgt_pkt->pkt_cdbp[0] == SCMD_PROUT) &&
2238             (((vpkt->vpkt_tgt_pkt->pkt_cdbp[1] & 0x1f) ==
2239             VHCI_PROUT_REGISTER) ||
2240             ((vpkt->vpkt_tgt_pkt->pkt_cdbp[1] & 0x1f) ==
2241             VHCI_PROUT_R_AND_IGNORE))) {
2242                 if (!sema_tryp(&vlun->svl_pgr_sema))
2243                         return (TRAN_BUSY);
2244                 pgr_sema_held = 1;
2245                 if (vlun->svl_first_path != NULL) {
2246                         rval = mdi_select_path(cdip, NULL,
2247                             MDI_SELECT_ONLINE_PATH | MDI_SELECT_STANDBY_PATH,
2248                             NULL, &pip);
2249                         if ((rval != MDI_SUCCESS) || (pip == NULL)) {
2250                                 VHCI_DEBUG(4, (CE_NOTE, NULL,
2251                                     "vhci_bind_transport: path select fail\n"));
2252                         } else {
2253                                 npip = pip;
2254                                 do {
2255                                         if (npip == vlun->svl_first_path) {
2256                                                 VHCI_DEBUG(4, (CE_NOTE, NULL,
2257                                                     "vhci_bind_transport: "
2258                                                     "valid first path 0x%p\n",
2259                                                     (void *)
2260                                                     vlun->svl_first_path));
2261                                                 pip = vlun->svl_first_path;
2262                                                 goto bind_path;
2263                                         }
2264                                         pip = npip;
2265                                         rval = mdi_select_path(cdip, NULL,
2266                                             MDI_SELECT_ONLINE_PATH |
2267                                             MDI_SELECT_STANDBY_PATH,
2268                                             pip, &npip);
2269                                         mdi_rele_path(pip);
2270                                 } while ((rval == MDI_SUCCESS) &&
2271                                     (npip != NULL));
2272                         }
2273                 }
2274 
2275                 if (vlun->svl_first_path) {
2276                         VHCI_DEBUG(4, (CE_NOTE, NULL,
2277                             "vhci_bind_transport: invalid first path 0x%p\n",
2278                             (void *)vlun->svl_first_path));
2279                         vlun->svl_first_path = NULL;
2280                 }
2281         } else if (vpkt->vpkt_tgt_pkt->pkt_cdbp[0] == SCMD_PRIN) {
2282                 if ((vpkt->vpkt_state & VHCI_PKT_THRU_TASKQ) == 0) {
2283                         if (!sema_tryp(&vlun->svl_pgr_sema))
2284                                 return (TRAN_BUSY);
2285                 }
2286                 pgr_sema_held = 1;
2287         }
2288 
2289         /*
2290          * If the path is already bound for PKT_PARTIAL_DMA case,
2291          * try to use the same path.
2292          */
2293         if ((vpkt->vpkt_flags & CFLAG_DMA_PARTIAL) && vpkt->vpkt_path) {
2294                 VHCI_DEBUG(4, (CE_NOTE, NULL,
2295                     "vhci_bind_transport: PKT_PARTIAL_DMA "
2296                     "vpkt 0x%p, path 0x%p\n",
2297                     (void *)vpkt, (void *)vpkt->vpkt_path));
2298                 pip = vpkt->vpkt_path;
2299                 goto bind_path;
2300         }
2301 
2302         /*
2303          * Get path_instance. Non-zero with FLAG_PKT_PATH_INSTANCE set
2304          * indicates that mdi_select_path should be called to select a
2305          * specific instance.
2306          *
2307          * NB: Condition pkt_path_instance reference on proper allocation.
2308          */
2309         if ((vpkt->vpkt_tgt_pkt->pkt_flags & FLAG_PKT_PATH_INSTANCE) &&
2310             scsi_pkt_allocated_correctly(vpkt->vpkt_tgt_pkt)) {
2311                 path_instance = vpkt->vpkt_tgt_pkt->pkt_path_instance;
2312         }
2313 
2314         /*
2315          * If reservation is active bind the transport directly to the pip
2316          * with the reservation.
2317          */
2318         if (vpkt->vpkt_hba_pkt == NULL) {
2319                 if (vlun->svl_flags & VLUN_RESERVE_ACTIVE_FLG) {
2320                         if (MDI_PI_IS_ONLINE(vlun->svl_resrv_pip)) {
2321                                 pip = vlun->svl_resrv_pip;
2322                                 mdi_hold_path(pip);
2323                                 vlun->svl_waiting_for_activepath = 0;
2324                                 rval = MDI_SUCCESS;
2325                                 goto bind_path;
2326                         } else {
2327                                 if (pgr_sema_held) {
2328                                         sema_v(&vlun->svl_pgr_sema);
2329                                 }
2330                                 return (TRAN_BUSY);
2331                         }
2332                 }
2333 try_again:
2334                 rval = mdi_select_path(cdip, vpkt->vpkt_tgt_init_bp,
2335                     path_instance ? MDI_SELECT_PATH_INSTANCE : 0,
2336                     (void *)(intptr_t)path_instance, &pip);
2337                 if (rval == MDI_BUSY) {
2338                         if (pgr_sema_held) {
2339                                 sema_v(&vlun->svl_pgr_sema);
2340                         }
2341                         return (TRAN_BUSY);
2342                 } else if (rval == MDI_DEVI_ONLINING) {
2343                         /*
2344                          * if we are here then we are in the midst of
2345                          * an attach/probe of the client device.
2346                          * We attempt to bind to ONLINE path if available,
2347                          * else it is OK to bind to a STANDBY path (instead
2348                          * of triggering a failover) because IO associated
2349                          * with attach/probe (eg. INQUIRY, block 0 read)
2350                          * are completed by targets even on passive paths
2351                          * If no ONLINE paths available, it is important
2352                          * to set svl_waiting_for_activepath for two
2353                          * reasons: (1) avoid sense analysis in the
2354                          * "external failure detection" codepath in
2355                          * vhci_intr().  Failure to do so will result in
2356                          * infinite loop (unless an ONLINE path becomes
2357                          * available at some point) (2) avoid
2358                          * unnecessary failover (see "---Waiting For Active
2359                          * Path---" comment below).
2360                          */
2361                         VHCI_DEBUG(1, (CE_NOTE, NULL, "!%p in onlining "
2362                             "state\n", (void *)cdip));
2363                         pip = NULL;
2364                         rval = mdi_select_path(cdip, vpkt->vpkt_tgt_init_bp,
2365                             mps_flag, NULL, &pip);
2366                         if ((rval != MDI_SUCCESS) || (pip == NULL)) {
2367                                 if (vlun->svl_waiting_for_activepath == 0) {
2368                                         vlun->svl_waiting_for_activepath = 1;
2369                                         vlun->svl_wfa_time = gethrtime();
2370                                 }
2371                                 mps_flag |= MDI_SELECT_STANDBY_PATH;
2372                                 rval = mdi_select_path(cdip,
2373                                     vpkt->vpkt_tgt_init_bp,
2374                                     mps_flag, NULL, &pip);
2375                                 if ((rval != MDI_SUCCESS) || (pip == NULL)) {
2376                                         if (pgr_sema_held) {
2377                                                 sema_v(&vlun->svl_pgr_sema);
2378                                         }
2379                                         return (TRAN_FATAL_ERROR);
2380                                 }
2381                                 goto bind_path;
2382                         }
2383                 } else if ((rval == MDI_FAILURE) ||
2384                     ((rval == MDI_NOPATH) && (path_instance))) {
2385                         if (pgr_sema_held) {
2386                                 sema_v(&vlun->svl_pgr_sema);
2387                         }
2388                         return (TRAN_FATAL_ERROR);
2389                 }
2390 
2391                 if ((pip == NULL) || (rval == MDI_NOPATH)) {
2392                         while (vlun->svl_waiting_for_activepath) {
2393                                 /*
2394                                  * ---Waiting For Active Path---
2395                                  * This device was discovered across a
2396                                  * passive path; lets wait for a little
2397                                  * bit, hopefully an active path will
2398                                  * show up obviating the need for a
2399                                  * failover
2400                                  */
2401                                 if ((gethrtime() - vlun->svl_wfa_time) >=
2402                                     (60 * NANOSEC)) {
2403                                         vlun->svl_waiting_for_activepath = 0;
2404                                 } else {
2405                                         drv_usecwait(1000);
2406                                         if (vlun->svl_waiting_for_activepath
2407                                             == 0) {
2408                                                 /*
2409                                                  * an active path has come
2410                                                  * online!
2411                                                  */
2412                                                 goto try_again;
2413                                         }
2414                                 }
2415                         }
2416                         VHCI_HOLD_LUN(vlun, VH_NOSLEEP, held);
2417                         if (!held) {
2418                                 VHCI_DEBUG(4, (CE_NOTE, NULL,
2419                                     "!Lun not held\n"));
2420                                 if (pgr_sema_held) {
2421                                         sema_v(&vlun->svl_pgr_sema);
2422                                 }
2423                                 return (TRAN_BUSY);
2424                         }
2425                         /*
2426                          * now that the LUN is stable, one last check
2427                          * to make sure no other changes sneaked in
2428                          * (like a path coming online or a
2429                          * failover initiated by another thread)
2430                          */
2431                         pip = NULL;
2432                         rval = mdi_select_path(cdip, vpkt->vpkt_tgt_init_bp,
2433                             0, NULL, &pip);
2434                         if (pip != NULL) {
2435                                 VHCI_RELEASE_LUN(vlun);
2436                                 vlun->svl_waiting_for_activepath = 0;
2437                                 goto bind_path;
2438                         }
2439 
2440                         /*
2441                          * Check if there is an ONLINE path OR a STANDBY path
2442                          * available. If none is available, do not attempt
2443                          * to do a failover, just return a fatal error at this
2444                          * point.
2445                          */
2446                         npip = NULL;
2447                         rval = mdi_select_path(cdip, NULL,
2448                             (MDI_SELECT_ONLINE_PATH | MDI_SELECT_STANDBY_PATH),
2449                             NULL, &npip);
2450                         if ((npip == NULL) || (rval != MDI_SUCCESS)) {
2451                                 /*
2452                                  * No paths available, jus return FATAL error.
2453                                  */
2454                                 VHCI_RELEASE_LUN(vlun);
2455                                 if (pgr_sema_held) {
2456                                         sema_v(&vlun->svl_pgr_sema);
2457                                 }
2458                                 return (TRAN_FATAL_ERROR);
2459                         }
2460                         mdi_rele_path(npip);
2461                         if (!(vpkt->vpkt_state & VHCI_PKT_IN_FAILOVER)) {
2462                                 VHCI_DEBUG(1, (CE_NOTE, NULL, "!invoking "
2463                                     "mdi_failover\n"));
2464                                 rval = mdi_failover(vhci->vhci_dip, cdip,
2465                                     MDI_FAILOVER_ASYNC);
2466                         } else {
2467                                 rval = vlun->svl_failover_status;
2468                         }
2469                         if (rval == MDI_FAILURE) {
2470                                 VHCI_RELEASE_LUN(vlun);
2471                                 if (pgr_sema_held) {
2472                                         sema_v(&vlun->svl_pgr_sema);
2473                                 }
2474                                 return (TRAN_FATAL_ERROR);
2475                         } else if (rval == MDI_BUSY) {
2476                                 VHCI_RELEASE_LUN(vlun);
2477                                 if (pgr_sema_held) {
2478                                         sema_v(&vlun->svl_pgr_sema);
2479                                 }
2480                                 return (TRAN_BUSY);
2481                         } else {
2482                                 if (pgr_sema_held) {
2483                                         sema_v(&vlun->svl_pgr_sema);
2484                                 }
2485                                 vpkt->vpkt_state |= VHCI_PKT_IN_FAILOVER;
2486                                 return (TRAN_BUSY);
2487                         }
2488                 }
2489                 vlun->svl_waiting_for_activepath = 0;
2490 bind_path:
2491                 vpkt->vpkt_path = pip;
2492                 svp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(pip);
2493                 ASSERT(svp != NULL);
2494 
2495                 psd = svp->svp_psd;
2496                 ASSERT(psd != NULL);
2497                 address = &psd->sd_address;
2498         } else {
2499                 pkt = vpkt->vpkt_hba_pkt;
2500                 address = &pkt->pkt_address;
2501         }
2502 
2503         /* Verify match of specified path_instance and selected path_instance */
2504         ASSERT((path_instance == 0) ||
2505             (path_instance == mdi_pi_get_path_instance(vpkt->vpkt_path)));
2506 
2507         /*
2508          * For PKT_PARTIAL_DMA case, call pHCI's scsi_init_pkt whenever
2509          * target driver calls vhci_scsi_init_pkt.
2510          */
2511         if ((vpkt->vpkt_flags & CFLAG_DMA_PARTIAL) &&
2512             vpkt->vpkt_path && vpkt->vpkt_hba_pkt) {
2513                 VHCI_DEBUG(4, (CE_NOTE, NULL,
2514                     "vhci_bind_transport: PKT_PARTIAL_DMA "
2515                     "vpkt 0x%p, path 0x%p hba_pkt 0x%p\n",
2516                     (void *)vpkt, (void *)vpkt->vpkt_path, (void *)pkt));
2517                 pkt = vpkt->vpkt_hba_pkt;
2518                 address = &pkt->pkt_address;
2519         }
2520 
2521         if (pkt == NULL || (vpkt->vpkt_flags & CFLAG_DMA_PARTIAL)) {
2522                 pkt = scsi_init_pkt(address, pkt,
2523                     vpkt->vpkt_tgt_init_bp, vpkt->vpkt_tgt_init_cdblen,
2524                     vpkt->vpkt_tgt_init_scblen, 0, flags, func, NULL);
2525 
2526                 if (pkt == NULL) {
2527                         VHCI_DEBUG(4, (CE_NOTE, NULL,
2528                             "!bind transport: 0x%p 0x%p 0x%p\n",
2529                             (void *)vhci, (void *)psd, (void *)vpkt));
2530                         if ((vpkt->vpkt_hba_pkt == NULL) && vpkt->vpkt_path) {
2531                                 MDI_PI_ERRSTAT(vpkt->vpkt_path,
2532                                     MDI_PI_TRANSERR);
2533                                 mdi_rele_path(vpkt->vpkt_path);
2534                                 vpkt->vpkt_path = NULL;
2535                         }
2536                         if (pgr_sema_held) {
2537                                 sema_v(&vlun->svl_pgr_sema);
2538                         }
2539                         /*
2540                          * Consider it a fatal error if b_error is
2541                          * set as a result of DMA binding failure
2542                          * vs. a condition of being temporarily out of
2543                          * some resource
2544                          */
2545                         if (vpkt->vpkt_tgt_init_bp == NULL ||
2546                             geterror(vpkt->vpkt_tgt_init_bp))
2547                                 return (TRAN_FATAL_ERROR);
2548                         else
2549                                 return (TRAN_BUSY);
2550                 }
2551         }
2552 
2553         pkt->pkt_private = vpkt;
2554         vpkt->vpkt_hba_pkt = pkt;
2555         return (TRAN_ACCEPT);
2556 }
2557 
2558 
2559 /*PRINTFLIKE3*/
2560 void
2561 vhci_log(int level, dev_info_t *dip, const char *fmt, ...)
2562 {
2563         char            buf[256];
2564         va_list         ap;
2565 
2566         va_start(ap, fmt);
2567         (void) vsprintf(buf, fmt, ap);
2568         va_end(ap);
2569 
2570         scsi_log(dip, "scsi_vhci", level, buf);
2571 }
2572 
2573 /* do a PGR out with the information we've saved away */
2574 static int
2575 vhci_do_prout(scsi_vhci_priv_t *svp)
2576 {
2577 
2578         struct scsi_pkt                 *new_pkt;
2579         struct buf                      *bp;
2580         scsi_vhci_lun_t                 *vlun = svp->svp_svl;
2581         int                             rval, retry, nr_retry, ua_retry;
2582         uint8_t                         *sns, skey;
2583 
2584         bp = getrbuf(KM_SLEEP);
2585         bp->b_flags = B_WRITE;
2586         bp->b_resid = 0;
2587         bp->b_un.b_addr = (caddr_t)&vlun->svl_prout;
2588         bp->b_bcount = vlun->svl_bcount;
2589 
2590         VHCI_INCR_PATH_CMDCOUNT(svp);
2591 
2592         new_pkt = scsi_init_pkt(&svp->svp_psd->sd_address, NULL, bp,
2593             CDB_GROUP1, sizeof (struct scsi_arq_status), 0, 0,
2594             SLEEP_FUNC, NULL);
2595         if (new_pkt == NULL) {
2596                 VHCI_DECR_PATH_CMDCOUNT(svp);
2597                 freerbuf(bp);
2598                 cmn_err(CE_WARN, "!vhci_do_prout: scsi_init_pkt failed");
2599                 return (0);
2600         }
2601         mutex_enter(&vlun->svl_mutex);
2602         bp->b_un.b_addr = (caddr_t)&vlun->svl_prout;
2603         bp->b_bcount = vlun->svl_bcount;
2604         bcopy(vlun->svl_cdb, new_pkt->pkt_cdbp,
2605             sizeof (vlun->svl_cdb));
2606         new_pkt->pkt_time = vlun->svl_time;
2607         mutex_exit(&vlun->svl_mutex);
2608         new_pkt->pkt_flags = FLAG_NOINTR;
2609 
2610         ua_retry = nr_retry = retry = 0;
2611 again:
2612         rval = vhci_do_scsi_cmd(new_pkt);
2613         if (rval != 1) {
2614                 if ((new_pkt->pkt_reason == CMD_CMPLT) &&
2615                     (SCBP_C(new_pkt) == STATUS_CHECK) &&
2616                     (new_pkt->pkt_state & STATE_ARQ_DONE)) {
2617                         sns = (uint8_t *)
2618                             &(((struct scsi_arq_status *)(uintptr_t)
2619                             (new_pkt->pkt_scbp))->sts_sensedata);
2620                         skey = scsi_sense_key(sns);
2621                         if ((skey == KEY_UNIT_ATTENTION) ||
2622                             (skey == KEY_NOT_READY)) {
2623                                 int max_retry;
2624                                 struct scsi_failover_ops *fops;
2625                                 fops = vlun->svl_fops;
2626                                 rval = fops->sfo_analyze_sense(svp->svp_psd,
2627                                     sns, vlun->svl_fops_ctpriv);
2628                                 if (rval == SCSI_SENSE_NOT_READY) {
2629                                         max_retry = vhci_prout_not_ready_retry;
2630                                         retry = nr_retry++;
2631                                         delay(1*drv_usectohz(1000000));
2632                                 } else {
2633                                         /* chk for state change and update */
2634                                         if (rval == SCSI_SENSE_STATE_CHANGED) {
2635                                                 int held;
2636                                                 VHCI_HOLD_LUN(vlun,
2637                                                     VH_NOSLEEP, held);
2638                                                 if (!held) {
2639                                                         rval = TRAN_BUSY;
2640                                                 } else {
2641                                                         /* chk for alua first */
2642                                                         vhci_update_pathstates(
2643                                                             (void *)vlun);
2644                                                 }
2645                                         }
2646                                         retry = ua_retry++;
2647                                         max_retry = VHCI_MAX_PGR_RETRIES;
2648                                 }
2649                                 if (retry < max_retry) {
2650                                         VHCI_DEBUG(4, (CE_WARN, NULL,
2651                                             "!vhci_do_prout retry 0x%x "
2652                                             "(0x%x 0x%x 0x%x)",
2653                                             SCBP_C(new_pkt),
2654                                             new_pkt->pkt_cdbp[0],
2655                                             new_pkt->pkt_cdbp[1],
2656                                             new_pkt->pkt_cdbp[2]));
2657                                         goto again;
2658                                 }
2659                                 rval = 0;
2660                                 VHCI_DEBUG(4, (CE_WARN, NULL,
2661                                     "!vhci_do_prout 0x%x "
2662                                     "(0x%x 0x%x 0x%x)",
2663                                     SCBP_C(new_pkt),
2664                                     new_pkt->pkt_cdbp[0],
2665                                     new_pkt->pkt_cdbp[1],
2666                                     new_pkt->pkt_cdbp[2]));
2667                         } else if (skey == KEY_ILLEGAL_REQUEST)
2668                                 rval = VHCI_PGR_ILLEGALOP;
2669                 }
2670         } else {
2671                 rval = 1;
2672         }
2673         scsi_destroy_pkt(new_pkt);
2674         VHCI_DECR_PATH_CMDCOUNT(svp);
2675         freerbuf(bp);
2676         return (rval);
2677 }
2678 
2679 static void
2680 vhci_run_cmd(void *arg)
2681 {
2682         struct scsi_pkt         *pkt = (struct scsi_pkt *)arg;
2683         struct scsi_pkt         *tpkt;
2684         scsi_vhci_priv_t        *svp;
2685         mdi_pathinfo_t          *pip, *npip;
2686         scsi_vhci_lun_t         *vlun;
2687         dev_info_t              *cdip;
2688         scsi_vhci_priv_t        *nsvp;
2689         int                     fail = 0;
2690         int                     rval;
2691         struct vhci_pkt         *vpkt;
2692         uchar_t                 cdb_1;
2693         vhci_prout_t            *prout;
2694 
2695         vpkt = (struct vhci_pkt *)pkt->pkt_private;
2696         tpkt = vpkt->vpkt_tgt_pkt;
2697         pip = vpkt->vpkt_path;
2698         svp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(pip);
2699         if (svp == NULL) {
2700                 tpkt->pkt_reason = CMD_TRAN_ERR;
2701                 tpkt->pkt_statistics = STAT_ABORTED;
2702                 goto done;
2703         }
2704         vlun = svp->svp_svl;
2705         prout = &vlun->svl_prout;
2706         if (SCBP_C(pkt) != STATUS_GOOD)
2707                 fail++;
2708         cdip = vlun->svl_dip;
2709         pip = npip = NULL;
2710         rval = mdi_select_path(cdip, NULL,
2711             MDI_SELECT_ONLINE_PATH|MDI_SELECT_STANDBY_PATH, NULL, &npip);
2712         if ((rval != MDI_SUCCESS) || (npip == NULL)) {
2713                 VHCI_DEBUG(4, (CE_NOTE, NULL,
2714                     "vhci_run_cmd: no path! 0x%p\n", (void *)svp));
2715                 tpkt->pkt_reason = CMD_TRAN_ERR;
2716                 tpkt->pkt_statistics = STAT_ABORTED;
2717                 goto done;
2718         }
2719 
2720         cdb_1 = vlun->svl_cdb[1];
2721         vlun->svl_cdb[1] &= 0xe0;
2722         vlun->svl_cdb[1] |= VHCI_PROUT_R_AND_IGNORE;
2723 
2724         do {
2725                 nsvp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(npip);
2726                 if (nsvp == NULL) {
2727                         VHCI_DEBUG(4, (CE_NOTE, NULL,
2728                             "vhci_run_cmd: no "
2729                             "client priv! 0x%p offlined?\n",
2730                             (void *)npip));
2731                         goto next_path;
2732                 }
2733                 if (vlun->svl_first_path == npip) {
2734                         goto next_path;
2735                 } else {
2736                         if (vhci_do_prout(nsvp) != 1)
2737                                 fail++;
2738                 }
2739 next_path:
2740                 pip = npip;
2741                 rval = mdi_select_path(cdip, NULL,
2742                     MDI_SELECT_ONLINE_PATH|MDI_SELECT_STANDBY_PATH,
2743                     pip, &npip);
2744                 mdi_rele_path(pip);
2745         } while ((rval == MDI_SUCCESS) && (npip != NULL));
2746 
2747         vlun->svl_cdb[1] = cdb_1;
2748 
2749         if (fail) {
2750                 VHCI_DEBUG(4, (CE_WARN, NULL, "%s%d: key registration failed, "
2751                     "couldn't be replicated on all paths",
2752                     ddi_driver_name(cdip), ddi_get_instance(cdip)));
2753                 vhci_print_prout_keys(vlun, "vhci_run_cmd: ");
2754 
2755                 if (SCBP_C(pkt) != STATUS_GOOD) {
2756                         tpkt->pkt_reason = CMD_TRAN_ERR;
2757                         tpkt->pkt_statistics = STAT_ABORTED;
2758                 }
2759         } else {
2760                 vlun->svl_pgr_active = 1;
2761                 vhci_print_prout_keys(vlun, "vhci_run_cmd: before bcopy:");
2762 
2763                 bcopy((const void *)prout->service_key,
2764                     (void *)prout->active_service_key, MHIOC_RESV_KEY_SIZE);
2765                 bcopy((const void *)prout->res_key,
2766                     (void *)prout->active_res_key, MHIOC_RESV_KEY_SIZE);
2767 
2768                 vhci_print_prout_keys(vlun, "vhci_run_cmd: after bcopy:");
2769         }
2770 done:
2771         if (SCBP_C(pkt) == STATUS_GOOD)
2772                 vlun->svl_first_path = NULL;
2773 
2774         if (svp)
2775                 VHCI_DECR_PATH_CMDCOUNT(svp);
2776 
2777         if ((vpkt->vpkt_flags & CFLAG_DMA_PARTIAL) == 0) {
2778                 scsi_destroy_pkt(pkt);
2779                 vpkt->vpkt_hba_pkt = NULL;
2780                 if (vpkt->vpkt_path) {
2781                         mdi_rele_path(vpkt->vpkt_path);
2782                         vpkt->vpkt_path = NULL;
2783                 }
2784         }
2785 
2786         sema_v(&vlun->svl_pgr_sema);
2787         /*
2788          * The PROUT commands are not included in the automatic retry
2789          * mechanism, therefore, vpkt_org_vpkt should never be set here.
2790          */
2791         ASSERT(vpkt->vpkt_org_vpkt == NULL);
2792         scsi_hba_pkt_comp(tpkt);
2793 }
2794 
2795 /*
2796  * Get the keys registered with this target.  Since we will have
2797  * registered the same key with multiple initiators, strip out
2798  * any duplicate keys.
2799  *
2800  * The pointers which will be used to filter the registered keys from
2801  * the device will be stored in filter_prin and filter_pkt.  If the
2802  * allocation length of the buffer was sufficient for the number of
2803  * parameter data bytes available to be returned by the device then the
2804  * key filtering will use the keylist returned from the original
2805  * request.  If the allocation length of the buffer was not sufficient,
2806  * then the filtering will use the keylist returned from the request
2807  * that is resent below.
2808  *
2809  * If the device returns an additional length field that is greater than
2810  * the allocation length of the buffer, then allocate a new buffer which
2811  * can accommodate the number of parameter data bytes available to be
2812  * returned.  Resend the scsi PRIN command, filter out the duplicate
2813  * keys and return as many of the unique keys found that was originally
2814  * requested and set the additional length field equal to the data bytes
2815  * of unique reservation keys available to be returned.
2816  *
2817  * If the device returns an additional length field that is less than or
2818  * equal to the allocation length of the buffer, then all the available
2819  * keys registered were returned by the device.  Filter out the
2820  * duplicate keys and return all of the unique keys found and set the
2821  * additional length field equal to the data bytes of the reservation
2822  * keys to be returned.
2823  */
2824 
2825 #define VHCI_PRIN_HEADER_SZ (sizeof (prin->length) + sizeof (prin->generation))
2826 
2827 static int
2828 vhci_do_prin(struct vhci_pkt **intr_vpkt)
2829 {
2830         scsi_vhci_priv_t *svp;
2831         struct vhci_pkt *vpkt = *intr_vpkt;
2832         vhci_prin_readkeys_t *prin;
2833         scsi_vhci_lun_t *vlun;
2834         struct scsi_vhci *vhci = ADDR2VHCI(&vpkt->vpkt_tgt_pkt->pkt_address);
2835 
2836         struct buf              *new_bp = NULL;
2837         struct scsi_pkt         *new_pkt = NULL;
2838         struct vhci_pkt         *new_vpkt = NULL;
2839         uint32_t                needed_length;
2840         int                     rval = VHCI_CMD_CMPLT;
2841         uint32_t                prin_length = 0;
2842         uint32_t                svl_prin_length = 0;
2843 
2844         ASSERT(vpkt->vpkt_path);
2845         svp = mdi_pi_get_vhci_private(vpkt->vpkt_path);
2846         ASSERT(svp);
2847         vlun = svp->svp_svl;
2848         ASSERT(vlun);
2849 
2850         /*
2851          * If the caller only asked for an amount of data that would not
2852          * be enough to include any key data it is likely that they will
2853          * send the next command with a buffer size based on the information
2854          * from this header. Doing recovery on this would be a duplication
2855          * of efforts.
2856          */
2857         if (vpkt->vpkt_tgt_init_bp->b_bcount <= VHCI_PRIN_HEADER_SZ) {
2858                 rval = VHCI_CMD_CMPLT;
2859                 goto exit;
2860         }
2861 
2862         if (vpkt->vpkt_org_vpkt == NULL) {
2863                 /*
2864                  * Can fail as sleep is not allowed.
2865                  */
2866                 prin = (vhci_prin_readkeys_t *)
2867                     bp_mapin_common(vpkt->vpkt_tgt_init_bp, VM_NOSLEEP);
2868         } else {
2869                 /*
2870                  * The retry buf doesn't need to be mapped in.
2871                  */
2872                 prin = (vhci_prin_readkeys_t *)
2873                     vpkt->vpkt_tgt_init_bp->b_un.b_daddr;
2874         }
2875 
2876         if (prin == NULL) {
2877                 VHCI_DEBUG(5, (CE_WARN, NULL,
2878                     "vhci_do_prin: bp_mapin_common failed."));
2879                 rval = VHCI_CMD_ERROR;
2880                 goto fail;
2881         }
2882 
2883         prin_length = BE_32(prin->length);
2884 
2885         /*
2886          * According to SPC-3r22, sec 4.3.4.6: "If the amount of
2887          * information to be transferred exceeds the maximum value
2888          * that the ALLOCATION LENGTH field is capable of specifying,
2889          * the device server shall...terminate the command with CHECK
2890          * CONDITION status".  The ALLOCATION LENGTH field of the
2891          * PERSISTENT RESERVE IN command is 2 bytes. We should never
2892          * get here with an ADDITIONAL LENGTH greater than 0xFFFF
2893          * so if we do, then it is an error!
2894          */
2895 
2896 
2897         if ((prin_length + VHCI_PRIN_HEADER_SZ) > 0xFFFF) {
2898                 VHCI_DEBUG(5, (CE_NOTE, NULL,
2899                     "vhci_do_prin: Device returned invalid "
2900                     "length 0x%x\n", prin_length));
2901                 rval = VHCI_CMD_ERROR;
2902                 goto fail;
2903         }
2904         needed_length = prin_length + VHCI_PRIN_HEADER_SZ;
2905 
2906         /*
2907          * If prin->length is greater than the byte count allocated in the
2908          * original buffer, then resend the request with enough buffer
2909          * allocated to get all of the available registered keys.
2910          */
2911         if ((vpkt->vpkt_tgt_init_bp->b_bcount < needed_length) &&
2912             (vpkt->vpkt_org_vpkt == NULL)) {
2913 
2914                 new_pkt = vhci_create_retry_pkt(vpkt);
2915                 if (new_pkt == NULL) {
2916                         rval = VHCI_CMD_ERROR;
2917                         goto fail;
2918                 }
2919                 new_vpkt = TGTPKT2VHCIPKT(new_pkt);
2920 
2921                 /*
2922                  * This is the buf with buffer pointer
2923                  * where the prin readkeys will be
2924                  * returned from the device
2925                  */
2926                 new_bp = scsi_alloc_consistent_buf(&svp->svp_psd->sd_address,
2927                     NULL, needed_length, B_READ, NULL_FUNC, NULL);
2928                 if ((new_bp == NULL) || (new_bp->b_un.b_addr == NULL)) {
2929                         if (new_bp) {
2930                                 scsi_free_consistent_buf(new_bp);
2931                         }
2932                         vhci_scsi_destroy_pkt(&new_pkt->pkt_address, new_pkt);
2933                         rval = VHCI_CMD_ERROR;
2934                         goto fail;
2935                 }
2936                 new_bp->b_bcount = needed_length;
2937                 new_pkt->pkt_cdbp[7] = (uchar_t)(needed_length >> 8);
2938                 new_pkt->pkt_cdbp[8] = (uchar_t)needed_length;
2939 
2940                 rval = VHCI_CMD_RETRY;
2941 
2942                 new_vpkt->vpkt_tgt_init_bp = new_bp;
2943         }
2944 
2945         if (rval == VHCI_CMD_RETRY) {
2946 
2947                 /*
2948                  * There were more keys then the original request asked for.
2949                  */
2950                 mdi_pathinfo_t *path_holder = vpkt->vpkt_path;
2951 
2952                 /*
2953                  * Release the old path because it does not matter which path
2954                  * this command is sent down.  This allows the normal bind
2955                  * transport mechanism to be used.
2956                  */
2957                 if (vpkt->vpkt_path != NULL) {
2958                         mdi_rele_path(vpkt->vpkt_path);
2959                         vpkt->vpkt_path = NULL;
2960                 }
2961 
2962                 /*
2963                  * Dispatch the retry command
2964                  */
2965                 if (taskq_dispatch(vhci->vhci_taskq, vhci_dispatch_scsi_start,
2966                     (void *) new_vpkt, KM_NOSLEEP) == NULL) {
2967                         if (path_holder) {
2968                                 vpkt->vpkt_path = path_holder;
2969                                 mdi_hold_path(path_holder);
2970                         }
2971                         scsi_free_consistent_buf(new_bp);
2972                         vhci_scsi_destroy_pkt(&new_pkt->pkt_address, new_pkt);
2973                         rval = VHCI_CMD_ERROR;
2974                         goto fail;
2975                 }
2976 
2977                 /*
2978                  * If we return VHCI_CMD_RETRY, that means the caller
2979                  * is going to bail and wait for the reissued command
2980                  * to complete.  In that case, we need to decrement
2981                  * the path command count right now.  In any other
2982                  * case, it'll be decremented by the caller.
2983                  */
2984                 VHCI_DECR_PATH_CMDCOUNT(svp);
2985                 goto exit;
2986 
2987         }
2988 
2989         if (rval == VHCI_CMD_CMPLT) {
2990                 /*
2991                  * The original request got all of the keys or the recovery
2992                  * packet returns.
2993                  */
2994                 int new;
2995                 int old;
2996                 int num_keys = prin_length / MHIOC_RESV_KEY_SIZE;
2997 
2998                 VHCI_DEBUG(4, (CE_NOTE, NULL, "vhci_do_prin: %d keys read\n",
2999                     num_keys));
3000 
3001 #ifdef DEBUG
3002                 VHCI_DEBUG(5, (CE_NOTE, NULL, "vhci_do_prin: from storage\n"));
3003                 if (vhci_debug == 5)
3004                         vhci_print_prin_keys(prin, num_keys);
3005                 VHCI_DEBUG(5, (CE_NOTE, NULL,
3006                     "vhci_do_prin: MPxIO old keys:\n"));
3007                 if (vhci_debug == 5)
3008                         vhci_print_prin_keys(&vlun->svl_prin, num_keys);
3009 #endif
3010 
3011                 /*
3012                  * Filter out all duplicate keys returned from the device
3013                  * We know that we use a different key for every host, so we
3014                  * can simply strip out duplicates. Otherwise we would need to
3015                  * do more bookkeeping to figure out which keys to strip out.
3016                  */
3017 
3018                 new = 0;
3019 
3020                 /*
3021                  * If we got at least 1 key copy it.
3022                  */
3023                 if (num_keys > 0) {
3024                         vlun->svl_prin.keylist[0] = prin->keylist[0];
3025                         new++;
3026                 }
3027 
3028                 /*
3029                  * find next unique key.
3030                  */
3031                 for (old = 1; old < num_keys; old++) {
3032                         int j;
3033                         int match = 0;
3034 
3035                         if (new >= VHCI_NUM_RESV_KEYS)
3036                                 break;
3037                         for (j = 0; j < new; j++) {
3038                                 if (bcmp(&prin->keylist[old],
3039                                     &vlun->svl_prin.keylist[j],
3040                                     sizeof (mhioc_resv_key_t)) == 0) {
3041                                         match = 1;
3042                                         break;
3043                                 }
3044                         }
3045                         if (!match) {
3046                                 vlun->svl_prin.keylist[new] =
3047                                     prin->keylist[old];
3048                                 new++;
3049                         }
3050                 }
3051 
3052                 /* Stored Big Endian */
3053                 vlun->svl_prin.generation = prin->generation;
3054                 svl_prin_length = new * sizeof (mhioc_resv_key_t);
3055                 /* Stored Big Endian */
3056                 vlun->svl_prin.length = BE_32(svl_prin_length);
3057                 svl_prin_length += VHCI_PRIN_HEADER_SZ;
3058 
3059                 /*
3060                  * If we arrived at this point after issuing a retry, make sure
3061                  * that we put everything back the way it originally was so
3062                  * that the target driver can complete the command correctly.
3063                  */
3064                 if (vpkt->vpkt_org_vpkt != NULL) {
3065                         new_bp = vpkt->vpkt_tgt_init_bp;
3066 
3067                         scsi_free_consistent_buf(new_bp);
3068 
3069                         vpkt = vhci_sync_retry_pkt(vpkt);
3070                         *intr_vpkt = vpkt;
3071 
3072                         /*
3073                          * Make sure the original buffer is mapped into kernel
3074                          * space before we try to copy the filtered keys into
3075                          * it.
3076                          */
3077                         prin = (vhci_prin_readkeys_t *)bp_mapin_common(
3078                             vpkt->vpkt_tgt_init_bp, VM_NOSLEEP);
3079                 }
3080 
3081                 /*
3082                  * Now copy the desired number of prin keys into the original
3083                  * target buffer.
3084                  */
3085                 if (svl_prin_length <= vpkt->vpkt_tgt_init_bp->b_bcount) {
3086                         /*
3087                          * It is safe to return all of the available unique
3088                          * keys
3089                          */
3090                         bcopy(&vlun->svl_prin, prin, svl_prin_length);
3091                 } else {
3092                         /*
3093                          * Not all of the available keys were requested by the
3094                          * original command.
3095                          */
3096                         bcopy(&vlun->svl_prin, prin,
3097                             vpkt->vpkt_tgt_init_bp->b_bcount);
3098                 }
3099 #ifdef DEBUG
3100                 VHCI_DEBUG(5, (CE_NOTE, NULL,
3101                     "vhci_do_prin: To Application:\n"));
3102                 if (vhci_debug == 5)
3103                         vhci_print_prin_keys(prin, new);
3104                 VHCI_DEBUG(5, (CE_NOTE, NULL,
3105                     "vhci_do_prin: MPxIO new keys:\n"));
3106                 if (vhci_debug == 5)
3107                         vhci_print_prin_keys(&vlun->svl_prin, new);
3108 #endif
3109         }
3110 fail:
3111         if (rval == VHCI_CMD_ERROR) {
3112                 /*
3113                  * If we arrived at this point after issuing a
3114                  * retry, make sure that we put everything back
3115                  * the way it originally was so that ssd can
3116                  * complete the command correctly.
3117                  */
3118 
3119                 if (vpkt->vpkt_org_vpkt != NULL) {
3120                         new_bp = vpkt->vpkt_tgt_init_bp;
3121                         if (new_bp != NULL) {
3122                                 scsi_free_consistent_buf(new_bp);
3123                         }
3124 
3125                         new_vpkt = vpkt;
3126                         vpkt = vpkt->vpkt_org_vpkt;
3127 
3128                         vhci_scsi_destroy_pkt(&svp->svp_psd->sd_address,
3129                             new_vpkt->vpkt_tgt_pkt);
3130                 }
3131 
3132                 /*
3133                  * Mark this command completion as having an error so that
3134                  * ssd will retry the command.
3135                  */
3136 
3137                 vpkt->vpkt_tgt_pkt->pkt_reason = CMD_ABORTED;
3138                 vpkt->vpkt_tgt_pkt->pkt_statistics |= STAT_ABORTED;
3139 
3140                 rval = VHCI_CMD_CMPLT;
3141         }
3142 exit:
3143         /*
3144          * Make sure that the semaphore is only released once.
3145          */
3146         if (rval == VHCI_CMD_CMPLT) {
3147                 sema_v(&vlun->svl_pgr_sema);
3148         }
3149 
3150         return (rval);
3151 }
3152 
3153 static void
3154 vhci_intr(struct scsi_pkt *pkt)
3155 {
3156         struct vhci_pkt         *vpkt = (struct vhci_pkt *)pkt->pkt_private;
3157         struct scsi_pkt         *tpkt;
3158         scsi_vhci_priv_t        *svp;
3159         scsi_vhci_lun_t         *vlun;
3160         int                     rval, held;
3161         struct scsi_failover_ops        *fops;
3162         uint8_t                 *sns, skey, asc, ascq;
3163         mdi_pathinfo_t          *lpath;
3164         static char             *timeout_err = "Command Timeout";
3165         static char             *parity_err = "Parity Error";
3166         char                    *err_str = NULL;
3167         dev_info_t              *vdip, *cdip;
3168         char                    *cpath;
3169 
3170         ASSERT(vpkt != NULL);
3171         tpkt = vpkt->vpkt_tgt_pkt;
3172         ASSERT(tpkt != NULL);
3173         svp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(vpkt->vpkt_path);
3174         ASSERT(svp != NULL);
3175         vlun = svp->svp_svl;
3176         ASSERT(vlun != NULL);
3177         lpath = vpkt->vpkt_path;
3178 
3179         /*
3180          * sync up the target driver's pkt with the pkt that
3181          * we actually used
3182          */
3183         *(tpkt->pkt_scbp) = *(pkt->pkt_scbp);
3184         tpkt->pkt_resid = pkt->pkt_resid;
3185         tpkt->pkt_state = pkt->pkt_state;
3186         tpkt->pkt_statistics = pkt->pkt_statistics;
3187         tpkt->pkt_reason = pkt->pkt_reason;
3188 
3189         /* Return path_instance information back to the target driver. */
3190         if (scsi_pkt_allocated_correctly(tpkt)) {
3191                 if (scsi_pkt_allocated_correctly(pkt)) {
3192                         /*
3193                          * If both packets were correctly allocated,
3194                          * return path returned by pHCI.
3195                          */
3196                         tpkt->pkt_path_instance = pkt->pkt_path_instance;
3197                 } else {
3198                         /* Otherwise return path of pHCI we used */
3199                         tpkt->pkt_path_instance =
3200                             mdi_pi_get_path_instance(lpath);
3201                 }
3202         }
3203 
3204         if (pkt->pkt_cdbp[0] == SCMD_PROUT &&
3205             ((pkt->pkt_cdbp[1] & 0x1f) == VHCI_PROUT_REGISTER) ||
3206             ((pkt->pkt_cdbp[1] & 0x1f) == VHCI_PROUT_R_AND_IGNORE)) {
3207                 if ((SCBP_C(pkt) != STATUS_GOOD) ||
3208                     (pkt->pkt_reason != CMD_CMPLT)) {
3209                         sema_v(&vlun->svl_pgr_sema);
3210                 }
3211         } else if (pkt->pkt_cdbp[0] == SCMD_PRIN) {
3212                 if (pkt->pkt_reason != CMD_CMPLT ||
3213                     (SCBP_C(pkt) != STATUS_GOOD)) {
3214                         sema_v(&vlun->svl_pgr_sema);
3215                 }
3216         }
3217 
3218         switch (pkt->pkt_reason) {
3219         case CMD_CMPLT:
3220                 /*
3221                  * cmd completed successfully, check for scsi errors
3222                  */
3223                 switch (*(pkt->pkt_scbp)) {
3224                 case STATUS_CHECK:
3225                         if (pkt->pkt_state & STATE_ARQ_DONE) {
3226                                 sns = (uint8_t *)
3227                                     &(((struct scsi_arq_status *)(uintptr_t)
3228                                     (pkt->pkt_scbp))->sts_sensedata);
3229                                 skey = scsi_sense_key(sns);
3230                                 asc = scsi_sense_asc(sns);
3231                                 ascq = scsi_sense_ascq(sns);
3232                                 fops = vlun->svl_fops;
3233                                 ASSERT(fops != NULL);
3234                                 VHCI_DEBUG(4, (CE_NOTE, NULL, "vhci_intr: "
3235                                     "Received sns key %x  esc %x  escq %x\n",
3236                                     skey, asc, ascq));
3237 
3238                                 if (vlun->svl_waiting_for_activepath == 1) {
3239                                         /*
3240                                          * if we are here it means we are
3241                                          * in the midst of a probe/attach
3242                                          * through a passive path; this
3243                                          * case is exempt from sense analysis
3244                                          * for detection of ext. failover
3245                                          * because that would unnecessarily
3246                                          * increase attach time.
3247                                          */
3248                                         bcopy(pkt->pkt_scbp, tpkt->pkt_scbp,
3249                                             vpkt->vpkt_tgt_init_scblen);
3250                                         break;
3251                                 }
3252                                 if (asc == VHCI_SCSI_PERR) {
3253                                         /*
3254                                          * parity error
3255                                          */
3256                                         err_str = parity_err;
3257                                         bcopy(pkt->pkt_scbp, tpkt->pkt_scbp,
3258                                             vpkt->vpkt_tgt_init_scblen);
3259                                         break;
3260                                 }
3261                                 rval = fops->sfo_analyze_sense(svp->svp_psd,
3262                                     sns, vlun->svl_fops_ctpriv);
3263                                 if ((rval == SCSI_SENSE_NOFAILOVER) ||
3264                                     (rval == SCSI_SENSE_UNKNOWN) ||
3265                                     (rval == SCSI_SENSE_NOT_READY)) {
3266                                         bcopy(pkt->pkt_scbp, tpkt->pkt_scbp,
3267                                             vpkt->vpkt_tgt_init_scblen);
3268                                         break;
3269                                 } else if (rval == SCSI_SENSE_STATE_CHANGED) {
3270                                         struct scsi_vhci        *vhci;
3271                                         vhci = ADDR2VHCI(&tpkt->pkt_address);
3272                                         VHCI_HOLD_LUN(vlun, VH_NOSLEEP, held);
3273                                         if (!held) {
3274                                                 /*
3275                                                  * looks like some other thread
3276                                                  * has already detected this
3277                                                  * condition
3278                                                  */
3279                                                 tpkt->pkt_state &=
3280                                                     ~STATE_ARQ_DONE;
3281                                                 *(tpkt->pkt_scbp) =
3282                                                     STATUS_BUSY;
3283                                                 break;
3284                                         }
3285                                         (void) taskq_dispatch(
3286                                             vhci->vhci_update_pathstates_taskq,
3287                                             vhci_update_pathstates,
3288                                             (void *)vlun, KM_SLEEP);
3289                                 } else {
3290                                         /*
3291                                          * externally initiated failover
3292                                          * has occurred or is in progress
3293                                          */
3294                                         VHCI_HOLD_LUN(vlun, VH_NOSLEEP, held);
3295                                         if (!held) {
3296                                                 /*
3297                                                  * looks like some other thread
3298                                                  * has already detected this
3299                                                  * condition
3300                                                  */
3301                                                 tpkt->pkt_state &=
3302                                                     ~STATE_ARQ_DONE;
3303                                                 *(tpkt->pkt_scbp) =
3304                                                     STATUS_BUSY;
3305                                                 break;
3306                                         } else {
3307                                                 rval = vhci_handle_ext_fo
3308                                                     (pkt, rval);
3309                                                 if (rval == BUSY_RETURN) {
3310                                                         tpkt->pkt_state &=
3311                                                             ~STATE_ARQ_DONE;
3312                                                         *(tpkt->pkt_scbp) =
3313                                                             STATUS_BUSY;
3314                                                         break;
3315                                                 }
3316                                                 bcopy(pkt->pkt_scbp,
3317                                                     tpkt->pkt_scbp,
3318                                                     vpkt->vpkt_tgt_init_scblen);
3319                                                 break;
3320                                         }
3321                                 }
3322                         }
3323                         break;
3324 
3325                 /*
3326                  * If this is a good SCSI-II RELEASE cmd completion then restore
3327                  * the load balancing policy and reset VLUN_RESERVE_ACTIVE_FLG.
3328                  * If this is a good SCSI-II RESERVE cmd completion then set
3329                  * VLUN_RESERVE_ACTIVE_FLG.
3330                  */
3331                 case STATUS_GOOD:
3332                         if ((pkt->pkt_cdbp[0] == SCMD_RELEASE) ||
3333                             (pkt->pkt_cdbp[0] == SCMD_RELEASE_G1)) {
3334                                 (void) mdi_set_lb_policy(vlun->svl_dip,
3335                                     vlun->svl_lb_policy_save);
3336                                 vlun->svl_flags &= ~VLUN_RESERVE_ACTIVE_FLG;
3337                                 VHCI_DEBUG(1, (CE_WARN, NULL,
3338                                     "!vhci_intr: vlun 0x%p release path 0x%p",
3339                                     (void *)vlun, (void *)vpkt->vpkt_path));
3340                         }
3341 
3342                         if ((pkt->pkt_cdbp[0] == SCMD_RESERVE) ||
3343                             (pkt->pkt_cdbp[0] == SCMD_RESERVE_G1)) {
3344                                 vlun->svl_flags |= VLUN_RESERVE_ACTIVE_FLG;
3345                                 vlun->svl_resrv_pip = vpkt->vpkt_path;
3346                                 VHCI_DEBUG(1, (CE_WARN, NULL,
3347                                     "!vhci_intr: vlun 0x%p reserved path 0x%p",
3348                                     (void *)vlun, (void *)vpkt->vpkt_path));
3349                         }
3350                         break;
3351 
3352                 case STATUS_RESERVATION_CONFLICT:
3353                         VHCI_DEBUG(1, (CE_WARN, NULL,
3354                             "!vhci_intr: vlun 0x%p "
3355                             "reserve conflict on path 0x%p",
3356                             (void *)vlun, (void *)vpkt->vpkt_path));
3357                         /* FALLTHROUGH */
3358                 default:
3359                         break;
3360                 }
3361 
3362                 /*
3363                  * Update I/O completion statistics for the path
3364                  */
3365                 mdi_pi_kstat_iosupdate(vpkt->vpkt_path, vpkt->vpkt_tgt_init_bp);
3366 
3367                 /*
3368                  * Command completed successfully, release the dma binding and
3369                  * destroy the transport side of the packet.
3370                  */
3371                 if ((pkt->pkt_cdbp[0] == SCMD_PROUT) &&
3372                     (((pkt->pkt_cdbp[1] & 0x1f) == VHCI_PROUT_REGISTER) ||
3373                     ((pkt->pkt_cdbp[1] & 0x1f) == VHCI_PROUT_R_AND_IGNORE))) {
3374                         if (SCBP_C(pkt) == STATUS_GOOD) {
3375                                 ASSERT(vlun->svl_taskq);
3376                                 svp->svp_last_pkt_reason = pkt->pkt_reason;
3377                                 (void) taskq_dispatch(vlun->svl_taskq,
3378                                     vhci_run_cmd, pkt, KM_SLEEP);
3379                                 return;
3380                         }
3381                 }
3382                 if ((SCBP_C(pkt) == STATUS_GOOD) &&
3383                     (pkt->pkt_cdbp[0] == SCMD_PRIN) && vpkt->vpkt_tgt_init_bp) {
3384                         /*
3385                          * If the action (value in byte 1 of the cdb) is zero,
3386                          * we're reading keys, and that's the only condition
3387                          * where we need to be concerned with filtering keys
3388                          * and potential retries.  Otherwise, we simply signal
3389                          * the semaphore and move on.
3390                          */
3391                         if (pkt->pkt_cdbp[1] == 0) {
3392                                 /*
3393                                  * If this is the completion of an internal
3394                                  * retry then we need to make sure that the
3395                                  * pkt and tpkt pointers are readjusted so
3396                                  * the calls to scsi_destroy_pkt and pkt_comp
3397                                  * below work * correctly.
3398                                  */
3399                                 if (vpkt->vpkt_org_vpkt != NULL) {
3400                                         pkt = vpkt->vpkt_org_vpkt->vpkt_hba_pkt;
3401                                         tpkt = vpkt->vpkt_org_vpkt->
3402                                             vpkt_tgt_pkt;
3403 
3404                                         /*
3405                                          * If this command was issued through
3406                                          * the taskq then we need to clear
3407                                          * this flag for proper processing in
3408                                          * the case of a retry from the target
3409                                          * driver.
3410                                          */
3411                                         vpkt->vpkt_state &=
3412                                             ~VHCI_PKT_THRU_TASKQ;
3413                                 }
3414 
3415                                 /*
3416                                  * if vhci_do_prin returns VHCI_CMD_CMPLT then
3417                                  * vpkt will contain the address of the
3418                                  * original vpkt
3419                                  */
3420                                 if (vhci_do_prin(&vpkt) == VHCI_CMD_RETRY) {
3421                                         /*
3422                                          * The command has been resent to get
3423                                          * all the keys from the device.  Don't
3424                                          * complete the command with ssd until
3425                                          * the retry completes.
3426                                          */
3427                                         return;
3428                                 }
3429                         } else {
3430                                 sema_v(&vlun->svl_pgr_sema);
3431                         }
3432                 }
3433 
3434                 break;
3435 
3436         case CMD_TIMEOUT:
3437                 if ((pkt->pkt_statistics &
3438                     (STAT_BUS_RESET|STAT_DEV_RESET|STAT_ABORTED)) == 0) {
3439 
3440                         VHCI_DEBUG(1, (CE_NOTE, NULL,
3441                             "!scsi vhci timeout invoked\n"));
3442 
3443                         (void) vhci_recovery_reset(vlun, &pkt->pkt_address,
3444                             FALSE, VHCI_DEPTH_ALL);
3445                 }
3446                 MDI_PI_ERRSTAT(lpath, MDI_PI_TRANSERR);
3447                 tpkt->pkt_statistics |= STAT_ABORTED;
3448                 err_str = timeout_err;
3449                 break;
3450 
3451         case CMD_TRAN_ERR:
3452                 /*
3453                  * This status is returned if the transport has sent the cmd
3454                  * down the link to the target and then some error occurs.
3455                  * In case of SCSI-II RESERVE cmd, we don't know if the
3456                  * reservation been accepted by the target or not, so we need
3457                  * to clear the reservation.
3458                  */
3459                 if ((pkt->pkt_cdbp[0] == SCMD_RESERVE) ||
3460                     (pkt->pkt_cdbp[0] == SCMD_RESERVE_G1)) {
3461                         VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_intr received"
3462                             " cmd_tran_err for scsi-2 reserve cmd\n"));
3463                         if (!vhci_recovery_reset(vlun, &pkt->pkt_address,
3464                             TRUE, VHCI_DEPTH_TARGET)) {
3465                                 VHCI_DEBUG(1, (CE_WARN, NULL,
3466                                     "!vhci_intr cmd_tran_err reset failed!"));
3467                         }
3468                 }
3469                 break;
3470 
3471         case CMD_DEV_GONE:
3472                 /*
3473                  * If this is the last path then report CMD_DEV_GONE to the
3474                  * target driver, otherwise report BUSY to triggger retry.
3475                  */
3476                 if (vlun->svl_dip &&
3477                     (mdi_client_get_path_count(vlun->svl_dip) <= 1)) {
3478                         struct scsi_vhci        *vhci;
3479                         vhci = ADDR2VHCI(&tpkt->pkt_address);
3480                         VHCI_DEBUG(1, (CE_NOTE, NULL, "vhci_intr received "
3481                             "cmd_dev_gone on last path\n"));
3482                         (void) vhci_invalidate_mpapi_lu(vhci, vlun);
3483                         break;
3484                 }
3485 
3486                 /* Report CMD_CMPLT-with-BUSY to cause retry. */
3487                 VHCI_DEBUG(1, (CE_NOTE, NULL, "vhci_intr received "
3488                     "cmd_dev_gone\n"));
3489                 tpkt->pkt_reason = CMD_CMPLT;
3490                 tpkt->pkt_state = STATE_GOT_BUS |
3491                     STATE_GOT_TARGET | STATE_SENT_CMD |
3492                     STATE_GOT_STATUS;
3493                 *(tpkt->pkt_scbp) = STATUS_BUSY;
3494                 break;
3495 
3496         default:
3497                 break;
3498         }
3499 
3500         /*
3501          * SCSI-II RESERVE cmd has been serviced by the lower layers clear
3502          * the flag so the lun is not QUIESCED any longer.
3503          * Also clear the VHCI_PKT_THRU_TASKQ flag, to ensure that if this pkt
3504          * is retried, a taskq shall again be dispatched to service it.  Else
3505          * it may lead to a system hang if the retry is within interrupt
3506          * context.
3507          */
3508         if ((pkt->pkt_cdbp[0] == SCMD_RESERVE) ||
3509             (pkt->pkt_cdbp[0] == SCMD_RESERVE_G1)) {
3510                 vlun->svl_flags &= ~VLUN_QUIESCED_FLG;
3511                 vpkt->vpkt_state &= ~VHCI_PKT_THRU_TASKQ;
3512         }
3513 
3514         /*
3515          * vpkt_org_vpkt should always be NULL here if the retry command
3516          * has been successfully processed.  If vpkt_org_vpkt != NULL at
3517          * this point, it is an error so restore the original vpkt and
3518          * return an error to the target driver so it can retry the
3519          * command as appropriate.
3520          */
3521         if (vpkt->vpkt_org_vpkt != NULL) {
3522                 struct vhci_pkt *new_vpkt = vpkt;
3523                 vpkt = vpkt->vpkt_org_vpkt;
3524 
3525                 vhci_scsi_destroy_pkt(&svp->svp_psd->sd_address,
3526                     new_vpkt->vpkt_tgt_pkt);
3527 
3528                 /*
3529                  * Mark this command completion as having an error so that
3530                  * ssd will retry the command.
3531                  */
3532                 vpkt->vpkt_tgt_pkt->pkt_reason = CMD_ABORTED;
3533                 vpkt->vpkt_tgt_pkt->pkt_statistics |= STAT_ABORTED;
3534 
3535                 pkt = vpkt->vpkt_hba_pkt;
3536                 tpkt = vpkt->vpkt_tgt_pkt;
3537         }
3538 
3539         if ((err_str != NULL) && (pkt->pkt_reason !=
3540             svp->svp_last_pkt_reason)) {
3541                 cdip = vlun->svl_dip;
3542                 vdip = ddi_get_parent(cdip);
3543                 cpath = kmem_alloc(MAXPATHLEN, KM_SLEEP);
3544                 vhci_log(CE_WARN, vdip, "!%s (%s%d): %s on path %s",
3545                     ddi_pathname(cdip, cpath), ddi_driver_name(cdip),
3546                     ddi_get_instance(cdip), err_str,
3547                     mdi_pi_spathname(vpkt->vpkt_path));
3548                 kmem_free(cpath, MAXPATHLEN);
3549         }
3550         svp->svp_last_pkt_reason = pkt->pkt_reason;
3551         VHCI_DECR_PATH_CMDCOUNT(svp);
3552 
3553         /*
3554          * For PARTIAL_DMA, vhci should not free the path.
3555          * Target driver will call into vhci_scsi_dmafree or
3556          * destroy pkt to release this path.
3557          */
3558         if ((vpkt->vpkt_flags & CFLAG_DMA_PARTIAL) == 0) {
3559                 scsi_destroy_pkt(pkt);
3560                 vpkt->vpkt_hba_pkt = NULL;
3561                 if (vpkt->vpkt_path) {
3562                         mdi_rele_path(vpkt->vpkt_path);
3563                         vpkt->vpkt_path = NULL;
3564                 }
3565         }
3566 
3567         scsi_hba_pkt_comp(tpkt);
3568 }
3569 
3570 /*
3571  * two possibilities: (1) failover has completed
3572  * or (2) is in progress; update our path states for
3573  * the former case; for the latter case,
3574  * initiate a scsi_watch request to
3575  * determine when failover completes - vlun is HELD
3576  * until failover completes; BUSY is returned to upper
3577  * layer in both the cases
3578  */
3579 static int
3580 vhci_handle_ext_fo(struct scsi_pkt *pkt, int fostat)
3581 {
3582         struct vhci_pkt         *vpkt = (struct vhci_pkt *)pkt->pkt_private;
3583         struct scsi_pkt         *tpkt;
3584         scsi_vhci_priv_t        *svp;
3585         scsi_vhci_lun_t         *vlun;
3586         struct scsi_vhci        *vhci;
3587         scsi_vhci_swarg_t       *swarg;
3588         char                    *path;
3589 
3590         ASSERT(vpkt != NULL);
3591         tpkt = vpkt->vpkt_tgt_pkt;
3592         ASSERT(tpkt != NULL);
3593         svp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(vpkt->vpkt_path);
3594         ASSERT(svp != NULL);
3595         vlun = svp->svp_svl;
3596         ASSERT(vlun != NULL);
3597         ASSERT(VHCI_LUN_IS_HELD(vlun));
3598 
3599         vhci = ADDR2VHCI(&tpkt->pkt_address);
3600 
3601         if (fostat == SCSI_SENSE_INACTIVE) {
3602                 VHCI_DEBUG(1, (CE_NOTE, NULL, "!Failover "
3603                     "detected for %s; updating path states...\n",
3604                     vlun->svl_lun_wwn));
3605                 /*
3606                  * set the vlun flag to indicate to the task that the target
3607                  * port group needs updating
3608                  */
3609                 vlun->svl_flags |= VLUN_UPDATE_TPG;
3610                 (void) taskq_dispatch(vhci->vhci_update_pathstates_taskq,
3611                     vhci_update_pathstates, (void *)vlun, KM_SLEEP);
3612         } else {
3613                 path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
3614                 vhci_log(CE_NOTE, ddi_get_parent(vlun->svl_dip),
3615                     "!%s (%s%d): Waiting for externally initiated failover "
3616                     "to complete", ddi_pathname(vlun->svl_dip, path),
3617                     ddi_driver_name(vlun->svl_dip),
3618                     ddi_get_instance(vlun->svl_dip));
3619                 kmem_free(path, MAXPATHLEN);
3620                 swarg = kmem_alloc(sizeof (*swarg), KM_NOSLEEP);
3621                 if (swarg == NULL) {
3622                         VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_handle_ext_fo: "
3623                             "request packet allocation for %s failed....\n",
3624                             vlun->svl_lun_wwn));
3625                         VHCI_RELEASE_LUN(vlun);
3626                         return (PKT_RETURN);
3627                 }
3628                 swarg->svs_svp = svp;
3629                 swarg->svs_tos = gethrtime();
3630                 swarg->svs_pi = vpkt->vpkt_path;
3631                 swarg->svs_release_lun = 0;
3632                 swarg->svs_done = 0;
3633                 /*
3634                  * place a hold on the path...we don't want it to
3635                  * vanish while scsi_watch is in progress
3636                  */
3637                 mdi_hold_path(vpkt->vpkt_path);
3638                 svp->svp_sw_token = scsi_watch_request_submit(svp->svp_psd,
3639                     VHCI_FOWATCH_INTERVAL, SENSE_LENGTH, vhci_efo_watch_cb,
3640                     (caddr_t)swarg);
3641         }
3642         return (BUSY_RETURN);
3643 }
3644 
3645 /*
3646  * vhci_efo_watch_cb:
3647  *      Callback from scsi_watch request to check the failover status.
3648  *      Completion is either due to successful failover or timeout.
3649  *      Upon successful completion, vhci_update_path_states is called.
3650  *      For timeout condition, vhci_efo_done is called.
3651  *      Always returns 0 to scsi_watch to keep retrying till vhci_efo_done
3652  *      terminates this request properly in a separate thread.
3653  */
3654 
3655 static int
3656 vhci_efo_watch_cb(caddr_t arg, struct scsi_watch_result *resultp)
3657 {
3658         struct scsi_status              *statusp = resultp->statusp;
3659         uint8_t                         *sensep = (uint8_t *)resultp->sensep;
3660         struct scsi_pkt                 *pkt = resultp->pkt;
3661         scsi_vhci_swarg_t               *swarg;
3662         scsi_vhci_priv_t                *svp;
3663         scsi_vhci_lun_t                 *vlun;
3664         struct scsi_vhci                *vhci;
3665         dev_info_t                      *vdip;
3666         int                             rval, updt_paths;
3667 
3668         swarg = (scsi_vhci_swarg_t *)(uintptr_t)arg;
3669         svp = swarg->svs_svp;
3670         if (swarg->svs_done) {
3671                 /*
3672                  * Already completed failover or timedout.
3673                  * Waiting for vhci_efo_done to terminate this scsi_watch.
3674                  */
3675                 return (0);
3676         }
3677 
3678         ASSERT(svp != NULL);
3679         vlun = svp->svp_svl;
3680         ASSERT(vlun != NULL);
3681         ASSERT(VHCI_LUN_IS_HELD(vlun));
3682         vlun->svl_efo_update_path = 0;
3683         vdip = ddi_get_parent(vlun->svl_dip);
3684         vhci = ddi_get_soft_state(vhci_softstate,
3685             ddi_get_instance(vdip));
3686 
3687         updt_paths = 0;
3688 
3689         if (pkt->pkt_reason != CMD_CMPLT) {
3690                 if ((gethrtime() - swarg->svs_tos) >= VHCI_EXTFO_TIMEOUT) {
3691                         swarg->svs_release_lun = 1;
3692                         goto done;
3693                 }
3694                 return (0);
3695         }
3696         if (*((unsigned char *)statusp) == STATUS_CHECK) {
3697                 rval = vlun->svl_fops->sfo_analyze_sense(svp->svp_psd, sensep,
3698                     vlun->svl_fops_ctpriv);
3699                 switch (rval) {
3700                         /*
3701                          * Only update path states in case path is definitely
3702                          * inactive, or no failover occurred.  For all other
3703                          * check conditions continue pinging.  A unexpected
3704                          * check condition shouldn't cause pinging to complete
3705                          * prematurely.
3706                          */
3707                         case SCSI_SENSE_INACTIVE:
3708                         case SCSI_SENSE_NOFAILOVER:
3709                                 updt_paths = 1;
3710                                 break;
3711                         default:
3712                                 if ((gethrtime() - swarg->svs_tos)
3713                                     >= VHCI_EXTFO_TIMEOUT) {
3714                                         swarg->svs_release_lun = 1;
3715                                         goto done;
3716                                 }
3717                                 return (0);
3718                 }
3719         } else if (*((unsigned char *)statusp) ==
3720             STATUS_RESERVATION_CONFLICT) {
3721                 updt_paths = 1;
3722         } else if ((*((unsigned char *)statusp)) &
3723             (STATUS_BUSY | STATUS_QFULL)) {
3724                 return (0);
3725         }
3726         if ((*((unsigned char *)statusp) == STATUS_GOOD) ||
3727             (updt_paths == 1)) {
3728                 /*
3729                  * we got here because we had detected an
3730                  * externally initiated failover; things
3731                  * have settled down now, so let's
3732                  * start up a task to update the
3733                  * path states and target port group
3734                  */
3735                 vlun->svl_efo_update_path = 1;
3736                 swarg->svs_done = 1;
3737                 vlun->svl_swarg = swarg;
3738                 vlun->svl_flags |= VLUN_UPDATE_TPG;
3739                 (void) taskq_dispatch(vhci->vhci_update_pathstates_taskq,
3740                     vhci_update_pathstates, (void *)vlun,
3741                     KM_SLEEP);
3742                 return (0);
3743         }
3744         if ((gethrtime() - swarg->svs_tos) >= VHCI_EXTFO_TIMEOUT) {
3745                 swarg->svs_release_lun = 1;
3746                 goto done;
3747         }
3748         return (0);
3749 done:
3750         swarg->svs_done = 1;
3751         (void) taskq_dispatch(vhci->vhci_taskq,
3752             vhci_efo_done, (void *)swarg, KM_SLEEP);
3753         return (0);
3754 }
3755 
3756 /*
3757  * vhci_efo_done:
3758  *      cleanly terminates scsi_watch and free up resources.
3759  *      Called as taskq function in vhci_efo_watch_cb for EFO timeout condition
3760  *      or by vhci_update_path_states invoked during external initiated
3761  *      failover completion.
3762  */
3763 static void
3764 vhci_efo_done(void *arg)
3765 {
3766         scsi_vhci_lun_t                 *vlun;
3767         scsi_vhci_swarg_t               *swarg = (scsi_vhci_swarg_t *)arg;
3768         scsi_vhci_priv_t                *svp = swarg->svs_svp;
3769         ASSERT(svp);
3770 
3771         vlun = svp->svp_svl;
3772         ASSERT(vlun);
3773 
3774         /* Wait for clean termination of scsi_watch */
3775         (void) scsi_watch_request_terminate(svp->svp_sw_token,
3776             SCSI_WATCH_TERMINATE_ALL_WAIT);
3777         svp->svp_sw_token = NULL;
3778 
3779         /* release path and freeup resources to indicate failover completion */
3780         mdi_rele_path(swarg->svs_pi);
3781         if (swarg->svs_release_lun) {
3782                 VHCI_RELEASE_LUN(vlun);
3783         }
3784         kmem_free((void *)swarg, sizeof (*swarg));
3785 }
3786 
3787 /*
3788  * Update the path states
3789  * vlun should be HELD when this is invoked.
3790  * Calls vhci_efo_done to cleanup resources allocated for EFO.
3791  */
3792 void
3793 vhci_update_pathstates(void *arg)
3794 {
3795         mdi_pathinfo_t                  *pip, *npip;
3796         dev_info_t                      *dip;
3797         struct scsi_failover_ops        *fo;
3798         struct scsi_vhci_priv           *svp;
3799         struct scsi_device              *psd;
3800         struct scsi_path_opinfo         opinfo;
3801         char                            *pclass, *tptr;
3802         struct scsi_vhci_lun            *vlun = (struct scsi_vhci_lun *)arg;
3803         int                             sps; /* mdi_select_path() status */
3804         char                            *cpath;
3805         struct scsi_vhci                *vhci;
3806         struct scsi_pkt                 *pkt;
3807         struct buf                      *bp;
3808         struct scsi_vhci_priv           *svp_conflict = NULL;
3809 
3810         ASSERT(VHCI_LUN_IS_HELD(vlun));
3811         dip  = vlun->svl_dip;
3812         pip = npip = NULL;
3813 
3814         vhci = ddi_get_soft_state(vhci_softstate,
3815             ddi_get_instance(ddi_get_parent(dip)));
3816 
3817         sps = mdi_select_path(dip, NULL, (MDI_SELECT_ONLINE_PATH |
3818             MDI_SELECT_STANDBY_PATH | MDI_SELECT_NO_PREFERRED), NULL, &npip);
3819         if ((npip == NULL) || (sps != MDI_SUCCESS)) {
3820                 goto done;
3821         }
3822 
3823         fo = vlun->svl_fops;
3824         do {
3825                 pip = npip;
3826                 svp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(pip);
3827                 psd = svp->svp_psd;
3828                 if (fo->sfo_path_get_opinfo(psd, &opinfo,
3829                     vlun->svl_fops_ctpriv) != 0) {
3830                         sps = mdi_select_path(dip, NULL,
3831                             (MDI_SELECT_ONLINE_PATH | MDI_SELECT_STANDBY_PATH |
3832                             MDI_SELECT_NO_PREFERRED), pip, &npip);
3833                         mdi_rele_path(pip);
3834                         continue;
3835                 }
3836 
3837                 if (mdi_prop_lookup_string(pip, "path-class", &pclass) !=
3838                     MDI_SUCCESS) {
3839                         VHCI_DEBUG(1, (CE_NOTE, NULL,
3840                             "!vhci_update_pathstates: prop lookup failed for "
3841                             "path 0x%p\n", (void *)pip));
3842                         sps = mdi_select_path(dip, NULL,
3843                             (MDI_SELECT_ONLINE_PATH | MDI_SELECT_STANDBY_PATH |
3844                             MDI_SELECT_NO_PREFERRED), pip, &npip);
3845                         mdi_rele_path(pip);
3846                         continue;
3847                 }
3848 
3849                 /*
3850                  * Need to update the "path-class" property
3851                  * value in the device tree if different
3852                  * from the existing value.
3853                  */
3854                 if (strcmp(pclass, opinfo.opinfo_path_attr) != 0) {
3855                         (void) mdi_prop_update_string(pip, "path-class",
3856                             opinfo.opinfo_path_attr);
3857                 }
3858 
3859                 /*
3860                  * Only change the state if needed. i.e. Don't call
3861                  * mdi_pi_set_state to ONLINE a path if its already
3862                  * ONLINE. Same for STANDBY paths.
3863                  */
3864 
3865                 if ((opinfo.opinfo_path_state == SCSI_PATH_ACTIVE ||
3866                     opinfo.opinfo_path_state == SCSI_PATH_ACTIVE_NONOPT)) {
3867                         if (!(MDI_PI_IS_ONLINE(pip))) {
3868                                 VHCI_DEBUG(1, (CE_NOTE, NULL,
3869                                     "!vhci_update_pathstates: marking path"
3870                                     " 0x%p as ONLINE\n", (void *)pip));
3871                                 cpath = kmem_alloc(MAXPATHLEN, KM_SLEEP);
3872                                 vhci_log(CE_NOTE, ddi_get_parent(dip), "!%s "
3873                                     "(%s%d): path %s "
3874                                     "is now ONLINE because of "
3875                                     "an externally initiated failover",
3876                                     ddi_pathname(dip, cpath),
3877                                     ddi_driver_name(dip),
3878                                     ddi_get_instance(dip),
3879                                     mdi_pi_spathname(pip));
3880                                 kmem_free(cpath, MAXPATHLEN);
3881                                 mdi_pi_set_state(pip,
3882                                     MDI_PATHINFO_STATE_ONLINE);
3883                                 mdi_pi_set_preferred(pip,
3884                                     opinfo.opinfo_preferred);
3885                                 tptr = kmem_alloc(strlen
3886                                     (opinfo.opinfo_path_attr)+1, KM_SLEEP);
3887                                 (void) strlcpy(tptr, opinfo.opinfo_path_attr,
3888                                     (strlen(opinfo.opinfo_path_attr)+1));
3889                                 mutex_enter(&vlun->svl_mutex);
3890                                 if (vlun->svl_active_pclass != NULL) {
3891                                         kmem_free(vlun->svl_active_pclass,
3892                                             strlen(vlun->svl_active_pclass)+1);
3893                                 }
3894                                 vlun->svl_active_pclass = tptr;
3895                                 if (vlun->svl_waiting_for_activepath) {
3896                                         vlun->svl_waiting_for_activepath = 0;
3897                                 }
3898                                 mutex_exit(&vlun->svl_mutex);
3899                         } else if (MDI_PI_IS_ONLINE(pip)) {
3900                                 if (strcmp(pclass, opinfo.opinfo_path_attr)
3901                                     != 0) {
3902                                         mdi_pi_set_preferred(pip,
3903                                             opinfo.opinfo_preferred);
3904                                         mutex_enter(&vlun->svl_mutex);
3905                                         if (vlun->svl_active_pclass == NULL ||
3906                                             strcmp(opinfo.opinfo_path_attr,
3907                                             vlun->svl_active_pclass) != 0) {
3908                                                 mutex_exit(&vlun->svl_mutex);
3909                                                 tptr = kmem_alloc(strlen
3910                                                     (opinfo.opinfo_path_attr)+1,
3911                                                     KM_SLEEP);
3912                                                 (void) strlcpy(tptr,
3913                                                     opinfo.opinfo_path_attr,
3914                                                     (strlen
3915                                                     (opinfo.opinfo_path_attr)
3916                                                     +1));
3917                                                 mutex_enter(&vlun->svl_mutex);
3918                                         } else {
3919                                                 /*
3920                                                  * No need to update
3921                                                  * svl_active_pclass
3922                                                  */
3923                                                 tptr = NULL;
3924                                                 mutex_exit(&vlun->svl_mutex);
3925                                         }
3926                                         if (tptr) {
3927                                                 if (vlun->svl_active_pclass
3928                                                     != NULL) {
3929                                                         kmem_free(vlun->
3930                                                             svl_active_pclass,
3931                                                             strlen(vlun->
3932                                                             svl_active_pclass)
3933                                                             +1);
3934                                                 }
3935                                                 vlun->svl_active_pclass = tptr;
3936                                                 mutex_exit(&vlun->svl_mutex);
3937                                         }
3938                                 }
3939                         }
3940 
3941                         /* Check for Reservation Conflict */
3942                         bp = scsi_alloc_consistent_buf(
3943                             &svp->svp_psd->sd_address, (struct buf *)NULL,
3944                             DEV_BSIZE, B_READ, NULL, NULL);
3945                         if (!bp) {
3946                                 VHCI_DEBUG(1, (CE_NOTE, NULL,
3947                                     "!vhci_update_pathstates: No resources "
3948                                     "(buf)\n"));
3949                                 mdi_rele_path(pip);
3950                                 goto done;
3951                         }
3952                         pkt = scsi_init_pkt(&svp->svp_psd->sd_address, NULL, bp,
3953                             CDB_GROUP1, sizeof (struct scsi_arq_status), 0,
3954                             PKT_CONSISTENT, NULL, NULL);
3955                         if (pkt) {
3956                                 (void) scsi_setup_cdb((union scsi_cdb *)
3957                                     (uintptr_t)pkt->pkt_cdbp, SCMD_READ, 1, 1,
3958                                     0);
3959                                 pkt->pkt_time = 3*30;
3960                                 pkt->pkt_flags = FLAG_NOINTR;
3961                                 pkt->pkt_path_instance =
3962                                     mdi_pi_get_path_instance(pip);
3963 
3964                                 if ((scsi_transport(pkt) == TRAN_ACCEPT) &&
3965                                     (pkt->pkt_reason == CMD_CMPLT) &&
3966                                     (SCBP_C(pkt) ==
3967                                     STATUS_RESERVATION_CONFLICT)) {
3968                                         VHCI_DEBUG(1, (CE_NOTE, NULL,
3969                                             "!vhci_update_pathstates: reserv. "
3970                                             "conflict to be resolved on 0x%p\n",
3971                                             (void *)pip));
3972                                         svp_conflict = svp;
3973                                 }
3974                                 scsi_destroy_pkt(pkt);
3975                         }
3976                         scsi_free_consistent_buf(bp);
3977                 } else if ((opinfo.opinfo_path_state == SCSI_PATH_INACTIVE) &&
3978                     !(MDI_PI_IS_STANDBY(pip))) {
3979                         VHCI_DEBUG(1, (CE_NOTE, NULL,
3980                             "!vhci_update_pathstates: marking path"
3981                             " 0x%p as STANDBY\n", (void *)pip));
3982                         cpath = kmem_alloc(MAXPATHLEN, KM_SLEEP);
3983                         vhci_log(CE_NOTE, ddi_get_parent(dip), "!%s "
3984                             "(%s%d): path %s "
3985                             "is now STANDBY because of "
3986                             "an externally initiated failover",
3987                             ddi_pathname(dip, cpath),
3988                             ddi_driver_name(dip),
3989                             ddi_get_instance(dip),
3990                             mdi_pi_spathname(pip));
3991                         kmem_free(cpath, MAXPATHLEN);
3992                         mdi_pi_set_state(pip,
3993                             MDI_PATHINFO_STATE_STANDBY);
3994                         mdi_pi_set_preferred(pip,
3995                             opinfo.opinfo_preferred);
3996                         mutex_enter(&vlun->svl_mutex);
3997                         if (vlun->svl_active_pclass != NULL) {
3998                                 if (strcmp(vlun->svl_active_pclass,
3999                                     opinfo.opinfo_path_attr) == 0) {
4000                                         kmem_free(vlun->
4001                                             svl_active_pclass,
4002                                             strlen(vlun->
4003                                             svl_active_pclass)+1);
4004                                         vlun->svl_active_pclass = NULL;
4005                                 }
4006                         }
4007                         mutex_exit(&vlun->svl_mutex);
4008                 }
4009                 (void) mdi_prop_free(pclass);
4010                 sps = mdi_select_path(dip, NULL,
4011                     (MDI_SELECT_ONLINE_PATH | MDI_SELECT_STANDBY_PATH |
4012                     MDI_SELECT_NO_PREFERRED), pip, &npip);
4013                 mdi_rele_path(pip);
4014 
4015         } while ((npip != NULL) && (sps == MDI_SUCCESS));
4016 
4017         /*
4018          * Check to see if this vlun has an active SCSI-II RESERVE.  If so
4019          * clear the reservation by sending a reset, so the host doesn't
4020          * receive a reservation conflict.  The reset has to be sent via a
4021          * working path.  Let's use a path referred to by svp_conflict as it
4022          * should be working.
4023          * Reset VLUN_RESERVE_ACTIVE_FLG for this vlun.  Also notify ssd
4024          * of the reset, explicitly.
4025          */
4026         if (vlun->svl_flags & VLUN_RESERVE_ACTIVE_FLG) {
4027                 if (svp_conflict && (vlun->svl_xlf_capable == 0)) {
4028                         VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_update_pathstates:"
4029                             " sending recovery reset on 0x%p, path_state: %x",
4030                             svp_conflict->svp_psd->sd_private,
4031                             mdi_pi_get_state((mdi_pathinfo_t *)
4032                             svp_conflict->svp_psd->sd_private)));
4033 
4034                         (void) vhci_recovery_reset(vlun,
4035                             &svp_conflict->svp_psd->sd_address, FALSE,
4036                             VHCI_DEPTH_TARGET);
4037                 }
4038                 vlun->svl_flags &= ~VLUN_RESERVE_ACTIVE_FLG;
4039                 mutex_enter(&vhci->vhci_mutex);
4040                 scsi_hba_reset_notify_callback(&vhci->vhci_mutex,
4041                     &vhci->vhci_reset_notify_listf);
4042                 mutex_exit(&vhci->vhci_mutex);
4043         }
4044         if (vlun->svl_flags & VLUN_UPDATE_TPG) {
4045                 /*
4046                  * Update the AccessState of related MP-API TPGs
4047                  */
4048                 (void) vhci_mpapi_update_tpg_acc_state_for_lu(vhci, vlun);
4049                 vlun->svl_flags &= ~VLUN_UPDATE_TPG;
4050         }
4051 done:
4052         if (vlun->svl_efo_update_path) {
4053                 vlun->svl_efo_update_path = 0;
4054                 vhci_efo_done(vlun->svl_swarg);
4055                 vlun->svl_swarg = 0;
4056         }
4057         VHCI_RELEASE_LUN(vlun);
4058 }
4059 
4060 /* ARGSUSED */
4061 static int
4062 vhci_pathinfo_init(dev_info_t *vdip, mdi_pathinfo_t *pip, int flags)
4063 {
4064         scsi_hba_tran_t         *hba = NULL;
4065         struct scsi_device      *psd = NULL;
4066         scsi_vhci_lun_t         *vlun = NULL;
4067         dev_info_t              *pdip = NULL;
4068         dev_info_t              *tgt_dip;
4069         struct scsi_vhci        *vhci;
4070         char                    *guid;
4071         scsi_vhci_priv_t        *svp = NULL;
4072         int                     rval = MDI_FAILURE;
4073         int                     vlun_alloced = 0;
4074 
4075         ASSERT(vdip != NULL);
4076         ASSERT(pip != NULL);
4077 
4078         vhci = ddi_get_soft_state(vhci_softstate, ddi_get_instance(vdip));
4079         ASSERT(vhci != NULL);
4080 
4081         pdip = mdi_pi_get_phci(pip);
4082         ASSERT(pdip != NULL);
4083 
4084         hba = ddi_get_driver_private(pdip);
4085         ASSERT(hba != NULL);
4086 
4087         tgt_dip = mdi_pi_get_client(pip);
4088         ASSERT(tgt_dip != NULL);
4089 
4090         if (ddi_prop_lookup_string(DDI_DEV_T_ANY, tgt_dip, PROPFLAGS,
4091             MDI_CLIENT_GUID_PROP, &guid) != DDI_SUCCESS) {
4092                 VHCI_DEBUG(1, (CE_WARN, NULL,
4093                     "vhci_pathinfo_init: lun guid property failed"));
4094                 goto failure;
4095         }
4096 
4097         vlun = vhci_lun_lookup_alloc(tgt_dip, guid, &vlun_alloced);
4098         ddi_prop_free(guid);
4099 
4100         vlun->svl_dip = tgt_dip;
4101 
4102         svp = kmem_zalloc(sizeof (*svp), KM_SLEEP);
4103         svp->svp_svl = vlun;
4104 
4105         /*
4106          * Initialize svl_lb_policy_save only for newly allocated vlun. Writing
4107          * to svl_lb_policy_save later could accidentally overwrite saved lb
4108          * policy.
4109          */
4110         if (vlun_alloced) {
4111                 vlun->svl_lb_policy_save = mdi_get_lb_policy(tgt_dip);
4112         }
4113 
4114         mutex_init(&svp->svp_mutex, NULL, MUTEX_DRIVER, NULL);
4115         cv_init(&svp->svp_cv, NULL, CV_DRIVER, NULL);
4116 
4117         psd = kmem_zalloc(sizeof (*psd), KM_SLEEP);
4118         mutex_init(&psd->sd_mutex, NULL, MUTEX_DRIVER, NULL);
4119 
4120         if (hba->tran_hba_flags & SCSI_HBA_ADDR_COMPLEX) {
4121                 /*
4122                  * For a SCSI_HBA_ADDR_COMPLEX transport we store a pointer to
4123                  * scsi_device in the scsi_address structure.  This allows an
4124                  * an HBA driver to find its scsi_device(9S) and
4125                  * per-scsi_device(9S) HBA private data given a
4126                  * scsi_address(9S) by using scsi_address_device(9F) and
4127                  * scsi_device_hba_private_get(9F)).
4128                  */
4129                 psd->sd_address.a.a_sd = psd;
4130         } else if (hba->tran_hba_flags & SCSI_HBA_TRAN_CLONE) {
4131                 /*
4132                  * Clone transport structure if requested, so
4133                  * Self enumerating HBAs always need to use cloning
4134                  */
4135                 scsi_hba_tran_t *clone =
4136                     kmem_alloc(sizeof (scsi_hba_tran_t), KM_SLEEP);
4137                 bcopy(hba, clone, sizeof (scsi_hba_tran_t));
4138                 hba = clone;
4139                 hba->tran_sd = psd;
4140         } else {
4141                 /*
4142                  * SPI pHCI unit-address. If we ever need to support this
4143                  * we could set a.spi.a_target/a.spi.a_lun based on pathinfo
4144                  * node unit-address properties.  For now we fail...
4145                  */
4146                 goto failure;
4147         }
4148 
4149         psd->sd_dev = tgt_dip;
4150         psd->sd_address.a_hba_tran = hba;
4151 
4152         /*
4153          * Mark scsi_device as being associated with a pathinfo node. For
4154          * a scsi_device structure associated with a devinfo node,
4155          * scsi_ctlops_initchild sets this field to NULL.
4156          */
4157         psd->sd_pathinfo = pip;
4158 
4159         /*
4160          * LEGACY: sd_private: set for older mpxio-capable pHCI drivers with
4161          * too much scsi_vhci/mdi/ndi knowledge. Remove this code when all
4162          * mpxio-capable pHCI drivers use SCSA enumeration services (or at
4163          * least have been changed to use sd_pathinfo instead).
4164          */
4165         psd->sd_private = (caddr_t)pip;
4166 
4167         /* See scsi_hba.c for info on sd_tran_safe kludge */
4168         psd->sd_tran_safe = hba;
4169 
4170         svp->svp_psd = psd;
4171         mdi_pi_set_vhci_private(pip, (caddr_t)svp);
4172 
4173         /*
4174          * call hba's target init entry point if it exists
4175          */
4176         if (hba->tran_tgt_init != NULL) {
4177                 psd->sd_tran_tgt_free_done = 0;
4178                 if ((rval = (*hba->tran_tgt_init)(pdip, tgt_dip,
4179                     hba, psd)) != DDI_SUCCESS) {
4180                         VHCI_DEBUG(1, (CE_WARN, pdip,
4181                             "!vhci_pathinfo_init: tran_tgt_init failed for "
4182                             "path=0x%p rval=%x", (void *)pip, rval));
4183                         goto failure;
4184                 }
4185         }
4186 
4187         svp->svp_new_path = 1;
4188 
4189         VHCI_DEBUG(4, (CE_NOTE, NULL, "!vhci_pathinfo_init: path:%p\n",
4190             (void *)pip));
4191         return (MDI_SUCCESS);
4192 
4193 failure:
4194         if (psd) {
4195                 mutex_destroy(&psd->sd_mutex);
4196                 kmem_free(psd, sizeof (*psd));
4197         }
4198         if (svp) {
4199                 mdi_pi_set_vhci_private(pip, NULL);
4200                 mutex_destroy(&svp->svp_mutex);
4201                 cv_destroy(&svp->svp_cv);
4202                 kmem_free(svp, sizeof (*svp));
4203         }
4204         if (hba && (hba->tran_hba_flags & SCSI_HBA_TRAN_CLONE))
4205                 kmem_free(hba, sizeof (scsi_hba_tran_t));
4206 
4207         if (vlun_alloced)
4208                 vhci_lun_free(vlun, NULL);
4209 
4210         return (rval);
4211 }
4212 
4213 /* ARGSUSED */
4214 static int
4215 vhci_pathinfo_uninit(dev_info_t *vdip, mdi_pathinfo_t *pip, int flags)
4216 {
4217         scsi_hba_tran_t         *hba = NULL;
4218         struct scsi_device      *psd = NULL;
4219         dev_info_t              *pdip = NULL;
4220         dev_info_t              *cdip = NULL;
4221         scsi_vhci_priv_t        *svp = NULL;
4222 
4223         ASSERT(vdip != NULL);
4224         ASSERT(pip != NULL);
4225 
4226         pdip = mdi_pi_get_phci(pip);
4227         ASSERT(pdip != NULL);
4228 
4229         cdip = mdi_pi_get_client(pip);
4230         ASSERT(cdip != NULL);
4231 
4232         hba = ddi_get_driver_private(pdip);
4233         ASSERT(hba != NULL);
4234 
4235         vhci_mpapi_set_path_state(vdip, pip, MP_DRVR_PATH_STATE_UNINIT);
4236         svp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(pip);
4237         if (svp == NULL) {
4238                 /* path already freed. Nothing to do. */
4239                 return (MDI_SUCCESS);
4240         }
4241 
4242         psd = svp->svp_psd;
4243         ASSERT(psd != NULL);
4244 
4245         if (hba->tran_hba_flags & SCSI_HBA_ADDR_COMPLEX) {
4246                 /* Verify plumbing */
4247                 ASSERT(psd->sd_address.a_hba_tran == hba);
4248                 ASSERT(psd->sd_address.a.a_sd == psd);
4249         } else if (hba->tran_hba_flags & SCSI_HBA_TRAN_CLONE) {
4250                 /* Switch to cloned scsi_hba_tran(9S) structure */
4251                 hba = psd->sd_address.a_hba_tran;
4252                 ASSERT(hba->tran_hba_flags & SCSI_HBA_TRAN_CLONE);
4253                 ASSERT(hba->tran_sd == psd);
4254         }
4255 
4256         if ((hba->tran_tgt_free != NULL) && !psd->sd_tran_tgt_free_done) {
4257                 (*hba->tran_tgt_free) (pdip, cdip, hba, psd);
4258                 psd->sd_tran_tgt_free_done = 1;
4259         }
4260         mutex_destroy(&psd->sd_mutex);
4261         if (hba->tran_hba_flags & SCSI_HBA_TRAN_CLONE) {
4262                 kmem_free(hba, sizeof (*hba));
4263         }
4264 
4265         mdi_pi_set_vhci_private(pip, NULL);
4266 
4267         /*
4268          * Free the pathinfo related scsi_device inquiry data. Note that this
4269          * matches what happens for scsi_hba.c devinfo case at uninitchild time.
4270          */
4271         if (psd->sd_inq)
4272                 kmem_free((caddr_t)psd->sd_inq, sizeof (struct scsi_inquiry));
4273         kmem_free((caddr_t)psd, sizeof (*psd));
4274 
4275         mutex_destroy(&svp->svp_mutex);
4276         cv_destroy(&svp->svp_cv);
4277         kmem_free((caddr_t)svp, sizeof (*svp));
4278 
4279         VHCI_DEBUG(4, (CE_NOTE, NULL, "!vhci_pathinfo_uninit: path=0x%p\n",
4280             (void *)pip));
4281         return (MDI_SUCCESS);
4282 }
4283 
4284 /* ARGSUSED */
4285 static int
4286 vhci_pathinfo_state_change(dev_info_t *vdip, mdi_pathinfo_t *pip,
4287     mdi_pathinfo_state_t state, uint32_t ext_state, int flags)
4288 {
4289         int                     rval = MDI_SUCCESS;
4290         scsi_vhci_priv_t        *svp;
4291         scsi_vhci_lun_t         *vlun;
4292         int                     held;
4293         int                     op = (flags & 0xf00) >> 8;
4294         struct scsi_vhci        *vhci;
4295 
4296         vhci = ddi_get_soft_state(vhci_softstate, ddi_get_instance(vdip));
4297 
4298         if (flags & MDI_EXT_STATE_CHANGE) {
4299                 /*
4300                  * We do not want to issue any commands down the path in case
4301                  * sync flag is set. Lower layers might not be ready to accept
4302                  * any I/O commands.
4303                  */
4304                 if (op == DRIVER_DISABLE)
4305                         return (MDI_SUCCESS);
4306 
4307                 svp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(pip);
4308                 if (svp == NULL) {
4309                         return (MDI_FAILURE);
4310                 }
4311                 vlun = svp->svp_svl;
4312 
4313                 if (flags & MDI_BEFORE_STATE_CHANGE) {
4314                         /*
4315                          * Hold the LUN.
4316                          */
4317                         VHCI_HOLD_LUN(vlun, VH_SLEEP, held);
4318                         if (flags & MDI_DISABLE_OP)  {
4319                                 /*
4320                                  * Issue scsi reset if it happens to be
4321                                  * reserved path.
4322                                  */
4323                                 if (vlun->svl_flags & VLUN_RESERVE_ACTIVE_FLG) {
4324                                         /*
4325                                          * if reservation pending on
4326                                          * this path, dont' mark the
4327                                          * path busy
4328                                          */
4329                                         if (op == DRIVER_DISABLE_TRANSIENT) {
4330                                                 VHCI_DEBUG(1, (CE_NOTE, NULL,
4331                                                     "!vhci_pathinfo"
4332                                                     "_state_change (pip:%p): "
4333                                                     " reservation: fail busy\n",
4334                                                     (void *)pip));
4335                                                 return (MDI_FAILURE);
4336                                         }
4337                                         if (pip == vlun->svl_resrv_pip) {
4338                                                 if (vhci_recovery_reset(
4339                                                     svp->svp_svl,
4340                                                     &svp->svp_psd->sd_address,
4341                                                     TRUE,
4342                                                     VHCI_DEPTH_TARGET) == 0) {
4343                                                         VHCI_DEBUG(1,
4344                                                             (CE_NOTE, NULL,
4345                                                             "!vhci_pathinfo"
4346                                                             "_state_change "
4347                                                             " (pip:%p): "
4348                                                             "reset failed, "
4349                                                             "give up!\n",
4350                                                             (void *)pip));
4351                                                 }
4352                                                 vlun->svl_flags &=
4353                                                     ~VLUN_RESERVE_ACTIVE_FLG;
4354                                         }
4355                                 }
4356                         } else if (flags & MDI_ENABLE_OP)  {
4357                                 if (((vhci->vhci_conf_flags &
4358                                     VHCI_CONF_FLAGS_AUTO_FAILBACK) ==
4359                                     VHCI_CONF_FLAGS_AUTO_FAILBACK) &&
4360                                     MDI_PI_IS_USER_DISABLE(pip) &&
4361                                     MDI_PI_IS_STANDBY(pip)) {
4362                                         struct scsi_failover_ops        *fo;
4363                                         char *best_pclass, *pclass = NULL;
4364                                         int  best_class, rv;
4365                                         /*
4366                                          * Failback if enabling a standby path
4367                                          * and it is the primary class or
4368                                          * preferred class
4369                                          */
4370                                         best_class = mdi_pi_get_preferred(pip);
4371                                         if (best_class == 0) {
4372                                                 /*
4373                                                  * if not preferred - compare
4374                                                  * path-class with class
4375                                                  */
4376                                                 fo = vlun->svl_fops;
4377                                                 (void) fo->sfo_pathclass_next(
4378                                                     NULL, &best_pclass,
4379                                                     vlun->svl_fops_ctpriv);
4380                                                 pclass = NULL;
4381                                                 rv = mdi_prop_lookup_string(pip,
4382                                                     "path-class", &pclass);
4383                                                 if (rv != MDI_SUCCESS ||
4384                                                     pclass == NULL) {
4385                                                         vhci_log(CE_NOTE, vdip,
4386                                                             "!path-class "
4387                                                             " lookup "
4388                                                             "failed. rv: %d"
4389                                                             "class: %p", rv,
4390                                                             (void *)pclass);
4391                                                 } else if (strncmp(pclass,
4392                                                     best_pclass,
4393                                                     strlen(best_pclass)) == 0) {
4394                                                         best_class = 1;
4395                                                 }
4396                                                 if (rv == MDI_SUCCESS &&
4397                                                     pclass != NULL) {
4398                                                         rv = mdi_prop_free(
4399                                                             pclass);
4400                                                         if (rv !=
4401                                                             DDI_PROP_SUCCESS) {
4402                                                                 vhci_log(
4403                                                                     CE_NOTE,
4404                                                                     vdip,
4405                                                                     "!path-"
4406                                                                     "class"
4407                                                                     " free"
4408                                                                     " failed"
4409                                                                     " rv: %d"
4410                                                                     " class: "
4411                                                                     "%p",
4412                                                                     rv,
4413                                                                     (void *)
4414                                                                     pclass);
4415                                                         }
4416                                                 }
4417                                         }
4418                                         if (best_class == 1) {
4419                                                 VHCI_DEBUG(1, (CE_NOTE, NULL,
4420                                                     "preferred path: %p "
4421                                                     "USER_DISABLE->USER_ENABLE "
4422                                                     "transition for lun %s\n",
4423                                                     (void *)pip,
4424                                                     vlun->svl_lun_wwn));
4425                                                 (void) taskq_dispatch(
4426                                                     vhci->vhci_taskq,
4427                                                     vhci_initiate_auto_failback,
4428                                                     (void *) vlun, KM_SLEEP);
4429                                         }
4430                                 }
4431                                 /*
4432                                  * if PGR is active, revalidate key and
4433                                  * register on this path also, if key is
4434                                  * still valid
4435                                  */
4436                                 sema_p(&vlun->svl_pgr_sema);
4437                                 if (vlun->svl_pgr_active)
4438                                         (void)
4439                                             vhci_pgr_validate_and_register(svp);
4440                                 sema_v(&vlun->svl_pgr_sema);
4441                                 /*
4442                                  * Inform target driver about any
4443                                  * reservations to be reinstated if target
4444                                  * has dropped reservation during the busy
4445                                  * period.
4446                                  */
4447                                 mutex_enter(&vhci->vhci_mutex);
4448                                 scsi_hba_reset_notify_callback(
4449                                     &vhci->vhci_mutex,
4450                                     &vhci->vhci_reset_notify_listf);
4451                                 mutex_exit(&vhci->vhci_mutex);
4452                         }
4453                 }
4454                 if (flags & MDI_AFTER_STATE_CHANGE) {
4455                         if (flags & MDI_ENABLE_OP)  {
4456                                 mutex_enter(&vhci_global_mutex);
4457                                 cv_broadcast(&vhci_cv);
4458                                 mutex_exit(&vhci_global_mutex);
4459                         }
4460                         if (vlun->svl_setcap_done) {
4461                                 (void) vhci_pHCI_cap(&svp->svp_psd->sd_address,
4462                                     "sector-size", vlun->svl_sector_size,
4463                                     1, pip);
4464                         }
4465 
4466                         /*
4467                          * Release the LUN
4468                          */
4469                         VHCI_RELEASE_LUN(vlun);
4470 
4471                         /*
4472                          * Path transition is complete.
4473                          * Run callback to indicate target driver to
4474                          * retry to prevent IO starvation.
4475                          */
4476                         if (scsi_callback_id != 0) {
4477                                 ddi_run_callback(&scsi_callback_id);
4478                         }
4479                 }
4480         } else {
4481                 switch (state) {
4482                 case MDI_PATHINFO_STATE_ONLINE:
4483                         rval = vhci_pathinfo_online(vdip, pip, flags);
4484                         break;
4485 
4486                 case MDI_PATHINFO_STATE_OFFLINE:
4487                         rval = vhci_pathinfo_offline(vdip, pip, flags);
4488                         break;
4489 
4490                 default:
4491                         break;
4492                 }
4493                 /*
4494                  * Path transition is complete.
4495                  * Run callback to indicate target driver to
4496                  * retry to prevent IO starvation.
4497                  */
4498                 if ((rval == MDI_SUCCESS) && (scsi_callback_id != 0)) {
4499                         ddi_run_callback(&scsi_callback_id);
4500                 }
4501                 return (rval);
4502         }
4503 
4504         return (MDI_SUCCESS);
4505 }
4506 
4507 /*
4508  * Parse the mpxio load balancing options. The datanameptr
4509  * will point to a string containing the load-balance-options value.
4510  * The load-balance-options value will be a property that
4511  * defines the load-balance algorithm and any arguments to that
4512  * algorithm.
4513  * For example:
4514  * device-type-mpxio-options-list=
4515  * "device-type=SUN    SENA", "load-balance-options=logical-block-options"
4516  * "device-type=SUN     SE6920", "round-robin-options";
4517  * logical-block-options="load-balance=logical-block", "region-size=15";
4518  * round-robin-options="load-balance=round-robin";
4519  *
4520  * If the load-balance is not defined the load balance algorithm will
4521  * default to the global setting. There will be default values assigned
4522  * to the arguments (region-size=18) and if an argument is one
4523  * that is not known, it will be ignored.
4524  */
4525 static void
4526 vhci_parse_mpxio_lb_options(dev_info_t *dip, dev_info_t *cdip,
4527         caddr_t datanameptr)
4528 {
4529         char                    *dataptr, *next_entry;
4530         caddr_t                 config_list     = NULL;
4531         int                     config_list_len = 0, list_len = 0;
4532         int                     region_size = -1;
4533         client_lb_t             load_balance;
4534 
4535         if (ddi_getlongprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, datanameptr,
4536             (caddr_t)&config_list, &config_list_len) != DDI_PROP_SUCCESS) {
4537                 return;
4538         }
4539 
4540         list_len = config_list_len;
4541         next_entry = config_list;
4542         while (config_list_len > 0) {
4543                 dataptr = next_entry;
4544 
4545                 if (strncmp(mdi_load_balance, dataptr,
4546                     strlen(mdi_load_balance)) == 0) {
4547                         /* get the load-balance scheme */
4548                         dataptr += strlen(mdi_load_balance) + 1;
4549                         if (strcmp(dataptr, LOAD_BALANCE_PROP_RR) == 0) {
4550                                 (void) mdi_set_lb_policy(cdip, LOAD_BALANCE_RR);
4551                                 load_balance = LOAD_BALANCE_RR;
4552                         } else if (strcmp(dataptr,
4553                             LOAD_BALANCE_PROP_LBA) == 0) {
4554                                 (void) mdi_set_lb_policy(cdip,
4555                                     LOAD_BALANCE_LBA);
4556                                 load_balance = LOAD_BALANCE_LBA;
4557                         } else if (strcmp(dataptr,
4558                             LOAD_BALANCE_PROP_NONE) == 0) {
4559                                 (void) mdi_set_lb_policy(cdip,
4560                                     LOAD_BALANCE_NONE);
4561                                 load_balance = LOAD_BALANCE_NONE;
4562                         }
4563                 } else if (strncmp(dataptr, LOGICAL_BLOCK_REGION_SIZE,
4564                     strlen(LOGICAL_BLOCK_REGION_SIZE)) == 0) {
4565                         int     i = 0;
4566                         char    *ptr;
4567                         char    *tmp;
4568 
4569                         tmp = dataptr + (strlen(LOGICAL_BLOCK_REGION_SIZE) + 1);
4570                         /* check for numeric value */
4571                         for (ptr = tmp; i < strlen(tmp); i++, ptr++) {
4572                                 if (!isdigit(*ptr)) {
4573                                         cmn_err(CE_WARN,
4574                                             "Illegal region size: %s."
4575                                             " Setting to default value: %d",
4576                                             tmp,
4577                                             LOAD_BALANCE_DEFAULT_REGION_SIZE);
4578                                         region_size =
4579                                             LOAD_BALANCE_DEFAULT_REGION_SIZE;
4580                                         break;
4581                                 }
4582                         }
4583                         if (i >= strlen(tmp)) {
4584                                 region_size = stoi(&tmp);
4585                         }
4586                         (void) mdi_set_lb_region_size(cdip, region_size);
4587                 }
4588                 config_list_len -= (strlen(next_entry) + 1);
4589                 next_entry += strlen(next_entry) + 1;
4590         }
4591 #ifdef DEBUG
4592         if ((region_size >= 0) && (load_balance != LOAD_BALANCE_LBA)) {
4593                 VHCI_DEBUG(1, (CE_NOTE, dip,
4594                     "!vhci_parse_mpxio_lb_options: region-size: %d"
4595                     "only valid for load-balance=logical-block\n",
4596                     region_size));
4597         }
4598 #endif
4599         if ((region_size == -1) && (load_balance == LOAD_BALANCE_LBA)) {
4600                 VHCI_DEBUG(1, (CE_NOTE, dip,
4601                     "!vhci_parse_mpxio_lb_options: No region-size"
4602                     " defined load-balance=logical-block."
4603                     " Default to: %d\n", LOAD_BALANCE_DEFAULT_REGION_SIZE));
4604                 (void) mdi_set_lb_region_size(cdip,
4605                     LOAD_BALANCE_DEFAULT_REGION_SIZE);
4606         }
4607         if (list_len > 0) {
4608                 kmem_free(config_list, list_len);
4609         }
4610 }
4611 
4612 /*
4613  * Parse the device-type-mpxio-options-list looking for the key of
4614  * "load-balance-options". If found, parse the load balancing options.
4615  * Check the comment of the vhci_get_device_type_mpxio_options()
4616  * for the device-type-mpxio-options-list.
4617  */
4618 static void
4619 vhci_parse_mpxio_options(dev_info_t *dip, dev_info_t *cdip,
4620                 caddr_t datanameptr, int list_len)
4621 {
4622         char            *dataptr;
4623         int             len;
4624 
4625         /*
4626          * get the data list
4627          */
4628         dataptr = datanameptr;
4629         len = 0;
4630         while (len < list_len &&
4631             strncmp(dataptr, DEVICE_TYPE_STR, strlen(DEVICE_TYPE_STR))
4632             != 0) {
4633                 if (strncmp(dataptr, LOAD_BALANCE_OPTIONS,
4634                     strlen(LOAD_BALANCE_OPTIONS)) == 0) {
4635                         len += strlen(LOAD_BALANCE_OPTIONS) + 1;
4636                         dataptr += strlen(LOAD_BALANCE_OPTIONS) + 1;
4637                         vhci_parse_mpxio_lb_options(dip, cdip, dataptr);
4638                 }
4639                 len += strlen(dataptr) + 1;
4640                 dataptr += strlen(dataptr) + 1;
4641         }
4642 }
4643 
4644 /*
4645  * Check the inquriy string returned from the device with the device-type
4646  * Check for the existence of the device-type-mpxio-options-list and
4647  * if found parse the list checking for a match with the device-type
4648  * value and the inquiry string returned from the device. If a match
4649  * is found, parse the mpxio options list. The format of the
4650  * device-type-mpxio-options-list is:
4651  * device-type-mpxio-options-list=
4652  * "device-type=SUN    SENA", "load-balance-options=logical-block-options"
4653  * "device-type=SUN     SE6920", "round-robin-options";
4654  * logical-block-options="load-balance=logical-block", "region-size=15";
4655  * round-robin-options="load-balance=round-robin";
4656  */
4657 void
4658 vhci_get_device_type_mpxio_options(dev_info_t *dip, dev_info_t *cdip,
4659         struct scsi_device *devp)
4660 {
4661 
4662         caddr_t                 config_list     = NULL;
4663         caddr_t                 vidptr, datanameptr;
4664         int                     vidlen, dupletlen = 0;
4665         int                     config_list_len = 0, len;
4666         struct scsi_inquiry     *inq = devp->sd_inq;
4667 
4668         /*
4669          * look up the device-type-mpxio-options-list and walk thru
4670          * the list compare the vendor ids of the earlier inquiry command and
4671          * with those vids in the list if there is a match, lookup
4672          * the mpxio-options value
4673          */
4674         if (ddi_getlongprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
4675             MPXIO_OPTIONS_LIST,
4676             (caddr_t)&config_list, &config_list_len) == DDI_PROP_SUCCESS) {
4677 
4678                 /*
4679                  * Compare vids in each duplet - if it matches,
4680                  * parse the mpxio options list.
4681                  */
4682                 for (len = config_list_len, vidptr = config_list; len > 0;
4683                     len -= dupletlen) {
4684 
4685                         dupletlen = 0;
4686 
4687                         if (strlen(vidptr) != 0 &&
4688                             strncmp(vidptr, DEVICE_TYPE_STR,
4689                             strlen(DEVICE_TYPE_STR)) == 0) {
4690                                 /* point to next duplet */
4691                                 datanameptr = vidptr + strlen(vidptr) + 1;
4692                                 /* add len of this duplet */
4693                                 dupletlen += strlen(vidptr) + 1;
4694                                 /* get to device type */
4695                                 vidptr += strlen(DEVICE_TYPE_STR) + 1;
4696                                 vidlen = strlen(vidptr);
4697                                 if ((vidlen != 0) &&
4698                                     bcmp(inq->inq_vid, vidptr, vidlen) == 0) {
4699                                         vhci_parse_mpxio_options(dip, cdip,
4700                                             datanameptr, len - dupletlen);
4701                                         break;
4702                                 }
4703                                 /* get to next duplet */
4704                                 vidptr += strlen(vidptr) + 1;
4705                         }
4706                         /* get to the next device-type */
4707                         while (len - dupletlen > 0 &&
4708                             strlen(vidptr) != 0 &&
4709                             strncmp(vidptr, DEVICE_TYPE_STR,
4710                             strlen(DEVICE_TYPE_STR)) != 0) {
4711                                 dupletlen += strlen(vidptr) + 1;
4712                                 vidptr += strlen(vidptr) + 1;
4713                         }
4714                 }
4715                 if (config_list_len > 0) {
4716                         kmem_free(config_list, config_list_len);
4717                 }
4718         }
4719 }
4720 
4721 static int
4722 vhci_update_pathinfo(struct scsi_device *psd,  mdi_pathinfo_t *pip,
4723         struct scsi_failover_ops *fo,
4724         scsi_vhci_lun_t         *vlun,
4725         struct scsi_vhci        *vhci)
4726 {
4727         struct scsi_path_opinfo         opinfo;
4728         char                            *pclass, *best_pclass;
4729         char                            *resrv_pclass = NULL;
4730         int                             force_rereserve = 0;
4731         int                             update_pathinfo_done = 0;
4732 
4733         if (fo->sfo_path_get_opinfo(psd, &opinfo, vlun->svl_fops_ctpriv) != 0) {
4734                 VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_update_pathinfo: "
4735                     "Failed to get operation info for path:%p\n", (void *)pip));
4736                 return (MDI_FAILURE);
4737         }
4738         /* set the xlf capable flag in the vlun for future use */
4739         vlun->svl_xlf_capable = opinfo.opinfo_xlf_capable;
4740         (void) mdi_prop_update_string(pip, "path-class",
4741             opinfo.opinfo_path_attr);
4742 
4743         pclass = opinfo.opinfo_path_attr;
4744         if (opinfo.opinfo_path_state == SCSI_PATH_ACTIVE) {
4745                 mutex_enter(&vlun->svl_mutex);
4746                 if (vlun->svl_active_pclass != NULL) {
4747                         if (strcmp(vlun->svl_active_pclass, pclass) != 0) {
4748                                 mutex_exit(&vlun->svl_mutex);
4749                                 /*
4750                                  * Externally initiated failover has happened;
4751                                  * force the path state to be STANDBY/ONLINE,
4752                                  * next IO will trigger failover and thus
4753                                  * sync-up the pathstates.  Reason we don't
4754                                  * sync-up immediately by invoking
4755                                  * vhci_update_pathstates() is because it
4756                                  * needs a VHCI_HOLD_LUN() and we don't
4757                                  * want to block here.
4758                                  *
4759                                  * Further, if the device is an ALUA device,
4760                                  * then failure to exactly match 'pclass' and
4761                                  * 'svl_active_pclass'(as is the case here)
4762                                  * indicates that the currently active path
4763                                  * is a 'non-optimized' path - which means
4764                                  * that 'svl_active_pclass' needs to be
4765                                  * replaced with opinfo.opinfo_path_state
4766                                  * value.
4767                                  */
4768 
4769                                 if (SCSI_FAILOVER_IS_TPGS(vlun->svl_fops)) {
4770                                         char    *tptr;
4771 
4772                                         /*
4773                                          * The device is ALUA compliant. The
4774                                          * state need to be changed to online
4775                                          * rather than standby state which is
4776                                          * done typically for a asymmetric
4777                                          * device that is non ALUA compliant.
4778                                          */
4779                                         mdi_pi_set_state(pip,
4780                                             MDI_PATHINFO_STATE_ONLINE);
4781                                         tptr = kmem_alloc(strlen
4782                                             (opinfo.opinfo_path_attr)+1,
4783                                             KM_SLEEP);
4784                                         (void) strlcpy(tptr,
4785                                             opinfo.opinfo_path_attr,
4786                                             (strlen(opinfo.opinfo_path_attr)
4787                                             +1));
4788                                         mutex_enter(&vlun->svl_mutex);
4789                                         kmem_free(vlun->svl_active_pclass,
4790                                             strlen(vlun->svl_active_pclass)+1);
4791                                         vlun->svl_active_pclass = tptr;
4792                                         mutex_exit(&vlun->svl_mutex);
4793                                 } else {
4794                                         /*
4795                                          * Non ALUA device case.
4796                                          */
4797                                         mdi_pi_set_state(pip,
4798                                             MDI_PATHINFO_STATE_STANDBY);
4799                                 }
4800                                 vlun->svl_fo_support = opinfo.opinfo_mode;
4801                                 mdi_pi_set_preferred(pip,
4802                                     opinfo.opinfo_preferred);
4803                                 update_pathinfo_done = 1;
4804                         }
4805 
4806                         /*
4807                          * Find out a class of currently reserved path if there
4808                          * is any.
4809                          */
4810                         if ((vlun->svl_flags & VLUN_RESERVE_ACTIVE_FLG) &&
4811                             mdi_prop_lookup_string(vlun->svl_resrv_pip,
4812                             "path-class", &resrv_pclass) != MDI_SUCCESS) {
4813                                 VHCI_DEBUG(1, (CE_NOTE, NULL,
4814                                     "!vhci_update_pathinfo: prop lookup "
4815                                     "failed for path 0x%p\n",
4816                                     (void *)vlun->svl_resrv_pip));
4817                                 /*
4818                                  * Something is wrong with the reserved path.
4819                                  * We can't do much with that right here. Just
4820                                  * force re-reservation to another path.
4821                                  */
4822                                 force_rereserve = 1;
4823                         }
4824 
4825                         (void) fo->sfo_pathclass_next(NULL, &best_pclass,
4826                             vlun->svl_fops_ctpriv);
4827                         if ((force_rereserve == 1) || ((resrv_pclass != NULL) &&
4828                             (strcmp(pclass, best_pclass) == 0) &&
4829                             (strcmp(resrv_pclass, best_pclass) != 0))) {
4830                                 /*
4831                                  * Inform target driver that a reservation
4832                                  * should be reinstated because the reserved
4833                                  * path is not the most preferred one.
4834                                  */
4835                                 mutex_enter(&vhci->vhci_mutex);
4836                                 scsi_hba_reset_notify_callback(
4837                                     &vhci->vhci_mutex,
4838                                     &vhci->vhci_reset_notify_listf);
4839                                 mutex_exit(&vhci->vhci_mutex);
4840                         }
4841 
4842                         if (update_pathinfo_done == 1) {
4843                                 return (MDI_SUCCESS);
4844                         }
4845                 } else {
4846                         char    *tptr;
4847 
4848                         /*
4849                          * lets release the mutex before we try to
4850                          * allocate since the potential to sleep is
4851                          * possible.
4852                          */
4853                         mutex_exit(&vlun->svl_mutex);
4854                         tptr = kmem_alloc(strlen(pclass)+1, KM_SLEEP);
4855                         (void) strlcpy(tptr, pclass, (strlen(pclass)+1));
4856                         mutex_enter(&vlun->svl_mutex);
4857                         vlun->svl_active_pclass = tptr;
4858                 }
4859                 mutex_exit(&vlun->svl_mutex);
4860                 mdi_pi_set_state(pip, MDI_PATHINFO_STATE_ONLINE);
4861                 vlun->svl_waiting_for_activepath = 0;
4862         } else if (opinfo.opinfo_path_state == SCSI_PATH_ACTIVE_NONOPT) {
4863                 mutex_enter(&vlun->svl_mutex);
4864                 if (vlun->svl_active_pclass == NULL) {
4865                         char    *tptr;
4866 
4867                         mutex_exit(&vlun->svl_mutex);
4868                         tptr = kmem_alloc(strlen(pclass)+1, KM_SLEEP);
4869                         (void) strlcpy(tptr, pclass, (strlen(pclass)+1));
4870                         mutex_enter(&vlun->svl_mutex);
4871                         vlun->svl_active_pclass = tptr;
4872                 }
4873                 mutex_exit(&vlun->svl_mutex);
4874                 mdi_pi_set_state(pip, MDI_PATHINFO_STATE_ONLINE);
4875                 vlun->svl_waiting_for_activepath = 0;
4876         } else if (opinfo.opinfo_path_state == SCSI_PATH_INACTIVE) {
4877                 mutex_enter(&vlun->svl_mutex);
4878                 if (vlun->svl_active_pclass != NULL) {
4879                         if (strcmp(vlun->svl_active_pclass, pclass) == 0) {
4880                                 mutex_exit(&vlun->svl_mutex);
4881                                 /*
4882                                  * externally initiated failover has happened;
4883                                  * force state to ONLINE (see comment above)
4884                                  */
4885                                 mdi_pi_set_state(pip,
4886                                     MDI_PATHINFO_STATE_ONLINE);
4887                                 vlun->svl_fo_support = opinfo.opinfo_mode;
4888                                 mdi_pi_set_preferred(pip,
4889                                     opinfo.opinfo_preferred);
4890                                 return (MDI_SUCCESS);
4891                         }
4892                 }
4893                 mutex_exit(&vlun->svl_mutex);
4894                 mdi_pi_set_state(pip, MDI_PATHINFO_STATE_STANDBY);
4895 
4896                 /*
4897                  * Initiate auto-failback, if enabled, for path if path-state
4898                  * is transitioning from OFFLINE->STANDBY and pathclass is the
4899                  * preferred pathclass for this storage.
4900                  * NOTE: In case where opinfo_path_state is SCSI_PATH_ACTIVE
4901                  * (above), where the pi state is set to STANDBY, we don't
4902                  * initiate auto-failback as the next IO shall take care of.
4903                  * this. See comment above.
4904                  */
4905                 (void) fo->sfo_pathclass_next(NULL, &best_pclass,
4906                     vlun->svl_fops_ctpriv);
4907                 if (((vhci->vhci_conf_flags & VHCI_CONF_FLAGS_AUTO_FAILBACK) ==
4908                     VHCI_CONF_FLAGS_AUTO_FAILBACK) &&
4909                     (strcmp(pclass, best_pclass) == 0) &&
4910                     ((MDI_PI_OLD_STATE(pip) == MDI_PATHINFO_STATE_OFFLINE)||
4911                     (MDI_PI_OLD_STATE(pip) == MDI_PATHINFO_STATE_INIT))) {
4912                         VHCI_DEBUG(1, (CE_NOTE, NULL, "%s pathclass path: %p"
4913                             " OFFLINE->STANDBY transition for lun %s\n",
4914                             best_pclass, (void *)pip, vlun->svl_lun_wwn));
4915                         (void) taskq_dispatch(vhci->vhci_taskq,
4916                             vhci_initiate_auto_failback, (void *) vlun,
4917                             KM_SLEEP);
4918                 }
4919         }
4920         vlun->svl_fo_support = opinfo.opinfo_mode;
4921         mdi_pi_set_preferred(pip, opinfo.opinfo_preferred);
4922 
4923         VHCI_DEBUG(8, (CE_NOTE, NULL, "vhci_update_pathinfo: opinfo_rev = %x,"
4924             " opinfo_path_state = %x opinfo_preferred = %x, opinfo_mode = %x\n",
4925             opinfo.opinfo_rev, opinfo.opinfo_path_state,
4926             opinfo.opinfo_preferred, opinfo.opinfo_mode));
4927 
4928         return (MDI_SUCCESS);
4929 }
4930 
4931 /*
4932  * Form the kstat name and and call mdi_pi_kstat_create()
4933  */
4934 void
4935 vhci_kstat_create_pathinfo(mdi_pathinfo_t *pip)
4936 {
4937         dev_info_t      *tgt_dip;
4938         dev_info_t      *pdip;
4939         char            *guid;
4940         char            *target_port, *target_port_dup;
4941         char            ks_name[KSTAT_STRLEN];
4942         uint_t          pid;
4943         int             by_id;
4944         mod_hash_val_t  hv;
4945 
4946 
4947         /* return if we have already allocated kstats */
4948         if (mdi_pi_kstat_exists(pip))
4949                 return;
4950 
4951         /*
4952          * We need instance numbers to create a kstat name, return if we don't
4953          * have instance numbers assigned yet.
4954          */
4955         tgt_dip = mdi_pi_get_client(pip);
4956         pdip = mdi_pi_get_phci(pip);
4957         if ((ddi_get_instance(tgt_dip) == -1) || (ddi_get_instance(pdip) == -1))
4958                 return;
4959 
4960         /*
4961          * A path oriented kstat has a ks_name of the form:
4962          *
4963          * <client-driver><instance>.t<pid>.<pHCI-driver><instance>
4964          *
4965          * We maintain a bidirectional 'target-port' to <pid> map,
4966          * called targetmap. All pathinfo nodes with the same
4967          * 'target-port' map to the same <pid>. The iostat(1M) code,
4968          * when parsing a path oriented kstat name, uses the <pid> as
4969          * a SCSI_VHCI_GET_TARGET_LONGNAME ioctl argument in order
4970          * to get the 'target-port'. For KSTAT_FLAG_PERSISTENT kstats,
4971          * this ioctl needs to translate a <pid> to a 'target-port'
4972          * even after all pathinfo nodes associated with the
4973          * 'target-port' have been destroyed. This is needed to support
4974          * consistent first-iteration activity-since-boot iostat(1M)
4975          * output. Because of this requirement, the mapping can't be
4976          * based on pathinfo information in a devinfo snapshot.
4977          */
4978 
4979         /* determine 'target-port' */
4980         if (mdi_prop_lookup_string(pip,
4981             SCSI_ADDR_PROP_TARGET_PORT, &target_port) == MDI_SUCCESS) {
4982                 target_port_dup = i_ddi_strdup(target_port, KM_SLEEP);
4983                 (void) mdi_prop_free(target_port);
4984                 by_id = 1;
4985         } else {
4986                 /*
4987                  * If the pHCI did not set up 'target-port' on this
4988                  * pathinfo node, assume that our client is the only
4989                  * one with paths to the device by using the guid
4990                  * value as the 'target-port'. Since no other client
4991                  * will have the same guid, no other client will use
4992                  * the same <pid>.  NOTE: a client with an instance
4993                  * number always has a guid.
4994                  */
4995                 (void) ddi_prop_lookup_string(DDI_DEV_T_ANY, tgt_dip,
4996                     PROPFLAGS, MDI_CLIENT_GUID_PROP, &guid);
4997                 target_port_dup = i_ddi_strdup(guid, KM_SLEEP);
4998                 ddi_prop_free(guid);
4999 
5000                 /*
5001                  * For this type of mapping we don't want the
5002                  * <id> -> 'target-port' mapping to be made.  This
5003                  * will cause the SCSI_VHCI_GET_TARGET_LONGNAME ioctl
5004                  * to fail, and the iostat(1M) long '-n' output will
5005                  * still use the <pid>.  We do this because we just
5006                  * made up the 'target-port' using the guid, and we
5007                  * don't want to expose that fact in iostat output.
5008                  */
5009                 by_id = 0;
5010         }
5011 
5012         /* find/establish <pid> given 'target-port' */
5013         mutex_enter(&vhci_targetmap_mutex);
5014         if (mod_hash_find(vhci_targetmap_byport,
5015             (mod_hash_key_t)target_port_dup, &hv) == 0) {
5016                 pid = (int)(intptr_t)hv;        /* mapping exists */
5017         } else {
5018                 pid = vhci_targetmap_pid++;     /* new mapping */
5019 
5020                 (void) mod_hash_insert(vhci_targetmap_byport,
5021                     (mod_hash_key_t)target_port_dup,
5022                     (mod_hash_val_t)(intptr_t)pid);
5023                 if (by_id) {
5024                         (void) mod_hash_insert(vhci_targetmap_bypid,
5025                             (mod_hash_key_t)(uintptr_t)pid,
5026                             (mod_hash_val_t)(uintptr_t)target_port_dup);
5027                 }
5028                 target_port_dup = NULL;         /* owned by hash */
5029         }
5030         mutex_exit(&vhci_targetmap_mutex);
5031 
5032         /* form kstat name */
5033         (void) snprintf(ks_name, KSTAT_STRLEN, "%s%d.t%d.%s%d",
5034             ddi_driver_name(tgt_dip), ddi_get_instance(tgt_dip),
5035             pid, ddi_driver_name(pdip), ddi_get_instance(pdip));
5036 
5037         VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_path_online: path:%p "
5038             "kstat %s: pid %x <-> port %s\n", (void *)pip,
5039             ks_name, pid, target_port_dup));
5040         if (target_port_dup)
5041                 kmem_free(target_port_dup, strlen(target_port_dup) + 1);
5042 
5043         /* call mdi to create kstats with the name we built */
5044         (void) mdi_pi_kstat_create(pip, ks_name);
5045 }
5046 
5047 /* ARGSUSED */
5048 static int
5049 vhci_pathinfo_online(dev_info_t *vdip, mdi_pathinfo_t *pip, int flags)
5050 {
5051         scsi_hba_tran_t                 *hba = NULL;
5052         struct scsi_device              *psd = NULL;
5053         scsi_vhci_lun_t                 *vlun = NULL;
5054         dev_info_t                      *pdip = NULL;
5055         dev_info_t                      *cdip;
5056         dev_info_t                      *tgt_dip;
5057         struct scsi_vhci                *vhci;
5058         char                            *guid;
5059         struct scsi_failover_ops        *sfo;
5060         scsi_vhci_priv_t                *svp = NULL;
5061         struct scsi_address             *ap;
5062         struct scsi_pkt                 *pkt;
5063         int                             rval = MDI_FAILURE;
5064         mpapi_item_list_t               *list_ptr;
5065         mpapi_lu_data_t                 *ld;
5066 
5067         ASSERT(vdip != NULL);
5068         ASSERT(pip != NULL);
5069 
5070         vhci = ddi_get_soft_state(vhci_softstate, ddi_get_instance(vdip));
5071         ASSERT(vhci != NULL);
5072 
5073         pdip = mdi_pi_get_phci(pip);
5074         hba = ddi_get_driver_private(pdip);
5075         ASSERT(hba != NULL);
5076 
5077         svp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(pip);
5078         ASSERT(svp != NULL);
5079 
5080         cdip = mdi_pi_get_client(pip);
5081         ASSERT(cdip != NULL);
5082         if (ddi_prop_lookup_string(DDI_DEV_T_ANY, cdip, PROPFLAGS,
5083             MDI_CLIENT_GUID_PROP, &guid) != DDI_SUCCESS) {
5084                 VHCI_DEBUG(1, (CE_WARN, NULL, "vhci_path_online: lun guid "
5085                     "property failed"));
5086                 goto failure;
5087         }
5088 
5089         vlun = vhci_lun_lookup(cdip);
5090         ASSERT(vlun != NULL);
5091 
5092         ddi_prop_free(guid);
5093 
5094         vlun->svl_dip = mdi_pi_get_client(pip);
5095         ASSERT(vlun->svl_dip != NULL);
5096 
5097         psd = svp->svp_psd;
5098         ASSERT(psd != NULL);
5099 
5100         ap = &psd->sd_address;
5101 
5102         /*
5103          * Get inquiry data into pathinfo related scsi_device structure.
5104          * Free sq_inq when pathinfo related scsi_device structure is destroyed
5105          * by vhci_pathinfo_uninit(). In other words, vhci maintains its own
5106          * copy of scsi_device and scsi_inquiry data on a per-path basis.
5107          */
5108         if (scsi_probe(psd, SLEEP_FUNC) != SCSIPROBE_EXISTS) {
5109                 VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_pathinfo_online: "
5110                     "scsi_probe failed path:%p rval:%x\n", (void *)pip, rval));
5111                 rval = MDI_FAILURE;
5112                 goto failure;
5113         }
5114 
5115         /*
5116          * See if we have a failover module to support the device.
5117          *
5118          * We re-probe to determine the failover ops for each path. This
5119          * is done in case there are any path-specific side-effects associated
5120          * with the sfo_device_probe implementation.
5121          *
5122          * Give the first successfull sfo_device_probe the opportunity to
5123          * establish 'ctpriv', vlun/client private data. The ctpriv will
5124          * then be passed into the failover module on all other sfo_device_*()
5125          * operations (and must be freed by sfo_device_unprobe implementation).
5126          *
5127          * NOTE: While sfo_device_probe is done once per path,
5128          * sfo_device_unprobe only occurs once - when the vlun is destroyed.
5129          *
5130          * NOTE: We don't currently support per-path fops private data
5131          * mechanism.
5132          */
5133         sfo = vhci_dev_fo(vdip, psd,
5134             &vlun->svl_fops_ctpriv, &vlun->svl_fops_name);
5135 
5136         /* check path configuration result with current vlun state */
5137         if (((sfo && vlun->svl_fops) && (sfo != vlun->svl_fops)) ||
5138             (sfo && vlun->svl_not_supported) ||
5139             ((sfo == NULL) && vlun->svl_fops)) {
5140                 /* Getting different results for different paths. */
5141                 VHCI_DEBUG(1, (CE_NOTE, vhci->vhci_dip,
5142                     "!vhci_pathinfo_online: dev (path 0x%p) contradiction\n",
5143                     (void *)pip));
5144                 cmn_err(CE_WARN, "scsi_vhci: failover contradiction: "
5145                     "'%s'.vs.'%s': path %s\n",
5146                     vlun->svl_fops ? vlun->svl_fops->sfo_name : "NULL",
5147                     sfo ? sfo->sfo_name : "NULL", mdi_pi_pathname(pip));
5148                 vlun->svl_not_supported = 1;
5149                 rval = MDI_NOT_SUPPORTED;
5150                 goto done;
5151         } else if (sfo == NULL) {
5152                 /* No failover module - device not supported under vHCI.  */
5153                 VHCI_DEBUG(1, (CE_NOTE, vhci->vhci_dip,
5154                     "!vhci_pathinfo_online: dev (path 0x%p) not "
5155                     "supported\n", (void *)pip));
5156 
5157                 /* XXX does this contradict vhci_is_dev_supported ? */
5158                 vlun->svl_not_supported = 1;
5159                 rval = MDI_NOT_SUPPORTED;
5160                 goto done;
5161         }
5162 
5163         /* failover supported for device - save failover_ops in vlun */
5164         vlun->svl_fops = sfo;
5165         ASSERT(vlun->svl_fops_name != NULL);
5166 
5167         /*
5168          * Obtain the device-type based mpxio options as specified in
5169          * scsi_vhci.conf file.
5170          *
5171          * NOTE: currently, the end result is a call to
5172          * mdi_set_lb_region_size().
5173          */
5174         tgt_dip = psd->sd_dev;
5175         ASSERT(tgt_dip != NULL);
5176         vhci_get_device_type_mpxio_options(vdip, tgt_dip, psd);
5177 
5178         /*
5179          * if PGR is active, revalidate key and register on this path also,
5180          * if key is still valid
5181          */
5182         sema_p(&vlun->svl_pgr_sema);
5183         if (vlun->svl_pgr_active) {
5184                 rval = vhci_pgr_validate_and_register(svp);
5185                 if (rval != 1) {
5186                         rval = MDI_FAILURE;
5187                         sema_v(&vlun->svl_pgr_sema);
5188                         goto failure;
5189                 }
5190         }
5191         sema_v(&vlun->svl_pgr_sema);
5192 
5193         if (svp->svp_new_path) {
5194                 /*
5195                  * Last chance to perform any cleanup operations on this
5196                  * new path before making this path completely online.
5197                  */
5198                 svp->svp_new_path = 0;
5199 
5200                 /*
5201                  * If scsi_vhci knows the lun is alread RESERVE'd,
5202                  * then skip the issue of RELEASE on new path.
5203                  */
5204                 if ((vlun->svl_flags & VLUN_RESERVE_ACTIVE_FLG) == 0) {
5205                         /*
5206                          * Issue SCSI-2 RELEASE only for the first time on
5207                          * a new path just in case the host rebooted and
5208                          * a reservation is still pending on this path.
5209                          * IBM Shark storage does not clear RESERVE upon
5210                          * host reboot.
5211                          */
5212                         pkt = scsi_init_pkt(ap, NULL, NULL, CDB_GROUP0,
5213                             sizeof (struct scsi_arq_status), 0, 0,
5214                             SLEEP_FUNC, NULL);
5215                         if (pkt == NULL) {
5216                                 VHCI_DEBUG(1, (CE_NOTE, NULL,
5217                                     "!vhci_pathinfo_online: "
5218                                     "Release init_pkt failed :%p\n",
5219                                     (void *)pip));
5220                                 rval = MDI_FAILURE;
5221                                 goto failure;
5222                         }
5223                         pkt->pkt_cdbp[0] = SCMD_RELEASE;
5224                         pkt->pkt_time = 60;
5225 
5226                         VHCI_DEBUG(1, (CE_NOTE, NULL,
5227                             "!vhci_path_online: path:%p "
5228                             "Issued SCSI-2 RELEASE\n", (void *)pip));
5229 
5230                         /* Ignore the return value */
5231                         (void) vhci_do_scsi_cmd(pkt);
5232                         scsi_destroy_pkt(pkt);
5233                 }
5234         }
5235 
5236         rval = vhci_update_pathinfo(psd, pip, sfo, vlun, vhci);
5237         if (rval == MDI_FAILURE) {
5238                 goto failure;
5239         }
5240 
5241         /* Initialize MP-API data */
5242         vhci_update_mpapi_data(vhci, vlun, pip);
5243 
5244         /*
5245          * MP-API also needs the Inquiry data to be maintained in the
5246          * mp_vendor_prop_t structure, so find the lun and update its
5247          * structure with this data.
5248          */
5249         list_ptr = (mpapi_item_list_t *)vhci_get_mpapi_item(vhci, NULL,
5250             MP_OBJECT_TYPE_MULTIPATH_LU, (void *)vlun);
5251         ld = (mpapi_lu_data_t *)list_ptr->item->idata;
5252         if (ld != NULL) {
5253                 bcopy(psd->sd_inq->inq_vid, ld->prop.prodInfo.vendor, 8);
5254                 bcopy(psd->sd_inq->inq_pid, ld->prop.prodInfo.product, 16);
5255                 bcopy(psd->sd_inq->inq_revision, ld->prop.prodInfo.revision, 4);
5256         } else {
5257                 VHCI_DEBUG(1, (CE_WARN, NULL, "!vhci_pathinfo_online: "
5258                     "mpapi_lu_data_t is NULL"));
5259         }
5260 
5261         /* create kstats for path */
5262         vhci_kstat_create_pathinfo(pip);
5263 
5264 done:
5265         mutex_enter(&vhci_global_mutex);
5266         cv_broadcast(&vhci_cv);
5267         mutex_exit(&vhci_global_mutex);
5268 
5269         if (vlun->svl_setcap_done) {
5270                 (void) vhci_pHCI_cap(ap, "sector-size",
5271                     vlun->svl_sector_size, 1, pip);
5272         }
5273 
5274         VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_path_online: path:%p\n",
5275             (void *)pip));
5276 
5277 failure:
5278         return (rval);
5279 }
5280 
5281 /*
5282  * path offline handler.  Release all bindings that will not be
5283  * released by the normal packet transport/completion code path.
5284  * Since we don't (presently) keep any bindings alive outside of
5285  * the in-transport packets (which will be released on completion)
5286  * there is not much to do here.
5287  */
5288 /* ARGSUSED */
5289 static int
5290 vhci_pathinfo_offline(dev_info_t *vdip, mdi_pathinfo_t *pip, int flags)
5291 {
5292         scsi_hba_tran_t         *hba = NULL;
5293         struct scsi_device      *psd = NULL;
5294         dev_info_t              *pdip = NULL;
5295         dev_info_t              *cdip = NULL;
5296         scsi_vhci_priv_t        *svp = NULL;
5297 
5298         ASSERT(vdip != NULL);
5299         ASSERT(pip != NULL);
5300 
5301         pdip = mdi_pi_get_phci(pip);
5302         ASSERT(pdip != NULL);
5303         if (pdip == NULL) {
5304                 VHCI_DEBUG(1, (CE_WARN, vdip, "Invalid path 0x%p: NULL "
5305                     "phci dip", (void *)pip));
5306                 return (MDI_FAILURE);
5307         }
5308 
5309         cdip = mdi_pi_get_client(pip);
5310         ASSERT(cdip != NULL);
5311         if (cdip == NULL) {
5312                 VHCI_DEBUG(1, (CE_WARN, vdip, "Invalid path 0x%p: NULL "
5313                     "client dip", (void *)pip));
5314                 return (MDI_FAILURE);
5315         }
5316 
5317         hba = ddi_get_driver_private(pdip);
5318         ASSERT(hba != NULL);
5319 
5320         svp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(pip);
5321         if (svp == NULL) {
5322                 /*
5323                  * mdi_pathinfo node in INIT state can have vHCI private
5324                  * information set to null
5325                  */
5326                 VHCI_DEBUG(1, (CE_NOTE, vdip, "!vhci_pathinfo_offline: "
5327                     "svp is NULL for pip 0x%p\n", (void *)pip));
5328                 return (MDI_SUCCESS);
5329         }
5330 
5331         psd = svp->svp_psd;
5332         ASSERT(psd != NULL);
5333 
5334         mutex_enter(&svp->svp_mutex);
5335 
5336         VHCI_DEBUG(1, (CE_NOTE, vdip, "!vhci_pathinfo_offline: "
5337             "%d cmds pending on path: 0x%p\n", svp->svp_cmds, (void *)pip));
5338         while (svp->svp_cmds != 0) {
5339                 if (cv_reltimedwait(&svp->svp_cv, &svp->svp_mutex,
5340                     drv_usectohz(vhci_path_quiesce_timeout * 1000000),
5341                     TR_CLOCK_TICK) == -1) {
5342                         /*
5343                          * The timeout time reached without the condition
5344                          * being signaled.
5345                          */
5346                         VHCI_DEBUG(1, (CE_NOTE, vdip, "!vhci_pathinfo_offline: "
5347                             "Timeout reached on path 0x%p without the cond\n",
5348                             (void *)pip));
5349                         VHCI_DEBUG(1, (CE_NOTE, vdip, "!vhci_pathinfo_offline: "
5350                             "%d cmds still pending on path: 0x%p\n",
5351                             svp->svp_cmds, (void *)pip));
5352                         break;
5353                 }
5354         }
5355         mutex_exit(&svp->svp_mutex);
5356 
5357         /*
5358          * Check to see if this vlun has an active SCSI-II RESERVE. And this
5359          * is the pip for the path that has been reserved.
5360          * If so clear the reservation by sending a reset, so the host will not
5361          * get a reservation conflict.  Reset the flag VLUN_RESERVE_ACTIVE_FLG
5362          * for this lun.  Also a reset notify is sent to the target driver
5363          * just in case the POR check condition is cleared by some other layer
5364          * in the stack.
5365          */
5366         if (svp->svp_svl->svl_flags & VLUN_RESERVE_ACTIVE_FLG) {
5367                 if (pip == svp->svp_svl->svl_resrv_pip) {
5368                         if (vhci_recovery_reset(svp->svp_svl,
5369                             &svp->svp_psd->sd_address, TRUE,
5370                             VHCI_DEPTH_TARGET) == 0) {
5371                                 VHCI_DEBUG(1, (CE_NOTE, NULL,
5372                                     "!vhci_pathinfo_offline (pip:%p):"
5373                                     "reset failed, retrying\n", (void *)pip));
5374                                 delay(1*drv_usectohz(1000000));
5375                                 if (vhci_recovery_reset(svp->svp_svl,
5376                                     &svp->svp_psd->sd_address, TRUE,
5377                                     VHCI_DEPTH_TARGET) == 0) {
5378                                         VHCI_DEBUG(1, (CE_NOTE, NULL,
5379                                             "!vhci_pathinfo_offline "
5380                                             "(pip:%p): reset failed, "
5381                                             "giving up!\n", (void *)pip));
5382                                 }
5383                         }
5384                         svp->svp_svl->svl_flags &= ~VLUN_RESERVE_ACTIVE_FLG;
5385                 }
5386         }
5387 
5388         mdi_pi_set_state(pip, MDI_PATHINFO_STATE_OFFLINE);
5389         vhci_mpapi_set_path_state(vdip, pip, MP_DRVR_PATH_STATE_REMOVED);
5390 
5391         VHCI_DEBUG(1, (CE_NOTE, NULL,
5392             "!vhci_pathinfo_offline: offlined path 0x%p\n", (void *)pip));
5393         return (MDI_SUCCESS);
5394 }
5395 
5396 
5397 /*
5398  * routine for SCSI VHCI IOCTL implementation.
5399  */
5400 /* ARGSUSED */
5401 static int
5402 vhci_ctl(dev_t dev, int cmd, intptr_t data, int mode, cred_t *credp, int *rval)
5403 {
5404         struct scsi_vhci                *vhci;
5405         dev_info_t                      *vdip;
5406         mdi_pathinfo_t                  *pip;
5407         int                             instance, held;
5408         int                             retval = 0;
5409         caddr_t                         phci_path = NULL, client_path = NULL;
5410         caddr_t                         paddr = NULL;
5411         sv_iocdata_t                    ioc;
5412         sv_iocdata_t                    *pioc = &ioc;
5413         sv_switch_to_cntlr_iocdata_t    iocsc;
5414         sv_switch_to_cntlr_iocdata_t    *piocsc = &iocsc;
5415         caddr_t                         s;
5416         scsi_vhci_lun_t                 *vlun;
5417         struct scsi_failover_ops        *fo;
5418         char                            *pclass;
5419 
5420         /* Check for validity of vhci structure */
5421         vhci = ddi_get_soft_state(vhci_softstate, MINOR2INST(getminor(dev)));
5422         if (vhci == NULL) {
5423                 return (ENXIO);
5424         }
5425 
5426         mutex_enter(&vhci->vhci_mutex);
5427         if ((vhci->vhci_state & VHCI_STATE_OPEN) == 0) {
5428                 mutex_exit(&vhci->vhci_mutex);
5429                 return (ENXIO);
5430         }
5431         mutex_exit(&vhci->vhci_mutex);
5432 
5433         /* Get the vhci dip */
5434         vdip = vhci->vhci_dip;
5435         ASSERT(vdip != NULL);
5436         instance = ddi_get_instance(vdip);
5437 
5438         /* Allocate memory for getting parameters from userland */
5439         phci_path       = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
5440         client_path     = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
5441         paddr           = kmem_zalloc(MAXNAMELEN, KM_SLEEP);
5442 
5443         /*
5444          * Set a local variable indicating the ioctl name. Used for
5445          * printing debug strings.
5446          */
5447         switch (cmd) {
5448         case SCSI_VHCI_GET_CLIENT_MULTIPATH_INFO:
5449                 s = "GET_CLIENT_MULTIPATH_INFO";
5450                 break;
5451 
5452         case SCSI_VHCI_GET_PHCI_MULTIPATH_INFO:
5453                 s = "GET_PHCI_MULTIPATH_INFO";
5454                 break;
5455 
5456         case SCSI_VHCI_GET_CLIENT_NAME:
5457                 s = "GET_CLIENT_NAME";
5458                 break;
5459 
5460         case SCSI_VHCI_PATH_ONLINE:
5461                 s = "PATH_ONLINE";
5462                 break;
5463 
5464         case SCSI_VHCI_PATH_OFFLINE:
5465                 s = "PATH_OFFLINE";
5466                 break;
5467 
5468         case SCSI_VHCI_PATH_STANDBY:
5469                 s = "PATH_STANDBY";
5470                 break;
5471 
5472         case SCSI_VHCI_PATH_TEST:
5473                 s = "PATH_TEST";
5474                 break;
5475 
5476         case SCSI_VHCI_SWITCH_TO_CNTLR:
5477                 s = "SWITCH_TO_CNTLR";
5478                 break;
5479         case SCSI_VHCI_PATH_DISABLE:
5480                 s = "PATH_DISABLE";
5481                 break;
5482         case SCSI_VHCI_PATH_ENABLE:
5483                 s = "PATH_ENABLE";
5484                 break;
5485 
5486         case SCSI_VHCI_GET_TARGET_LONGNAME:
5487                 s = "GET_TARGET_LONGNAME";
5488                 break;
5489 
5490 #ifdef  DEBUG
5491         case SCSI_VHCI_CONFIGURE_PHCI:
5492                 s = "CONFIGURE_PHCI";
5493                 break;
5494 
5495         case SCSI_VHCI_UNCONFIGURE_PHCI:
5496                 s = "UNCONFIGURE_PHCI";
5497                 break;
5498 #endif
5499 
5500         default:
5501                 s = "Unknown";
5502                 vhci_log(CE_NOTE, vdip,
5503                     "!vhci%d: ioctl %x (unsupported ioctl)", instance, cmd);
5504                 retval = ENOTSUP;
5505                 break;
5506         }
5507         if (retval != 0) {
5508                 goto end;
5509         }
5510 
5511         VHCI_DEBUG(6, (CE_WARN, vdip, "!vhci%d: ioctl <%s>", instance, s));
5512 
5513         /*
5514          * Get IOCTL parameters from userland
5515          */
5516         switch (cmd) {
5517         case SCSI_VHCI_GET_CLIENT_MULTIPATH_INFO:
5518         case SCSI_VHCI_GET_PHCI_MULTIPATH_INFO:
5519         case SCSI_VHCI_GET_CLIENT_NAME:
5520         case SCSI_VHCI_PATH_ONLINE:
5521         case SCSI_VHCI_PATH_OFFLINE:
5522         case SCSI_VHCI_PATH_STANDBY:
5523         case SCSI_VHCI_PATH_TEST:
5524         case SCSI_VHCI_PATH_DISABLE:
5525         case SCSI_VHCI_PATH_ENABLE:
5526         case SCSI_VHCI_GET_TARGET_LONGNAME:
5527 #ifdef  DEBUG
5528         case SCSI_VHCI_CONFIGURE_PHCI:
5529         case SCSI_VHCI_UNCONFIGURE_PHCI:
5530 #endif
5531                 retval = vhci_get_iocdata((const void *)data, pioc, mode, s);
5532                 break;
5533 
5534         case SCSI_VHCI_SWITCH_TO_CNTLR:
5535                 retval = vhci_get_iocswitchdata((const void *)data, piocsc,
5536                     mode, s);
5537                 break;
5538         }
5539         if (retval != 0) {
5540                 goto end;
5541         }
5542 
5543 
5544         /*
5545          * Process the IOCTL
5546          */
5547         switch (cmd) {
5548         case SCSI_VHCI_GET_CLIENT_MULTIPATH_INFO:
5549         {
5550                 uint_t          num_paths;      /* Num paths to client dev */
5551                 sv_path_info_t  *upibuf = NULL; /* To keep userland values */
5552                 sv_path_info_t  *kpibuf = NULL; /* Kernel data for ioctls */
5553                 dev_info_t      *cdip;          /* Client device dip */
5554 
5555                 if (pioc->ret_elem == NULL) {
5556                         retval = EINVAL;
5557                         break;
5558                 }
5559 
5560                 /* Get client device path from user land */
5561                 if (vhci_ioc_get_client_path(pioc, client_path, mode, s)) {
5562                         retval = EFAULT;
5563                         break;
5564                 }
5565 
5566                 VHCI_DEBUG(6, (CE_WARN, vdip, "!vhci_ioctl: ioctl <%s> "
5567                     "client <%s>", s, client_path));
5568 
5569                 /* Get number of paths to this client device */
5570                 if ((cdip = mdi_client_path2devinfo(vdip, client_path))
5571                     == NULL) {
5572                         retval = ENXIO;
5573                         VHCI_DEBUG(1, (CE_WARN, NULL, "!vhci_ioctl: ioctl <%s> "
5574                             "client dip doesn't exist. invalid path <%s>",
5575                             s, client_path));
5576                         break;
5577                 }
5578                 num_paths = mdi_client_get_path_count(cdip);
5579 
5580                 if (ddi_copyout(&num_paths, pioc->ret_elem,
5581                     sizeof (num_paths), mode)) {
5582                         VHCI_DEBUG(1, (CE_WARN, NULL, "!vhci_ioctl: ioctl <%s> "
5583                             "num_paths copyout failed", s));
5584                         retval = EFAULT;
5585                         break;
5586                 }
5587 
5588                 /* If  user just wanted num_paths, then return */
5589                 if (pioc->buf_elem == 0 || pioc->ret_buf == NULL ||
5590                     num_paths == 0) {
5591                         break;
5592                 }
5593 
5594                 /* Set num_paths to value as much as can be sent to userland */
5595                 if (num_paths > pioc->buf_elem) {
5596                         num_paths = pioc->buf_elem;
5597                 }
5598 
5599                 /* Allocate memory and get userland pointers */
5600                 if (vhci_ioc_alloc_pathinfo(&upibuf, &kpibuf, num_paths,
5601                     pioc, mode, s) != 0) {
5602                         retval = EFAULT;
5603                         break;
5604                 }
5605                 ASSERT(upibuf != NULL);
5606                 ASSERT(kpibuf != NULL);
5607 
5608                 /*
5609                  * Get the path information and send it to userland.
5610                  */
5611                 if (vhci_get_client_path_list(cdip, kpibuf, num_paths)
5612                     != MDI_SUCCESS) {
5613                         retval = ENXIO;
5614                         vhci_ioc_free_pathinfo(upibuf, kpibuf, num_paths);
5615                         break;
5616                 }
5617 
5618                 if (vhci_ioc_send_pathinfo(upibuf, kpibuf, num_paths,
5619                     pioc, mode, s)) {
5620                         retval = EFAULT;
5621                         vhci_ioc_free_pathinfo(upibuf, kpibuf, num_paths);
5622                         break;
5623                 }
5624 
5625                 /* Free the memory allocated for path information */
5626                 vhci_ioc_free_pathinfo(upibuf, kpibuf, num_paths);
5627                 break;
5628         }
5629 
5630         case SCSI_VHCI_GET_PHCI_MULTIPATH_INFO:
5631         {
5632                 uint_t          num_paths;      /* Num paths to client dev */
5633                 sv_path_info_t  *upibuf = NULL; /* To keep userland values */
5634                 sv_path_info_t  *kpibuf = NULL; /* Kernel data for ioctls */
5635                 dev_info_t      *pdip;          /* PHCI device dip */
5636 
5637                 if (pioc->ret_elem == NULL) {
5638                         retval = EINVAL;
5639                         break;
5640                 }
5641 
5642                 /* Get PHCI device path from user land */
5643                 if (vhci_ioc_get_phci_path(pioc, phci_path, mode, s)) {
5644                         retval = EFAULT;
5645                         break;
5646                 }
5647 
5648                 VHCI_DEBUG(6, (CE_WARN, vdip,
5649                     "!vhci_ioctl: ioctl <%s> phci <%s>", s, phci_path));
5650 
5651                 /* Get number of devices associated with this PHCI device */
5652                 if ((pdip = mdi_phci_path2devinfo(vdip, phci_path)) == NULL) {
5653                         VHCI_DEBUG(1, (CE_WARN, NULL, "!vhci_ioctl: ioctl <%s> "
5654                             "phci dip doesn't exist. invalid path <%s>",
5655                             s, phci_path));
5656                         retval = ENXIO;
5657                         break;
5658                 }
5659 
5660                 num_paths = mdi_phci_get_path_count(pdip);
5661 
5662                 if (ddi_copyout(&num_paths, pioc->ret_elem,
5663                     sizeof (num_paths), mode)) {
5664                         VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_ioctl: ioctl <%s> "
5665                             "num_paths copyout failed", s));
5666                         retval = EFAULT;
5667                         break;
5668                 }
5669 
5670                 /* If  user just wanted num_paths, then return */
5671                 if (pioc->buf_elem == 0 || pioc->ret_buf == NULL ||
5672                     num_paths == 0) {
5673                         break;
5674                 }
5675 
5676                 /* Set num_paths to value as much as can be sent to userland */
5677                 if (num_paths > pioc->buf_elem) {
5678                         num_paths = pioc->buf_elem;
5679                 }
5680 
5681                 /* Allocate memory and get userland pointers */
5682                 if (vhci_ioc_alloc_pathinfo(&upibuf, &kpibuf, num_paths,
5683                     pioc, mode, s) != 0) {
5684                         retval = EFAULT;
5685                         break;
5686                 }
5687                 ASSERT(upibuf != NULL);
5688                 ASSERT(kpibuf != NULL);
5689 
5690                 /*
5691                  * Get the path information and send it to userland.
5692                  */
5693                 if (vhci_get_phci_path_list(pdip, kpibuf, num_paths)
5694                     != MDI_SUCCESS) {
5695                         retval = ENXIO;
5696                         vhci_ioc_free_pathinfo(upibuf, kpibuf, num_paths);
5697                         break;
5698                 }
5699 
5700                 if (vhci_ioc_send_pathinfo(upibuf, kpibuf, num_paths,
5701                     pioc, mode, s)) {
5702                         retval = EFAULT;
5703                         vhci_ioc_free_pathinfo(upibuf, kpibuf, num_paths);
5704                         break;
5705                 }
5706 
5707                 /* Free the memory allocated for path information */
5708                 vhci_ioc_free_pathinfo(upibuf, kpibuf, num_paths);
5709                 break;
5710         }
5711 
5712         case SCSI_VHCI_GET_CLIENT_NAME:
5713         {
5714                 dev_info_t              *cdip, *pdip;
5715 
5716                 /* Get PHCI path and device address from user land */
5717                 if (vhci_ioc_get_phci_path(pioc, phci_path, mode, s) ||
5718                     vhci_ioc_get_paddr(pioc, paddr, mode, s)) {
5719                         retval = EFAULT;
5720                         break;
5721                 }
5722 
5723                 VHCI_DEBUG(6, (CE_WARN, vdip, "!vhci_ioctl: ioctl <%s> "
5724                     "phci <%s>, paddr <%s>", s, phci_path, paddr));
5725 
5726                 /* Get the PHCI dip */
5727                 if ((pdip = mdi_phci_path2devinfo(vdip, phci_path)) == NULL) {
5728                         VHCI_DEBUG(1, (CE_WARN, NULL, "!vhci_ioctl: ioctl <%s> "
5729                             "phci dip doesn't exist. invalid path <%s>",
5730                             s, phci_path));
5731                         retval = ENXIO;
5732                         break;
5733                 }
5734 
5735                 if ((pip = mdi_pi_find(pdip, NULL, paddr)) == NULL) {
5736                         VHCI_DEBUG(1, (CE_WARN, vdip, "!vhci_ioctl: ioctl <%s> "
5737                             "pathinfo doesn't exist. invalid device addr", s));
5738                         retval = ENXIO;
5739                         break;
5740                 }
5741 
5742                 /* Get the client device pathname and send to userland */
5743                 cdip = mdi_pi_get_client(pip);
5744                 vhci_ioc_devi_to_path(cdip, client_path);
5745 
5746                 VHCI_DEBUG(6, (CE_WARN, vdip, "!vhci_ioctl: ioctl <%s> "
5747                     "client <%s>", s, client_path));
5748 
5749                 if (vhci_ioc_send_client_path(client_path, pioc, mode, s)) {
5750                         retval = EFAULT;
5751                         break;
5752                 }
5753                 break;
5754         }
5755 
5756         case SCSI_VHCI_PATH_ONLINE:
5757         case SCSI_VHCI_PATH_OFFLINE:
5758         case SCSI_VHCI_PATH_STANDBY:
5759         case SCSI_VHCI_PATH_TEST:
5760         {
5761                 dev_info_t              *pdip;  /* PHCI dip */
5762 
5763                 /* Get PHCI path and device address from user land */
5764                 if (vhci_ioc_get_phci_path(pioc, phci_path, mode, s) ||
5765                     vhci_ioc_get_paddr(pioc, paddr, mode, s)) {
5766                         retval = EFAULT;
5767                         break;
5768                 }
5769 
5770                 VHCI_DEBUG(6, (CE_WARN, vdip, "!vhci_ioctl: ioctl <%s> "
5771                     "phci <%s>, paddr <%s>", s, phci_path, paddr));
5772 
5773                 /* Get the PHCI dip */
5774                 if ((pdip = mdi_phci_path2devinfo(vdip, phci_path)) == NULL) {
5775                         VHCI_DEBUG(1, (CE_WARN, NULL, "!vhci_ioctl: ioctl <%s> "
5776                             "phci dip doesn't exist. invalid path <%s>",
5777                             s, phci_path));
5778                         retval = ENXIO;
5779                         break;
5780                 }
5781 
5782                 if ((pip = mdi_pi_find(pdip, NULL, paddr)) == NULL) {
5783                         VHCI_DEBUG(1, (CE_WARN, vdip, "!vhci_ioctl: ioctl <%s> "
5784                             "pathinfo doesn't exist. invalid device addr", s));
5785                         retval = ENXIO;
5786                         break;
5787                 }
5788 
5789                 VHCI_DEBUG(6, (CE_WARN, vdip, "!vhci_ioctl: ioctl <%s> "
5790                     "Calling MDI function to change device state", s));
5791 
5792                 switch (cmd) {
5793                 case SCSI_VHCI_PATH_ONLINE:
5794                         retval = mdi_pi_online(pip, 0);
5795                         break;
5796 
5797                 case SCSI_VHCI_PATH_OFFLINE:
5798                         retval = mdi_pi_offline(pip, 0);
5799                         break;
5800 
5801                 case SCSI_VHCI_PATH_STANDBY:
5802                         retval = mdi_pi_standby(pip, 0);
5803                         break;
5804 
5805                 case SCSI_VHCI_PATH_TEST:
5806                         break;
5807                 }
5808                 break;
5809         }
5810 
5811         case SCSI_VHCI_SWITCH_TO_CNTLR:
5812         {
5813                 dev_info_t *cdip;
5814                 struct scsi_device *devp;
5815 
5816                 /* Get the client device pathname */
5817                 if (ddi_copyin(piocsc->client, client_path,
5818                     MAXPATHLEN, mode)) {
5819                         VHCI_DEBUG(2, (CE_WARN, vdip, "!vhci_ioctl: ioctl <%s> "
5820                             "client_path copyin failed", s));
5821                         retval = EFAULT;
5822                         break;
5823                 }
5824 
5825                 /* Get the path class to which user wants to switch */
5826                 if (ddi_copyin(piocsc->class, paddr, MAXNAMELEN, mode)) {
5827                         VHCI_DEBUG(2, (CE_WARN, vdip, "!vhci_ioctl: ioctl <%s> "
5828                             "controller_class copyin failed", s));
5829                         retval = EFAULT;
5830                         break;
5831                 }
5832 
5833                 /* Perform validity checks */
5834                 if ((cdip = mdi_client_path2devinfo(vdip,
5835                     client_path)) == NULL) {
5836                         VHCI_DEBUG(1, (CE_WARN, NULL, "!vhci_ioctl: ioctl <%s> "
5837                             "client dip doesn't exist. invalid path <%s>",
5838                             s, client_path));
5839                         retval = ENXIO;
5840                         break;
5841                 }
5842 
5843                 VHCI_DEBUG(6, (CE_WARN, vdip, "!vhci_ioctl: Calling MDI func "
5844                     "to switch controller"));
5845                 VHCI_DEBUG(6, (CE_WARN, vdip, "!vhci_ioctl: client <%s> "
5846                     "class <%s>", client_path, paddr));
5847 
5848                 if (strcmp(paddr, PCLASS_PRIMARY) &&
5849                     strcmp(paddr, PCLASS_SECONDARY)) {
5850                         VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_ioctl: ioctl <%s> "
5851                             "invalid path class <%s>", s, paddr));
5852                         retval = ENXIO;
5853                         break;
5854                 }
5855 
5856                 devp = ddi_get_driver_private(cdip);
5857                 if (devp == NULL) {
5858                         VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_ioctl: ioctl <%s> "
5859                             "invalid scsi device <%s>", s, client_path));
5860                         retval = ENXIO;
5861                         break;
5862                 }
5863                 vlun = ADDR2VLUN(&devp->sd_address);
5864                 ASSERT(vlun);
5865 
5866                 /*
5867                  * Checking to see if device has only one pclass, PRIMARY.
5868                  * If so this device doesn't support failovers.  Assumed
5869                  * that the devices with one pclass is PRIMARY, as thats the
5870                  * case today.  If this is not true and in future other
5871                  * symmetric devices are supported with other pclass, this
5872                  * IOCTL shall have to be overhauled anyways as now the only
5873                  * arguments it accepts are PRIMARY and SECONDARY.
5874                  */
5875                 fo = vlun->svl_fops;
5876                 if (fo->sfo_pathclass_next(PCLASS_PRIMARY, &pclass,
5877                     vlun->svl_fops_ctpriv)) {
5878                         retval = ENOTSUP;
5879                         break;
5880                 }
5881 
5882                 VHCI_HOLD_LUN(vlun, VH_SLEEP, held);
5883                 mutex_enter(&vlun->svl_mutex);
5884                 if (vlun->svl_active_pclass != NULL) {
5885                         if (strcmp(vlun->svl_active_pclass, paddr) == 0) {
5886                                 mutex_exit(&vlun->svl_mutex);
5887                                 retval = EALREADY;
5888                                 VHCI_RELEASE_LUN(vlun);
5889                                 break;
5890                         }
5891                 }
5892                 mutex_exit(&vlun->svl_mutex);
5893                 /* Call mdi function to cause  a switch over */
5894                 retval = mdi_failover(vdip, cdip, MDI_FAILOVER_SYNC);
5895                 if (retval == MDI_SUCCESS) {
5896                         retval = 0;
5897                 } else if (retval == MDI_BUSY) {
5898                         retval = EBUSY;
5899                 } else {
5900                         retval = EIO;
5901                 }
5902                 VHCI_RELEASE_LUN(vlun);
5903                 break;
5904         }
5905 
5906         case SCSI_VHCI_PATH_ENABLE:
5907         case SCSI_VHCI_PATH_DISABLE:
5908         {
5909                 dev_info_t      *cdip, *pdip;
5910 
5911                 /*
5912                  * Get client device path from user land
5913                  */
5914                 if (vhci_ioc_get_client_path(pioc, client_path, mode, s)) {
5915                         retval = EFAULT;
5916                         break;
5917                 }
5918 
5919                 /*
5920                  * Get Phci device path from user land
5921                  */
5922                 if (vhci_ioc_get_phci_path(pioc, phci_path, mode, s)) {
5923                         retval = EFAULT;
5924                         break;
5925                 }
5926 
5927                 /*
5928                  * Get the devinfo for the Phci.
5929                  */
5930                 if ((pdip = mdi_phci_path2devinfo(vdip, phci_path)) == NULL) {
5931                         VHCI_DEBUG(1, (CE_WARN, NULL, "!vhci_ioctl: ioctl <%s> "
5932                             "phci dip doesn't exist. invalid path <%s>",
5933                             s, phci_path));
5934                         retval = ENXIO;
5935                         break;
5936                 }
5937 
5938                 /*
5939                  * If the client path is set to /scsi_vhci then we need
5940                  * to do the operation on all the clients so set cdip to NULL.
5941                  * Else, try to get the client dip.
5942                  */
5943                 if (strcmp(client_path, "/scsi_vhci") == 0) {
5944                         cdip = NULL;
5945                 } else {
5946                         if ((cdip = mdi_client_path2devinfo(vdip,
5947                             client_path)) == NULL) {
5948                                 retval = ENXIO;
5949                                 VHCI_DEBUG(1, (CE_WARN, NULL,
5950                                     "!vhci_ioctl: ioctl <%s> client dip "
5951                                     "doesn't exist. invalid path <%s>",
5952                                     s, client_path));
5953                                 break;
5954                         }
5955                 }
5956 
5957                 if (cmd == SCSI_VHCI_PATH_ENABLE)
5958                         retval = mdi_pi_enable(cdip, pdip, USER_DISABLE);
5959                 else
5960                         retval = mdi_pi_disable(cdip, pdip, USER_DISABLE);
5961 
5962                 break;
5963         }
5964 
5965         case SCSI_VHCI_GET_TARGET_LONGNAME:
5966         {
5967                 uint_t          pid = pioc->buf_elem;
5968                 char            *target_port;
5969                 mod_hash_val_t  hv;
5970 
5971                 /* targetmap lookup of 'target-port' by <pid> */
5972                 if (mod_hash_find(vhci_targetmap_bypid,
5973                     (mod_hash_key_t)(uintptr_t)pid, &hv) != 0) {
5974                         /*
5975                          * NOTE: failure to find the mapping is OK for guid
5976                          * based 'target-port' values.
5977                          */
5978                         VHCI_DEBUG(3, (CE_WARN, NULL, "!vhci_ioctl: ioctl <%s> "
5979                             "targetport mapping doesn't exist: pid %d",
5980                             s, pid));
5981                         retval = ENXIO;
5982                         break;
5983                 }
5984 
5985                 /* copyout 'target-port' result */
5986                 target_port = (char *)hv;
5987                 if (copyoutstr(target_port, pioc->addr, MAXNAMELEN, NULL)) {
5988                         VHCI_DEBUG(1, (CE_WARN, NULL, "!vhci_ioctl: ioctl <%s> "
5989                             "targetport copyout failed: len: %d",
5990                             s, (int)strlen(target_port)));
5991                         retval = EFAULT;
5992                 }
5993                 break;
5994         }
5995 
5996 #ifdef  DEBUG
5997         case SCSI_VHCI_CONFIGURE_PHCI:
5998         {
5999                 dev_info_t              *pdip;
6000 
6001                 /* Get PHCI path and device address from user land */
6002                 if (vhci_ioc_get_phci_path(pioc, phci_path, mode, s)) {
6003                         retval = EFAULT;
6004                         break;
6005                 }
6006 
6007                 VHCI_DEBUG(6, (CE_WARN, vdip, "!vhci_ioctl: ioctl <%s> "
6008                     "phci <%s>", s, phci_path));
6009 
6010                 /* Get the PHCI dip */
6011                 if ((pdip = e_ddi_hold_devi_by_path(phci_path, 0)) == NULL) {
6012                         VHCI_DEBUG(3, (CE_WARN, NULL, "!vhci_ioctl: ioctl <%s> "
6013                             "phci dip doesn't exist. invalid path <%s>",
6014                             s, phci_path));
6015                         retval = ENXIO;
6016                         break;
6017                 }
6018 
6019                 if (ndi_devi_config(pdip,
6020                     NDI_DEVFS_CLEAN|NDI_DEVI_PERSIST) != NDI_SUCCESS) {
6021                         retval = EIO;
6022                 }
6023 
6024                 ddi_release_devi(pdip);
6025                 break;
6026         }
6027 
6028         case SCSI_VHCI_UNCONFIGURE_PHCI:
6029         {
6030                 dev_info_t              *pdip;
6031 
6032                 /* Get PHCI path and device address from user land */
6033                 if (vhci_ioc_get_phci_path(pioc, phci_path, mode, s)) {
6034                         retval = EFAULT;
6035                         break;
6036                 }
6037 
6038                 VHCI_DEBUG(6, (CE_WARN, vdip, "!vhci_ioctl: ioctl <%s> "
6039                     "phci <%s>", s, phci_path));
6040 
6041                 /* Get the PHCI dip */
6042                 if ((pdip = e_ddi_hold_devi_by_path(phci_path, 0)) == NULL) {
6043                         VHCI_DEBUG(3, (CE_WARN, NULL, "!vhci_ioctl: ioctl <%s> "
6044                             "phci dip doesn't exist. invalid path <%s>",
6045                             s, phci_path));
6046                         retval = ENXIO;
6047                         break;
6048                 }
6049 
6050                 if (ndi_devi_unconfig(pdip,
6051                     NDI_DEVI_REMOVE|NDI_DEVFS_CLEAN) != NDI_SUCCESS) {
6052                         retval = EBUSY;
6053                 }
6054 
6055                 ddi_release_devi(pdip);
6056                 break;
6057         }
6058 #endif
6059         }
6060 
6061 end:
6062         /* Free the memory allocated above */
6063         if (phci_path != NULL) {
6064                 kmem_free(phci_path, MAXPATHLEN);
6065         }
6066         if (client_path != NULL) {
6067                 kmem_free(client_path, MAXPATHLEN);
6068         }
6069         if (paddr != NULL) {
6070                 kmem_free(paddr, MAXNAMELEN);
6071         }
6072         return (retval);
6073 }
6074 
6075 /*
6076  * devctl IOCTL support for client device DR
6077  */
6078 /* ARGSUSED */
6079 int
6080 vhci_devctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
6081     int *rvalp)
6082 {
6083         dev_info_t *self;
6084         dev_info_t *child;
6085         scsi_hba_tran_t *hba;
6086         struct devctl_iocdata *dcp;
6087         struct scsi_vhci *vhci;
6088         int rv = 0;
6089         int retval = 0;
6090         scsi_vhci_priv_t *svp;
6091         mdi_pathinfo_t  *pip;
6092 
6093         if ((vhci = ddi_get_soft_state(vhci_softstate,
6094             MINOR2INST(getminor(dev)))) == NULL)
6095                 return (ENXIO);
6096 
6097         /*
6098          * check if :devctl minor device has been opened
6099          */
6100         mutex_enter(&vhci->vhci_mutex);
6101         if ((vhci->vhci_state & VHCI_STATE_OPEN) == 0) {
6102                 mutex_exit(&vhci->vhci_mutex);
6103                 return (ENXIO);
6104         }
6105         mutex_exit(&vhci->vhci_mutex);
6106 
6107         self = vhci->vhci_dip;
6108         hba = ddi_get_driver_private(self);
6109         if (hba == NULL)
6110                 return (ENXIO);
6111 
6112         /*
6113          * We can use the generic implementation for these ioctls
6114          */
6115         switch (cmd) {
6116         case DEVCTL_DEVICE_GETSTATE:
6117         case DEVCTL_DEVICE_ONLINE:
6118         case DEVCTL_DEVICE_OFFLINE:
6119         case DEVCTL_DEVICE_REMOVE:
6120         case DEVCTL_BUS_GETSTATE:
6121                 return (ndi_devctl_ioctl(self, cmd, arg, mode, 0));
6122         }
6123 
6124         /*
6125          * read devctl ioctl data
6126          */
6127         if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
6128                 return (EFAULT);
6129 
6130         switch (cmd) {
6131 
6132         case DEVCTL_DEVICE_RESET:
6133                 /*
6134                  * lookup and hold child device
6135                  */
6136                 if ((child = ndi_devi_find(self, ndi_dc_getname(dcp),
6137                     ndi_dc_getaddr(dcp))) == NULL) {
6138                         rv = ENXIO;
6139                         break;
6140                 }
6141                 retval = mdi_select_path(child, NULL,
6142                     (MDI_SELECT_ONLINE_PATH | MDI_SELECT_STANDBY_PATH),
6143                     NULL, &pip);
6144                 if ((retval != MDI_SUCCESS) || (pip == NULL)) {
6145                         VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_ioctl:"
6146                             "Unable to get a path, dip 0x%p", (void *)child));
6147                         rv = ENXIO;
6148                         break;
6149                 }
6150                 svp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(pip);
6151                 if (vhci_recovery_reset(svp->svp_svl,
6152                     &svp->svp_psd->sd_address, TRUE,
6153                     VHCI_DEPTH_TARGET) == 0) {
6154                         VHCI_DEBUG(1, (CE_NOTE, NULL,
6155                             "!vhci_ioctl(pip:%p): "
6156                             "reset failed\n", (void *)pip));
6157                         rv = ENXIO;
6158                 }
6159                 mdi_rele_path(pip);
6160                 break;
6161 
6162         case DEVCTL_BUS_QUIESCE:
6163         case DEVCTL_BUS_UNQUIESCE:
6164         case DEVCTL_BUS_RESET:
6165         case DEVCTL_BUS_RESETALL:
6166 #ifdef  DEBUG
6167         case DEVCTL_BUS_CONFIGURE:
6168         case DEVCTL_BUS_UNCONFIGURE:
6169 #endif
6170                 rv = ENOTSUP;
6171                 break;
6172 
6173         default:
6174                 rv = ENOTTY;
6175         } /* end of outer switch */
6176 
6177         ndi_dc_freehdl(dcp);
6178         return (rv);
6179 }
6180 
6181 /*
6182  * Routine to get the PHCI pathname from ioctl structures in userland
6183  */
6184 /* ARGSUSED */
6185 static int
6186 vhci_ioc_get_phci_path(sv_iocdata_t *pioc, caddr_t phci_path,
6187         int mode, caddr_t s)
6188 {
6189         int retval = 0;
6190 
6191         if (ddi_copyin(pioc->phci, phci_path, MAXPATHLEN, mode)) {
6192                 VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_ioc_get_phci: ioctl <%s> "
6193                     "phci_path copyin failed", s));
6194                 retval = EFAULT;
6195         }
6196         return (retval);
6197 
6198 }
6199 
6200 
6201 /*
6202  * Routine to get the Client device pathname from ioctl structures in userland
6203  */
6204 /* ARGSUSED */
6205 static int
6206 vhci_ioc_get_client_path(sv_iocdata_t *pioc, caddr_t client_path,
6207         int mode, caddr_t s)
6208 {
6209         int retval = 0;
6210 
6211         if (ddi_copyin(pioc->client, client_path, MAXPATHLEN, mode)) {
6212                 VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_ioc_get_client: "
6213                     "ioctl <%s> client_path copyin failed", s));
6214                 retval = EFAULT;
6215         }
6216         return (retval);
6217 }
6218 
6219 
6220 /*
6221  * Routine to get physical device address from ioctl structure in userland
6222  */
6223 /* ARGSUSED */
6224 static int
6225 vhci_ioc_get_paddr(sv_iocdata_t *pioc, caddr_t paddr, int mode, caddr_t s)
6226 {
6227         int retval = 0;
6228 
6229         if (ddi_copyin(pioc->addr, paddr, MAXNAMELEN, mode)) {
6230                 VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_ioc_get_paddr: "
6231                     "ioctl <%s> device addr copyin failed", s));
6232                 retval = EFAULT;
6233         }
6234         return (retval);
6235 }
6236 
6237 
6238 /*
6239  * Routine to send client device pathname to userland.
6240  */
6241 /* ARGSUSED */
6242 static int
6243 vhci_ioc_send_client_path(caddr_t client_path, sv_iocdata_t *pioc,
6244         int mode, caddr_t s)
6245 {
6246         int retval = 0;
6247 
6248         if (ddi_copyout(client_path, pioc->client, MAXPATHLEN, mode)) {
6249                 VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_ioc_send_client: "
6250                     "ioctl <%s> client_path copyout failed", s));
6251                 retval = EFAULT;
6252         }
6253         return (retval);
6254 }
6255 
6256 
6257 /*
6258  * Routine to translated dev_info pointer (dip) to device pathname.
6259  */
6260 static void
6261 vhci_ioc_devi_to_path(dev_info_t *dip, caddr_t path)
6262 {
6263         (void) ddi_pathname(dip, path);
6264 }
6265 
6266 
6267 /*
6268  * vhci_get_phci_path_list:
6269  *              get information about devices associated with a
6270  *              given PHCI device.
6271  *
6272  * Return Values:
6273  *              path information elements
6274  */
6275 int
6276 vhci_get_phci_path_list(dev_info_t *pdip, sv_path_info_t *pibuf,
6277         uint_t num_elems)
6278 {
6279         uint_t                  count, done;
6280         mdi_pathinfo_t          *pip;
6281         sv_path_info_t          *ret_pip;
6282         int                     status;
6283         size_t                  prop_size;
6284         int                     circular;
6285 
6286         /*
6287          * Get the PHCI structure and retrieve the path information
6288          * from the GUID hash table.
6289          */
6290 
6291         ret_pip = pibuf;
6292         count = 0;
6293 
6294         ndi_devi_enter(pdip, &circular);
6295 
6296         done = (count >= num_elems);
6297         pip = mdi_get_next_client_path(pdip, NULL);
6298         while (pip && !done) {
6299                 mdi_pi_lock(pip);
6300                 (void) ddi_pathname(mdi_pi_get_phci(pip),
6301                     ret_pip->device.ret_phci);
6302                 (void) strcpy(ret_pip->ret_addr, mdi_pi_get_addr(pip));
6303                 (void) mdi_pi_get_state2(pip, &ret_pip->ret_state,
6304                     &ret_pip->ret_ext_state);
6305 
6306                 status = mdi_prop_size(pip, &prop_size);
6307                 if (status == MDI_SUCCESS && ret_pip->ret_prop.ret_buf_size) {
6308                         *ret_pip->ret_prop.ret_buf_size = (uint_t)prop_size;
6309                 }
6310 
6311 #ifdef DEBUG
6312                 if (status != MDI_SUCCESS) {
6313                         VHCI_DEBUG(2, (CE_WARN, NULL,
6314                             "!vhci_get_phci_path_list: "
6315                             "phci <%s>, prop size failure 0x%x",
6316                             ret_pip->device.ret_phci, status));
6317                 }
6318 #endif /* DEBUG */
6319 
6320 
6321                 if (status == MDI_SUCCESS && ret_pip->ret_prop.buf &&
6322                     prop_size && ret_pip->ret_prop.buf_size >= prop_size) {
6323                         status = mdi_prop_pack(pip,
6324                             &ret_pip->ret_prop.buf,
6325                             ret_pip->ret_prop.buf_size);
6326 
6327 #ifdef DEBUG
6328                         if (status != MDI_SUCCESS) {
6329                                 VHCI_DEBUG(2, (CE_WARN, NULL,
6330                                     "!vhci_get_phci_path_list: "
6331                                     "phci <%s>, prop pack failure 0x%x",
6332                                     ret_pip->device.ret_phci, status));
6333                         }
6334 #endif /* DEBUG */
6335                 }
6336 
6337                 mdi_pi_unlock(pip);
6338                 pip = mdi_get_next_client_path(pdip, pip);
6339                 ret_pip++;
6340                 count++;
6341                 done = (count >= num_elems);
6342         }
6343 
6344         ndi_devi_exit(pdip, circular);
6345 
6346         return (MDI_SUCCESS);
6347 }
6348 
6349 
6350 /*
6351  * vhci_get_client_path_list:
6352  *              get information about various paths associated with a
6353  *              given client device.
6354  *
6355  * Return Values:
6356  *              path information elements
6357  */
6358 int
6359 vhci_get_client_path_list(dev_info_t *cdip, sv_path_info_t *pibuf,
6360         uint_t num_elems)
6361 {
6362         uint_t                  count, done;
6363         mdi_pathinfo_t          *pip;
6364         sv_path_info_t          *ret_pip;
6365         int                     status;
6366         size_t                  prop_size;
6367         int                     circular;
6368 
6369         ret_pip = pibuf;
6370         count = 0;
6371 
6372         ndi_devi_enter(cdip, &circular);
6373 
6374         done = (count >= num_elems);
6375         pip = mdi_get_next_phci_path(cdip, NULL);
6376         while (pip && !done) {
6377                 mdi_pi_lock(pip);
6378                 (void) ddi_pathname(mdi_pi_get_phci(pip),
6379                     ret_pip->device.ret_phci);
6380                 (void) strcpy(ret_pip->ret_addr, mdi_pi_get_addr(pip));
6381                 (void) mdi_pi_get_state2(pip, &ret_pip->ret_state,
6382                     &ret_pip->ret_ext_state);
6383 
6384                 status = mdi_prop_size(pip, &prop_size);
6385                 if (status == MDI_SUCCESS && ret_pip->ret_prop.ret_buf_size) {
6386                         *ret_pip->ret_prop.ret_buf_size = (uint_t)prop_size;
6387                 }
6388 
6389 #ifdef DEBUG
6390                 if (status != MDI_SUCCESS) {
6391                         VHCI_DEBUG(2, (CE_WARN, NULL,
6392                             "!vhci_get_client_path_list: "
6393                             "phci <%s>, prop size failure 0x%x",
6394                             ret_pip->device.ret_phci, status));
6395                 }
6396 #endif /* DEBUG */
6397 
6398 
6399                 if (status == MDI_SUCCESS && ret_pip->ret_prop.buf &&
6400                     prop_size && ret_pip->ret_prop.buf_size >= prop_size) {
6401                         status = mdi_prop_pack(pip,
6402                             &ret_pip->ret_prop.buf,
6403                             ret_pip->ret_prop.buf_size);
6404 
6405 #ifdef DEBUG
6406                         if (status != MDI_SUCCESS) {
6407                                 VHCI_DEBUG(2, (CE_WARN, NULL,
6408                                     "!vhci_get_client_path_list: "
6409                                     "phci <%s>, prop pack failure 0x%x",
6410                                     ret_pip->device.ret_phci, status));
6411                         }
6412 #endif /* DEBUG */
6413                 }
6414 
6415                 mdi_pi_unlock(pip);
6416                 pip = mdi_get_next_phci_path(cdip, pip);
6417                 ret_pip++;
6418                 count++;
6419                 done = (count >= num_elems);
6420         }
6421 
6422         ndi_devi_exit(cdip, circular);
6423 
6424         return (MDI_SUCCESS);
6425 }
6426 
6427 
6428 /*
6429  * Routine to get ioctl argument structure from userland.
6430  */
6431 /* ARGSUSED */
6432 static int
6433 vhci_get_iocdata(const void *data, sv_iocdata_t *pioc, int mode, caddr_t s)
6434 {
6435         int     retval = 0;
6436 
6437 #ifdef  _MULTI_DATAMODEL
6438         switch (ddi_model_convert_from(mode & FMODELS)) {
6439         case DDI_MODEL_ILP32:
6440         {
6441                 sv_iocdata32_t  ioc32;
6442 
6443                 if (ddi_copyin(data, &ioc32, sizeof (ioc32), mode)) {
6444                         retval = EFAULT;
6445                         break;
6446                 }
6447                 pioc->client = (caddr_t)(uintptr_t)ioc32.client;
6448                 pioc->phci   = (caddr_t)(uintptr_t)ioc32.phci;
6449                 pioc->addr   = (caddr_t)(uintptr_t)ioc32.addr;
6450                 pioc->buf_elem       = (uint_t)ioc32.buf_elem;
6451                 pioc->ret_buf        = (sv_path_info_t *)(uintptr_t)ioc32.ret_buf;
6452                 pioc->ret_elem       = (uint_t *)(uintptr_t)ioc32.ret_elem;
6453                 break;
6454         }
6455 
6456         case DDI_MODEL_NONE:
6457                 if (ddi_copyin(data, pioc, sizeof (*pioc), mode)) {
6458                         retval = EFAULT;
6459                         break;
6460                 }
6461                 break;
6462         }
6463 #else   /* _MULTI_DATAMODEL */
6464         if (ddi_copyin(data, pioc, sizeof (*pioc), mode)) {
6465                 retval = EFAULT;
6466         }
6467 #endif  /* _MULTI_DATAMODEL */
6468 
6469 #ifdef DEBUG
6470         if (retval) {
6471                 VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_get_ioc: cmd <%s> "
6472                     "iocdata copyin failed", s));
6473         }
6474 #endif
6475 
6476         return (retval);
6477 }
6478 
6479 
6480 /*
6481  * Routine to get the ioctl argument for ioctl causing controller switchover.
6482  */
6483 /* ARGSUSED */
6484 static int
6485 vhci_get_iocswitchdata(const void *data, sv_switch_to_cntlr_iocdata_t *piocsc,
6486     int mode, caddr_t s)
6487 {
6488         int     retval = 0;
6489 
6490 #ifdef  _MULTI_DATAMODEL
6491         switch (ddi_model_convert_from(mode & FMODELS)) {
6492         case DDI_MODEL_ILP32:
6493         {
6494                 sv_switch_to_cntlr_iocdata32_t  ioc32;
6495 
6496                 if (ddi_copyin(data, &ioc32, sizeof (ioc32), mode)) {
6497                         retval = EFAULT;
6498                         break;
6499                 }
6500                 piocsc->client       = (caddr_t)(uintptr_t)ioc32.client;
6501                 piocsc->class        = (caddr_t)(uintptr_t)ioc32.class;
6502                 break;
6503         }
6504 
6505         case DDI_MODEL_NONE:
6506                 if (ddi_copyin(data, piocsc, sizeof (*piocsc), mode)) {
6507                         retval = EFAULT;
6508                 }
6509                 break;
6510         }
6511 #else   /* _MULTI_DATAMODEL */
6512         if (ddi_copyin(data, piocsc, sizeof (*piocsc), mode)) {
6513                 retval = EFAULT;
6514         }
6515 #endif  /* _MULTI_DATAMODEL */
6516 
6517 #ifdef DEBUG
6518         if (retval) {
6519                 VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_get_ioc: cmd <%s> "
6520                     "switch_to_cntlr_iocdata copyin failed", s));
6521         }
6522 #endif
6523 
6524         return (retval);
6525 }
6526 
6527 
6528 /*
6529  * Routine to allocate memory for the path information structures.
6530  * It allocates two chunks of memory - one for keeping userland
6531  * pointers/values for path information and path properties, second for
6532  * keeping allocating kernel memory for path properties. These path
6533  * properties are finally copied to userland.
6534  */
6535 /* ARGSUSED */
6536 static int
6537 vhci_ioc_alloc_pathinfo(sv_path_info_t **upibuf, sv_path_info_t **kpibuf,
6538     uint_t num_paths, sv_iocdata_t *pioc, int mode, caddr_t s)
6539 {
6540         sv_path_info_t  *pi;
6541         uint_t          bufsize;
6542         int             retval = 0;
6543         int             index;
6544 
6545         /* Allocate memory */
6546         *upibuf = (sv_path_info_t *)
6547             kmem_zalloc(sizeof (sv_path_info_t) * num_paths, KM_SLEEP);
6548         ASSERT(*upibuf != NULL);
6549         *kpibuf = (sv_path_info_t *)
6550             kmem_zalloc(sizeof (sv_path_info_t) * num_paths, KM_SLEEP);
6551         ASSERT(*kpibuf != NULL);
6552 
6553         /*
6554          * Get the path info structure from the user space.
6555          * We are interested in the following fields:
6556          *      - user size of buffer for per path properties.
6557          *      - user address of buffer for path info properties.
6558          *      - user pointer for returning actual buffer size
6559          * Keep these fields in the 'upibuf' structures.
6560          * Allocate buffer for per path info properties in kernel
6561          * structure ('kpibuf').
6562          * Size of these buffers will be equal to the size of buffers
6563          * in the user space.
6564          */
6565 #ifdef  _MULTI_DATAMODEL
6566         switch (ddi_model_convert_from(mode & FMODELS)) {
6567         case DDI_MODEL_ILP32:
6568         {
6569                 sv_path_info32_t        *src;
6570                 sv_path_info32_t        pi32;
6571 
6572                 src  = (sv_path_info32_t *)pioc->ret_buf;
6573                 pi = (sv_path_info_t *)*upibuf;
6574                 for (index = 0; index < num_paths; index++, src++, pi++) {
6575                         if (ddi_copyin(src, &pi32, sizeof (pi32), mode)) {
6576                                 retval = EFAULT;
6577                                 break;
6578                         }
6579 
6580                         pi->ret_prop.buf_size        =
6581                             (uint_t)pi32.ret_prop.buf_size;
6582                         pi->ret_prop.ret_buf_size =
6583                             (uint_t *)(uintptr_t)pi32.ret_prop.ret_buf_size;
6584                         pi->ret_prop.buf     =
6585                             (caddr_t)(uintptr_t)pi32.ret_prop.buf;
6586                 }
6587                 break;
6588         }
6589 
6590         case DDI_MODEL_NONE:
6591                 if (ddi_copyin(pioc->ret_buf, *upibuf,
6592                     sizeof (sv_path_info_t) * num_paths, mode)) {
6593                         retval = EFAULT;
6594                 }
6595                 break;
6596         }
6597 #else   /* _MULTI_DATAMODEL */
6598         if (ddi_copyin(pioc->ret_buf, *upibuf,
6599             sizeof (sv_path_info_t) * num_paths, mode)) {
6600                 retval = EFAULT;
6601         }
6602 #endif  /* _MULTI_DATAMODEL */
6603 
6604         if (retval != 0) {
6605                 VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_alloc_path_info: "
6606                     "ioctl <%s> normal: path_info copyin failed", s));
6607                 kmem_free(*upibuf, sizeof (sv_path_info_t) * num_paths);
6608                 kmem_free(*kpibuf, sizeof (sv_path_info_t) * num_paths);
6609                 *upibuf = NULL;
6610                 *kpibuf = NULL;
6611                 return (retval);
6612         }
6613 
6614         /*
6615          * Allocate memory for per path properties.
6616          */
6617         for (index = 0, pi = *kpibuf; index < num_paths; index++, pi++) {
6618                 bufsize = (*upibuf)[index].ret_prop.buf_size;
6619 
6620                 if (bufsize && bufsize <= SV_PROP_MAX_BUF_SIZE) {
6621                         pi->ret_prop.buf_size = bufsize;
6622                         pi->ret_prop.buf = (caddr_t)
6623                             kmem_zalloc(bufsize, KM_SLEEP);
6624                         ASSERT(pi->ret_prop.buf != NULL);
6625                 } else {
6626                         pi->ret_prop.buf_size = 0;
6627                         pi->ret_prop.buf = NULL;
6628                 }
6629 
6630                 if ((*upibuf)[index].ret_prop.ret_buf_size != NULL) {
6631                         pi->ret_prop.ret_buf_size = (uint_t *)kmem_zalloc(
6632                             sizeof (*pi->ret_prop.ret_buf_size), KM_SLEEP);
6633                         ASSERT(pi->ret_prop.ret_buf_size != NULL);
6634                 } else {
6635                         pi->ret_prop.ret_buf_size = NULL;
6636                 }
6637         }
6638 
6639         return (0);
6640 }
6641 
6642 
6643 /*
6644  * Routine to free memory for the path information structures.
6645  * This is the memory which was allocated earlier.
6646  */
6647 /* ARGSUSED */
6648 static void
6649 vhci_ioc_free_pathinfo(sv_path_info_t *upibuf, sv_path_info_t *kpibuf,
6650     uint_t num_paths)
6651 {
6652         sv_path_info_t  *pi;
6653         int             index;
6654 
6655         /* Free memory for per path properties */
6656         for (index = 0, pi = kpibuf; index < num_paths; index++, pi++) {
6657                 if (pi->ret_prop.ret_buf_size != NULL) {
6658                         kmem_free(pi->ret_prop.ret_buf_size,
6659                             sizeof (*pi->ret_prop.ret_buf_size));
6660                 }
6661 
6662                 if (pi->ret_prop.buf != NULL) {
6663                         kmem_free(pi->ret_prop.buf, pi->ret_prop.buf_size);
6664                 }
6665         }
6666 
6667         /* Free memory for path info structures */
6668         kmem_free(upibuf, sizeof (sv_path_info_t) * num_paths);
6669         kmem_free(kpibuf, sizeof (sv_path_info_t) * num_paths);
6670 }
6671 
6672 
6673 /*
6674  * Routine to copy path information and path properties to userland.
6675  */
6676 /* ARGSUSED */
6677 static int
6678 vhci_ioc_send_pathinfo(sv_path_info_t *upibuf, sv_path_info_t *kpibuf,
6679     uint_t num_paths, sv_iocdata_t *pioc, int mode, caddr_t s)
6680 {
6681         int                     retval = 0, index;
6682         sv_path_info_t          *upi_ptr;
6683         sv_path_info32_t        *upi32_ptr;
6684 
6685 #ifdef  _MULTI_DATAMODEL
6686         switch (ddi_model_convert_from(mode & FMODELS)) {
6687         case DDI_MODEL_ILP32:
6688                 goto copy_32bit;
6689 
6690         case DDI_MODEL_NONE:
6691                 goto copy_normal;
6692         }
6693 #else   /* _MULTI_DATAMODEL */
6694 
6695         goto copy_normal;
6696 
6697 #endif  /* _MULTI_DATAMODEL */
6698 
6699 copy_normal:
6700 
6701         /*
6702          * Copy path information and path properties to user land.
6703          * Pointer fields inside the path property structure were
6704          * saved in the 'upibuf' structure earlier.
6705          */
6706         upi_ptr = pioc->ret_buf;
6707         for (index = 0; index < num_paths; index++) {
6708                 if (ddi_copyout(kpibuf[index].device.ret_ct,
6709                     upi_ptr[index].device.ret_ct, MAXPATHLEN, mode)) {
6710                         retval = EFAULT;
6711                         break;
6712                 }
6713 
6714                 if (ddi_copyout(kpibuf[index].ret_addr,
6715                     upi_ptr[index].ret_addr, MAXNAMELEN, mode)) {
6716                         retval = EFAULT;
6717                         break;
6718                 }
6719 
6720                 if (ddi_copyout(&kpibuf[index].ret_state,
6721                     &upi_ptr[index].ret_state, sizeof (kpibuf[index].ret_state),
6722                     mode)) {
6723                         retval = EFAULT;
6724                         break;
6725                 }
6726 
6727                 if (ddi_copyout(&kpibuf[index].ret_ext_state,
6728                     &upi_ptr[index].ret_ext_state,
6729                     sizeof (kpibuf[index].ret_ext_state), mode)) {
6730                         retval = EFAULT;
6731                         break;
6732                 }
6733 
6734                 if ((kpibuf[index].ret_prop.ret_buf_size != NULL) &&
6735                     ddi_copyout(kpibuf[index].ret_prop.ret_buf_size,
6736                     upibuf[index].ret_prop.ret_buf_size,
6737                     sizeof (*upibuf[index].ret_prop.ret_buf_size), mode)) {
6738                         retval = EFAULT;
6739                         break;
6740                 }
6741 
6742                 if ((kpibuf[index].ret_prop.buf != NULL) &&
6743                     ddi_copyout(kpibuf[index].ret_prop.buf,
6744                     upibuf[index].ret_prop.buf,
6745                     upibuf[index].ret_prop.buf_size, mode)) {
6746                         retval = EFAULT;
6747                         break;
6748                 }
6749         }
6750 
6751 #ifdef DEBUG
6752         if (retval) {
6753                 VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_get_ioc: ioctl <%s> "
6754                     "normal: path_info copyout failed", s));
6755         }
6756 #endif
6757 
6758         return (retval);
6759 
6760 copy_32bit:
6761         /*
6762          * Copy path information and path properties to user land.
6763          * Pointer fields inside the path property structure were
6764          * saved in the 'upibuf' structure earlier.
6765          */
6766         upi32_ptr = (sv_path_info32_t *)pioc->ret_buf;
6767         for (index = 0; index < num_paths; index++) {
6768                 if (ddi_copyout(kpibuf[index].device.ret_ct,
6769                     upi32_ptr[index].device.ret_ct, MAXPATHLEN, mode)) {
6770                         retval = EFAULT;
6771                         break;
6772                 }
6773 
6774                 if (ddi_copyout(kpibuf[index].ret_addr,
6775                     upi32_ptr[index].ret_addr, MAXNAMELEN, mode)) {
6776                         retval = EFAULT;
6777                         break;
6778                 }
6779 
6780                 if (ddi_copyout(&kpibuf[index].ret_state,
6781                     &upi32_ptr[index].ret_state,
6782                     sizeof (kpibuf[index].ret_state), mode)) {
6783                         retval = EFAULT;
6784                         break;
6785                 }
6786 
6787                 if (ddi_copyout(&kpibuf[index].ret_ext_state,
6788                     &upi32_ptr[index].ret_ext_state,
6789                     sizeof (kpibuf[index].ret_ext_state), mode)) {
6790                         retval = EFAULT;
6791                         break;
6792                 }
6793                 if ((kpibuf[index].ret_prop.ret_buf_size != NULL) &&
6794                     ddi_copyout(kpibuf[index].ret_prop.ret_buf_size,
6795                     upibuf[index].ret_prop.ret_buf_size,
6796                     sizeof (*upibuf[index].ret_prop.ret_buf_size), mode)) {
6797                         retval = EFAULT;
6798                         break;
6799                 }
6800 
6801                 if ((kpibuf[index].ret_prop.buf != NULL) &&
6802                     ddi_copyout(kpibuf[index].ret_prop.buf,
6803                     upibuf[index].ret_prop.buf,
6804                     upibuf[index].ret_prop.buf_size, mode)) {
6805                         retval = EFAULT;
6806                         break;
6807                 }
6808         }
6809 
6810 #ifdef DEBUG
6811         if (retval) {
6812                 VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_get_ioc: ioctl <%s> "
6813                     "normal: path_info copyout failed", s));
6814         }
6815 #endif
6816 
6817         return (retval);
6818 }
6819 
6820 
6821 /*
6822  * vhci_failover()
6823  * This routine expects VHCI_HOLD_LUN before being invoked.  It can be invoked
6824  * as MDI_FAILOVER_ASYNC or MDI_FAILOVER_SYNC.  For Asynchronous failovers
6825  * this routine shall VHCI_RELEASE_LUN on exiting.  For synchronous failovers
6826  * it is the callers responsibility to release lun.
6827  */
6828 
6829 /* ARGSUSED */
6830 static int
6831 vhci_failover(dev_info_t *vdip, dev_info_t *cdip, int flags)
6832 {
6833         char                    *guid;
6834         scsi_vhci_lun_t         *vlun = NULL;
6835         struct scsi_vhci        *vhci;
6836         mdi_pathinfo_t          *pip, *npip;
6837         char                    *s_pclass, *pclass1, *pclass2, *pclass;
6838         char                    active_pclass_copy[255], *active_pclass_ptr;
6839         char                    *ptr1, *ptr2;
6840         mdi_pathinfo_state_t    pi_state;
6841         uint32_t                pi_ext_state;
6842         scsi_vhci_priv_t        *svp;
6843         struct scsi_device      *sd;
6844         struct scsi_failover_ops        *sfo;
6845         int                     sps; /* mdi_select_path() status */
6846         int                     activation_done = 0;
6847         int                     rval, retval = MDI_FAILURE;
6848         int                     reserve_pending, check_condition, UA_condition;
6849         struct scsi_pkt         *pkt;
6850         struct buf              *bp;
6851 
6852         vhci = ddi_get_soft_state(vhci_softstate, ddi_get_instance(vdip));
6853         sd = ddi_get_driver_private(cdip);
6854         vlun = ADDR2VLUN(&sd->sd_address);
6855         ASSERT(vlun != 0);
6856         ASSERT(VHCI_LUN_IS_HELD(vlun));
6857         guid = vlun->svl_lun_wwn;
6858         VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_failover(1): guid %s\n", guid));
6859         vhci_log(CE_NOTE, vdip, "!Initiating failover for device %s "
6860             "(GUID %s)", ddi_node_name(cdip), guid);
6861 
6862         /*
6863          * Lets maintain a local copy of the vlun->svl_active_pclass
6864          * for the rest of the processing. Accessing the field
6865          * directly in the loop below causes loop logic to break
6866          * especially when the field gets updated by other threads
6867          * update path status etc and causes 'paths are not currently
6868          * available' condition to be declared prematurely.
6869          */
6870         mutex_enter(&vlun->svl_mutex);
6871         if (vlun->svl_active_pclass != NULL) {
6872                 (void) strlcpy(active_pclass_copy, vlun->svl_active_pclass,
6873                     sizeof (active_pclass_copy));
6874                 active_pclass_ptr = &active_pclass_copy[0];
6875                 mutex_exit(&vlun->svl_mutex);
6876                 if (vhci_quiesce_paths(vdip, cdip, vlun, guid,
6877                     active_pclass_ptr) != 0) {
6878                         retval = MDI_FAILURE;
6879                 }
6880         } else {
6881                 /*
6882                  * can happen only when the available path to device
6883                  * discovered is a STANDBY path.
6884                  */
6885                 mutex_exit(&vlun->svl_mutex);
6886                 active_pclass_copy[0] = '\0';
6887                 active_pclass_ptr = NULL;
6888         }
6889 
6890         sfo = vlun->svl_fops;
6891         ASSERT(sfo != NULL);
6892         pclass1 = s_pclass = active_pclass_ptr;
6893         VHCI_DEBUG(1, (CE_NOTE, NULL, "!(%s)failing over from %s\n", guid,
6894             (s_pclass == NULL ? "<none>" : s_pclass)));
6895 
6896 next_pathclass:
6897 
6898         rval = sfo->sfo_pathclass_next(pclass1, &pclass2,
6899             vlun->svl_fops_ctpriv);
6900         if (rval == ENOENT) {
6901                 if (s_pclass == NULL) {
6902                         VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_failover(4)(%s): "
6903                             "failed, no more pathclasses\n", guid));
6904                         goto done;
6905                 } else {
6906                         (void) sfo->sfo_pathclass_next(NULL, &pclass2,
6907                             vlun->svl_fops_ctpriv);
6908                 }
6909         } else if (rval == EINVAL) {
6910                 vhci_log(CE_NOTE, vdip, "!Failover operation failed for "
6911                     "device %s (GUID %s): Invalid path-class %s",
6912                     ddi_node_name(cdip), guid,
6913                     ((pclass1 == NULL) ? "<none>" : pclass1));
6914                 goto done;
6915         }
6916         if ((s_pclass != NULL) && (strcmp(pclass2, s_pclass) == 0)) {
6917                 /*
6918                  * paths are not currently available
6919                  */
6920                 vhci_log(CE_NOTE, vdip, "!Failover path currently unavailable"
6921                     " for device %s (GUID %s)",
6922                     ddi_node_name(cdip), guid);
6923                 goto done;
6924         }
6925         pip = npip = NULL;
6926         VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_failover(5.2)(%s): considering "
6927             "%s as failover destination\n", guid, pclass2));
6928         sps = mdi_select_path(cdip, NULL, MDI_SELECT_STANDBY_PATH, NULL, &npip);
6929         if ((npip == NULL) || (sps != MDI_SUCCESS)) {
6930                 VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_failover(%s): no "
6931                     "STANDBY paths found (status:%x)!\n", guid, sps));
6932                 pclass1 = pclass2;
6933                 goto next_pathclass;
6934         }
6935         do {
6936                 pclass = NULL;
6937                 if ((mdi_prop_lookup_string(npip, "path-class",
6938                     &pclass) != MDI_SUCCESS) || (strcmp(pclass2,
6939                     pclass) != 0)) {
6940                         VHCI_DEBUG(1, (CE_NOTE, NULL,
6941                             "!vhci_failover(5.5)(%s): skipping path "
6942                             "%p(%s)...\n", guid, (void *)npip, pclass));
6943                         pip = npip;
6944                         sps = mdi_select_path(cdip, NULL,
6945                             MDI_SELECT_STANDBY_PATH, pip, &npip);
6946                         mdi_rele_path(pip);
6947                         (void) mdi_prop_free(pclass);
6948                         continue;
6949                 }
6950                 svp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(npip);
6951 
6952                 /*
6953                  * Issue READ at non-zer block on this STANDBY path.
6954                  * Purple returns
6955                  * 1. RESERVATION_CONFLICT if reservation is pending
6956                  * 2. POR check condition if it reset happened.
6957                  * 2. failover Check Conditions if one is already in progress.
6958                  */
6959                 reserve_pending = 0;
6960                 check_condition = 0;
6961                 UA_condition = 0;
6962 
6963                 bp = scsi_alloc_consistent_buf(&svp->svp_psd->sd_address,
6964                     (struct buf *)NULL, DEV_BSIZE, B_READ, NULL, NULL);
6965                 if (!bp) {
6966                         VHCI_DEBUG(1, (CE_NOTE, NULL,
6967                             "vhci_failover !No resources (buf)\n"));
6968                         mdi_rele_path(npip);
6969                         goto done;
6970                 }
6971                 pkt = scsi_init_pkt(&svp->svp_psd->sd_address, NULL, bp,
6972                     CDB_GROUP1, sizeof (struct scsi_arq_status), 0,
6973                     PKT_CONSISTENT, NULL, NULL);
6974                 if (pkt) {
6975                         (void) scsi_setup_cdb((union scsi_cdb *)(uintptr_t)
6976                             pkt->pkt_cdbp, SCMD_READ, 1, 1, 0);
6977                         pkt->pkt_flags = FLAG_NOINTR;
6978 check_path_again:
6979                         pkt->pkt_path_instance = mdi_pi_get_path_instance(npip);
6980                         pkt->pkt_time = 3*30;
6981 
6982                         if (scsi_transport(pkt) == TRAN_ACCEPT) {
6983                                 switch (pkt->pkt_reason) {
6984                                 case CMD_CMPLT:
6985                                         switch (SCBP_C(pkt)) {
6986                                         case STATUS_GOOD:
6987                                                 /* Already failed over */
6988                                                 activation_done = 1;
6989                                                 break;
6990                                         case STATUS_RESERVATION_CONFLICT:
6991                                                 reserve_pending = 1;
6992                                                 break;
6993                                         case STATUS_CHECK:
6994                                                 check_condition = 1;
6995                                                 break;
6996                                         }
6997                                 }
6998                         }
6999                         if (check_condition &&
7000                             (pkt->pkt_state & STATE_ARQ_DONE)) {
7001                                 uint8_t *sns, skey, asc, ascq;
7002                                 sns = (uint8_t *)
7003                                     &(((struct scsi_arq_status *)(uintptr_t)
7004                                     (pkt->pkt_scbp))->sts_sensedata);
7005                                 skey = scsi_sense_key(sns);
7006                                 asc = scsi_sense_asc(sns);
7007                                 ascq = scsi_sense_ascq(sns);
7008                                 if (skey == KEY_UNIT_ATTENTION &&
7009                                     asc == 0x29) {
7010                                         /* Already failed over */
7011                                         VHCI_DEBUG(1, (CE_NOTE, NULL,
7012                                             "!vhci_failover(7)(%s): "
7013                                             "path 0x%p POR UA condition\n",
7014                                             guid, (void *)npip));
7015                                         if (UA_condition == 0) {
7016                                                 UA_condition = 1;
7017                                                 goto check_path_again;
7018                                         }
7019                                 } else {
7020                                         activation_done = 0;
7021                                         VHCI_DEBUG(1, (CE_NOTE, NULL,
7022                                             "!vhci_failover(%s): path 0x%p "
7023                                             "unhandled chkcond %x %x %x\n",
7024                                             guid, (void *)npip, skey,
7025                                             asc, ascq));
7026                                 }
7027                         }
7028                         scsi_destroy_pkt(pkt);
7029                 }
7030                 scsi_free_consistent_buf(bp);
7031 
7032                 if (activation_done) {
7033                         mdi_rele_path(npip);
7034                         VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_failover(7)(%s): "
7035                             "path 0x%p already failedover\n", guid,
7036                             (void *)npip));
7037                         break;
7038                 }
7039                 if (reserve_pending && (vlun->svl_xlf_capable == 0)) {
7040                         (void) vhci_recovery_reset(vlun,
7041                             &svp->svp_psd->sd_address,
7042                             FALSE, VHCI_DEPTH_ALL);
7043                 }
7044                 VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_failover(6)(%s): "
7045                     "activating path 0x%p(psd:%p)\n", guid, (void *)npip,
7046                     (void *)svp->svp_psd));
7047                 if (sfo->sfo_path_activate(svp->svp_psd, pclass2,
7048                     vlun->svl_fops_ctpriv) == 0) {
7049                         activation_done = 1;
7050                         mdi_rele_path(npip);
7051                         VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_failover(7)(%s): "
7052                             "path 0x%p successfully activated\n", guid,
7053                             (void *)npip));
7054                         break;
7055                 }
7056                 pip = npip;
7057                 sps = mdi_select_path(cdip, NULL, MDI_SELECT_STANDBY_PATH,
7058                     pip, &npip);
7059                 mdi_rele_path(pip);
7060         } while ((npip != NULL) && (sps == MDI_SUCCESS));
7061         if (activation_done == 0) {
7062                 pclass1 = pclass2;
7063                 goto next_pathclass;
7064         }
7065 
7066         /*
7067          * if we are here, we have succeeded in activating path npip of
7068          * pathclass pclass2; let us validate all paths of pclass2 by
7069          * "ping"-ing each one and mark the good ones ONLINE
7070          * Also, set the state of the paths belonging to the previously
7071          * active pathclass to STANDBY
7072          */
7073         pip = npip = NULL;
7074         sps = mdi_select_path(cdip, NULL, (MDI_SELECT_ONLINE_PATH |
7075             MDI_SELECT_STANDBY_PATH | MDI_SELECT_USER_DISABLE_PATH),
7076             NULL, &npip);
7077         if (npip == NULL || sps != MDI_SUCCESS) {
7078                 VHCI_DEBUG(1, (CE_NOTE, NULL, "!Failover operation failed for "
7079                     "device %s (GUID %s): paths may be busy\n",
7080                     ddi_node_name(cdip), guid));
7081                 goto done;
7082         }
7083         do {
7084                 (void) mdi_pi_get_state2(npip, &pi_state, &pi_ext_state);
7085                 if (mdi_prop_lookup_string(npip, "path-class", &pclass)
7086                     != MDI_SUCCESS) {
7087                         pip = npip;
7088                         sps = mdi_select_path(cdip, NULL,
7089                             (MDI_SELECT_ONLINE_PATH |
7090                             MDI_SELECT_STANDBY_PATH |
7091                             MDI_SELECT_USER_DISABLE_PATH),
7092                             pip, &npip);
7093                         mdi_rele_path(pip);
7094                         continue;
7095                 }
7096                 if (strcmp(pclass, pclass2) == 0) {
7097                         if (pi_state == MDI_PATHINFO_STATE_STANDBY) {
7098                                 svp = (scsi_vhci_priv_t *)
7099                                     mdi_pi_get_vhci_private(npip);
7100                                 VHCI_DEBUG(1, (CE_NOTE, NULL,
7101                                     "!vhci_failover(8)(%s): "
7102                                     "pinging path 0x%p\n",
7103                                     guid, (void *)npip));
7104                                 if (sfo->sfo_path_ping(svp->svp_psd,
7105                                     vlun->svl_fops_ctpriv) == 1) {
7106                                         mdi_pi_set_state(npip,
7107                                             MDI_PATHINFO_STATE_ONLINE);
7108                                         VHCI_DEBUG(1, (CE_NOTE, NULL,
7109                                             "!vhci_failover(9)(%s): "
7110                                             "path 0x%p ping successful, "
7111                                             "marked online\n", guid,
7112                                             (void *)npip));
7113                                         MDI_PI_ERRSTAT(npip, MDI_PI_FAILTO);
7114                                 }
7115                         }
7116                 } else if ((s_pclass != NULL) && (strcmp(pclass, s_pclass)
7117                     == 0)) {
7118                         if (pi_state == MDI_PATHINFO_STATE_ONLINE) {
7119                                 mdi_pi_set_state(npip,
7120                                     MDI_PATHINFO_STATE_STANDBY);
7121                                 VHCI_DEBUG(1, (CE_NOTE, NULL,
7122                                     "!vhci_failover(10)(%s): path 0x%p marked "
7123                                     "STANDBY\n", guid, (void *)npip));
7124                                 MDI_PI_ERRSTAT(npip, MDI_PI_FAILFROM);
7125                         }
7126                 }
7127                 (void) mdi_prop_free(pclass);
7128                 pip = npip;
7129                 sps = mdi_select_path(cdip, NULL, (MDI_SELECT_ONLINE_PATH |
7130                     MDI_SELECT_STANDBY_PATH|MDI_SELECT_USER_DISABLE_PATH),
7131                     pip, &npip);
7132                 mdi_rele_path(pip);
7133         } while ((npip != NULL) && (sps == MDI_SUCCESS));
7134 
7135         /*
7136          * Update the AccessState of related MP-API TPGs
7137          */
7138         (void) vhci_mpapi_update_tpg_acc_state_for_lu(vhci, vlun);
7139 
7140         vhci_log(CE_NOTE, vdip, "!Failover operation completed successfully "
7141             "for device %s (GUID %s): failed over from %s to %s",
7142             ddi_node_name(cdip), guid, ((s_pclass == NULL) ? "<none>" :
7143             s_pclass), pclass2);
7144         ptr1 = kmem_alloc(strlen(pclass2)+1, KM_SLEEP);
7145         (void) strlcpy(ptr1, pclass2, (strlen(pclass2)+1));
7146         mutex_enter(&vlun->svl_mutex);
7147         ptr2 = vlun->svl_active_pclass;
7148         vlun->svl_active_pclass = ptr1;
7149         mutex_exit(&vlun->svl_mutex);
7150         if (ptr2) {
7151                 kmem_free(ptr2, strlen(ptr2)+1);
7152         }
7153         mutex_enter(&vhci->vhci_mutex);
7154         scsi_hba_reset_notify_callback(&vhci->vhci_mutex,
7155             &vhci->vhci_reset_notify_listf);
7156         /* All reservations are cleared upon these resets. */
7157         vlun->svl_flags &= ~VLUN_RESERVE_ACTIVE_FLG;
7158         mutex_exit(&vhci->vhci_mutex);
7159         VHCI_DEBUG(1, (CE_NOTE, NULL, "!vhci_failover(11): DONE! Active "
7160             "pathclass for %s is now %s\n", guid, pclass2));
7161         retval = MDI_SUCCESS;
7162 
7163 done:
7164         vlun->svl_failover_status = retval;
7165         if (flags == MDI_FAILOVER_ASYNC) {
7166                 VHCI_RELEASE_LUN(vlun);
7167                 VHCI_DEBUG(6, (CE_NOTE, NULL, "!vhci_failover(12): DONE! "
7168                     "releasing lun, as failover was ASYNC\n"));
7169         } else {
7170                 VHCI_DEBUG(6, (CE_NOTE, NULL, "!vhci_failover(12): DONE! "
7171                     "NOT releasing lun, as failover was SYNC\n"));
7172         }
7173         return (retval);
7174 }
7175 
7176 /*
7177  * vhci_client_attached is called after the successful attach of a
7178  * client devinfo node.
7179  */
7180 static void
7181 vhci_client_attached(dev_info_t *cdip)
7182 {
7183         mdi_pathinfo_t  *pip;
7184         int             circular;
7185 
7186         /*
7187          * At this point the client has attached and it's instance number is
7188          * valid, so we can set up kstats.  We need to do this here because it
7189          * is possible for paths to go online prior to client attach, in which
7190          * case the call to vhci_kstat_create_pathinfo in vhci_pathinfo_online
7191          * was a noop.
7192          */
7193         ndi_devi_enter(cdip, &circular);
7194         for (pip = mdi_get_next_phci_path(cdip, NULL); pip;
7195             pip = mdi_get_next_phci_path(cdip, pip))
7196                 vhci_kstat_create_pathinfo(pip);
7197         ndi_devi_exit(cdip, circular);
7198 }
7199 
7200 /*
7201  * quiesce all of the online paths
7202  */
7203 static int
7204 vhci_quiesce_paths(dev_info_t *vdip, dev_info_t *cdip, scsi_vhci_lun_t *vlun,
7205         char *guid, char *active_pclass_ptr)
7206 {
7207         scsi_vhci_priv_t        *svp;
7208         char                    *s_pclass = NULL;
7209         mdi_pathinfo_t          *npip, *pip;
7210         int                     sps;
7211 
7212         /* quiesce currently active paths */
7213         s_pclass = NULL;
7214         pip = npip = NULL;
7215         sps = mdi_select_path(cdip, NULL, MDI_SELECT_ONLINE_PATH, NULL, &npip);
7216         if ((npip == NULL) || (sps != MDI_SUCCESS)) {
7217                 return (1);
7218         }
7219         do {
7220                 if (mdi_prop_lookup_string(npip, "path-class",
7221                     &s_pclass) != MDI_SUCCESS) {
7222                         mdi_rele_path(npip);
7223                         vhci_log(CE_NOTE, vdip, "!Failover operation failed "
7224                             "for device %s (GUID %s) due to an internal "
7225                             "error", ddi_node_name(cdip), guid);
7226                         return (1);
7227                 }
7228                 if (strcmp(s_pclass, active_pclass_ptr) == 0) {
7229                         /*
7230                          * quiesce path. Free s_pclass since
7231                          * we don't need it anymore
7232                          */
7233                         VHCI_DEBUG(1, (CE_NOTE, NULL,
7234                             "!vhci_failover(2)(%s): failing over "
7235                             "from %s; quiescing path %p\n",
7236                             guid, s_pclass, (void *)npip));
7237                         (void) mdi_prop_free(s_pclass);
7238                         svp = (scsi_vhci_priv_t *)
7239                             mdi_pi_get_vhci_private(npip);
7240                         if (svp == NULL) {
7241                                 VHCI_DEBUG(1, (CE_NOTE, NULL,
7242                                     "!vhci_failover(2.5)(%s): no "
7243                                     "client priv! %p offlined?\n",
7244                                     guid, (void *)npip));
7245                                 pip = npip;
7246                                 sps = mdi_select_path(cdip, NULL,
7247                                     MDI_SELECT_ONLINE_PATH, pip, &npip);
7248                                 mdi_rele_path(pip);
7249                                 continue;
7250                         }
7251                         if (scsi_abort(&svp->svp_psd->sd_address, NULL)
7252                             == 0) {
7253                                 (void) vhci_recovery_reset(vlun,
7254                                     &svp->svp_psd->sd_address, FALSE,
7255                                     VHCI_DEPTH_TARGET);
7256                         }
7257                         mutex_enter(&svp->svp_mutex);
7258                         if (svp->svp_cmds == 0) {
7259                                 VHCI_DEBUG(1, (CE_NOTE, NULL,
7260                                     "!vhci_failover(3)(%s):"
7261                                     "quiesced path %p\n", guid, (void *)npip));
7262                         } else {
7263                                 while (svp->svp_cmds != 0) {
7264                                         cv_wait(&svp->svp_cv, &svp->svp_mutex);
7265                                         VHCI_DEBUG(1, (CE_NOTE, NULL,
7266                                             "!vhci_failover(3.cv)(%s):"
7267                                             "quiesced path %p\n", guid,
7268                                             (void *)npip));
7269                                 }
7270                         }
7271                         mutex_exit(&svp->svp_mutex);
7272                 } else {
7273                         /*
7274                          * make sure we freeup the memory
7275                          */
7276                         (void) mdi_prop_free(s_pclass);
7277                 }
7278                 pip = npip;
7279                 sps = mdi_select_path(cdip, NULL, MDI_SELECT_ONLINE_PATH,
7280                     pip, &npip);
7281                 mdi_rele_path(pip);
7282         } while ((npip != NULL) && (sps == MDI_SUCCESS));
7283         return (0);
7284 }
7285 
7286 static struct scsi_vhci_lun *
7287 vhci_lun_lookup(dev_info_t *tgt_dip)
7288 {
7289         return ((struct scsi_vhci_lun *)
7290             mdi_client_get_vhci_private(tgt_dip));
7291 }
7292 
7293 static struct scsi_vhci_lun *
7294 vhci_lun_lookup_alloc(dev_info_t *tgt_dip, char *guid, int *didalloc)
7295 {
7296         struct scsi_vhci_lun *svl;
7297 
7298         if (svl = vhci_lun_lookup(tgt_dip)) {
7299                 return (svl);
7300         }
7301 
7302         svl = kmem_zalloc(sizeof (*svl), KM_SLEEP);
7303         svl->svl_lun_wwn = kmem_zalloc(strlen(guid)+1, KM_SLEEP);
7304         (void) strcpy(svl->svl_lun_wwn,  guid);
7305         mutex_init(&svl->svl_mutex, NULL, MUTEX_DRIVER, NULL);
7306         cv_init(&svl->svl_cv, NULL, CV_DRIVER, NULL);
7307         sema_init(&svl->svl_pgr_sema, 1, NULL, SEMA_DRIVER, NULL);
7308         svl->svl_waiting_for_activepath = 1;
7309         svl->svl_sector_size = 1;
7310         mdi_client_set_vhci_private(tgt_dip, svl);
7311         *didalloc = 1;
7312         VHCI_DEBUG(1, (CE_NOTE, NULL,
7313             "vhci_lun_lookup_alloc: guid %s vlun 0x%p\n",
7314             guid, (void *)svl));
7315         return (svl);
7316 }
7317 
7318 static void
7319 vhci_lun_free(struct scsi_vhci_lun *dvlp, struct scsi_device *sd)
7320 {
7321         char *guid;
7322 
7323         guid = dvlp->svl_lun_wwn;
7324         ASSERT(guid != NULL);
7325         VHCI_DEBUG(4, (CE_NOTE, NULL, "!vhci_lun_free: %s\n", guid));
7326 
7327         mutex_enter(&dvlp->svl_mutex);
7328         if (dvlp->svl_active_pclass != NULL) {
7329                 kmem_free(dvlp->svl_active_pclass,
7330                     strlen(dvlp->svl_active_pclass)+1);
7331         }
7332         dvlp->svl_active_pclass = NULL;
7333         mutex_exit(&dvlp->svl_mutex);
7334 
7335         if (dvlp->svl_lun_wwn != NULL) {
7336                 kmem_free(dvlp->svl_lun_wwn, strlen(dvlp->svl_lun_wwn)+1);
7337         }
7338         dvlp->svl_lun_wwn = NULL;
7339 
7340         if (dvlp->svl_fops_name) {
7341                 kmem_free(dvlp->svl_fops_name, strlen(dvlp->svl_fops_name)+1);
7342         }
7343         dvlp->svl_fops_name = NULL;
7344 
7345         if (dvlp->svl_fops_ctpriv != NULL &&
7346             dvlp->svl_fops != NULL) {
7347                 dvlp->svl_fops->sfo_device_unprobe(sd, dvlp->svl_fops_ctpriv);
7348         }
7349 
7350         if (dvlp->svl_flags & VLUN_TASK_D_ALIVE_FLG)
7351                 taskq_destroy(dvlp->svl_taskq);
7352 
7353         mutex_destroy(&dvlp->svl_mutex);
7354         cv_destroy(&dvlp->svl_cv);
7355         sema_destroy(&dvlp->svl_pgr_sema);
7356         kmem_free(dvlp, sizeof (*dvlp));
7357         /*
7358          * vhci_lun_free may be called before the tgt_dip
7359          * initialization so check if the sd is NULL.
7360          */
7361         if (sd != NULL)
7362                 scsi_device_hba_private_set(sd, NULL);
7363 }
7364 
7365 int
7366 vhci_do_scsi_cmd(struct scsi_pkt *pkt)
7367 {
7368         int     err = 0;
7369         int     retry_cnt = 0;
7370         uint8_t *sns, skey;
7371 
7372 #ifdef DEBUG
7373         if (vhci_debug > 5) {
7374                 vhci_print_cdb(pkt->pkt_address.a_hba_tran->tran_hba_dip,
7375                     CE_WARN, "Vhci command", pkt->pkt_cdbp);
7376         }
7377 #endif
7378 
7379 retry:
7380         err = scsi_poll(pkt);
7381         if (err) {
7382                 if (pkt->pkt_cdbp[0] == SCMD_RELEASE) {
7383                         if (SCBP_C(pkt) == STATUS_RESERVATION_CONFLICT) {
7384                                 VHCI_DEBUG(1, (CE_NOTE, NULL,
7385                                     "!v_s_do_s_c: RELEASE conflict\n"));
7386                                 return (0);
7387                         }
7388                 }
7389                 if (retry_cnt++ < 6) {
7390                         VHCI_DEBUG(1, (CE_WARN, NULL,
7391                             "!v_s_do_s_c:retry packet 0x%p "
7392                             "status 0x%x reason %s",
7393                             (void *)pkt, SCBP_C(pkt),
7394                             scsi_rname(pkt->pkt_reason)));
7395                         if ((pkt->pkt_reason == CMD_CMPLT) &&
7396                             (SCBP_C(pkt) == STATUS_CHECK) &&
7397                             (pkt->pkt_state & STATE_ARQ_DONE)) {
7398                                 sns = (uint8_t *)
7399                                     &(((struct scsi_arq_status *)(uintptr_t)
7400                                     (pkt->pkt_scbp))->sts_sensedata);
7401                                 skey = scsi_sense_key(sns);
7402                                 VHCI_DEBUG(1, (CE_WARN, NULL,
7403                                     "!v_s_do_s_c:retry "
7404                                     "packet 0x%p  sense data %s", (void *)pkt,
7405                                     scsi_sname(skey)));
7406                         }
7407                         goto retry;
7408                 }
7409                 VHCI_DEBUG(1, (CE_WARN, NULL,
7410                     "!v_s_do_s_c: failed transport 0x%p 0x%x",
7411                     (void *)pkt, SCBP_C(pkt)));
7412                 return (0);
7413         }
7414 
7415         switch (pkt->pkt_reason) {
7416                 case CMD_TIMEOUT:
7417                         VHCI_DEBUG(1, (CE_WARN, NULL, "!pkt timed "
7418                             "out (pkt 0x%p)", (void *)pkt));
7419                         return (0);
7420                 case CMD_CMPLT:
7421                         switch (SCBP_C(pkt)) {
7422                                 case STATUS_GOOD:
7423                                         break;
7424                                 case STATUS_CHECK:
7425                                         if (pkt->pkt_state & STATE_ARQ_DONE) {
7426                                                 sns = (uint8_t *)&(((
7427                                                     struct scsi_arq_status *)
7428                                                     (uintptr_t)
7429                                                     (pkt->pkt_scbp))->
7430                                                     sts_sensedata);
7431                                                 skey = scsi_sense_key(sns);
7432                                                 if ((skey ==
7433                                                     KEY_UNIT_ATTENTION) ||
7434                                                     (skey ==
7435                                                     KEY_NOT_READY)) {
7436                                                         /*
7437                                                          * clear unit attn.
7438                                                          */
7439 
7440                                                         VHCI_DEBUG(1,
7441                                                             (CE_WARN, NULL,
7442                                                             "!v_s_do_s_c: "
7443                                                             "retry "
7444                                                             "packet 0x%p sense "
7445                                                             "data %s",
7446                                                             (void *)pkt,
7447                                                             scsi_sname
7448                                                             (skey)));
7449                                                         goto retry;
7450                                                 }
7451                                                 VHCI_DEBUG(4, (CE_WARN, NULL,
7452                                                     "!ARQ while "
7453                                                     "transporting "
7454                                                     "(pkt 0x%p)",
7455                                                     (void *)pkt));
7456                                                 return (0);
7457                                         }
7458                                         return (0);
7459                                 default:
7460                                         VHCI_DEBUG(1, (CE_WARN, NULL,
7461                                             "!Bad status returned "
7462                                             "(pkt 0x%p, status %x)",
7463                                             (void *)pkt, SCBP_C(pkt)));
7464                                         return (0);
7465                         }
7466                         break;
7467                 case CMD_INCOMPLETE:
7468                 case CMD_RESET:
7469                 case CMD_ABORTED:
7470                 case CMD_TRAN_ERR:
7471                         if (retry_cnt++ < 1) {
7472                                 VHCI_DEBUG(1, (CE_WARN, NULL,
7473                                     "!v_s_do_s_c: retry packet 0x%p %s",
7474                                     (void *)pkt, scsi_rname(pkt->pkt_reason)));
7475                                 goto retry;
7476                         }
7477                         /* FALLTHROUGH */
7478                 default:
7479                         VHCI_DEBUG(1, (CE_WARN, NULL, "!pkt did not "
7480                             "complete successfully (pkt 0x%p,"
7481                             "reason %x)", (void *)pkt, pkt->pkt_reason));
7482                         return (0);
7483         }
7484         return (1);
7485 }
7486 
7487 static int
7488 vhci_quiesce_lun(struct scsi_vhci_lun *vlun)
7489 {
7490         mdi_pathinfo_t          *pip, *spip;
7491         dev_info_t              *cdip;
7492         struct scsi_vhci_priv   *svp;
7493         mdi_pathinfo_state_t    pstate;
7494         uint32_t                p_ext_state;
7495         int                     circular;
7496 
7497         cdip = vlun->svl_dip;
7498         pip = spip = NULL;
7499         ndi_devi_enter(cdip, &circular);
7500         pip = mdi_get_next_phci_path(cdip, NULL);
7501         while (pip != NULL) {
7502                 (void) mdi_pi_get_state2(pip, &pstate, &p_ext_state);
7503                 if (pstate != MDI_PATHINFO_STATE_ONLINE) {
7504                         spip = pip;
7505                         pip = mdi_get_next_phci_path(cdip, spip);
7506                         continue;
7507                 }
7508                 mdi_hold_path(pip);
7509                 ndi_devi_exit(cdip, circular);
7510                 svp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(pip);
7511                 mutex_enter(&svp->svp_mutex);
7512                 while (svp->svp_cmds != 0) {
7513                         if (cv_reltimedwait(&svp->svp_cv, &svp->svp_mutex,
7514                             drv_usectohz(vhci_path_quiesce_timeout * 1000000),
7515                             TR_CLOCK_TICK) == -1) {
7516                                 mutex_exit(&svp->svp_mutex);
7517                                 mdi_rele_path(pip);
7518                                 VHCI_DEBUG(1, (CE_WARN, NULL,
7519                                     "Quiesce of lun is not successful "
7520                                     "vlun: 0x%p.", (void *)vlun));
7521                                 return (0);
7522                         }
7523                 }
7524                 mutex_exit(&svp->svp_mutex);
7525                 ndi_devi_enter(cdip, &circular);
7526                 spip = pip;
7527                 pip = mdi_get_next_phci_path(cdip, spip);
7528                 mdi_rele_path(spip);
7529         }
7530         ndi_devi_exit(cdip, circular);
7531         return (1);
7532 }
7533 
7534 static int
7535 vhci_pgr_validate_and_register(scsi_vhci_priv_t *svp)
7536 {
7537         scsi_vhci_lun_t         *vlun;
7538         vhci_prout_t            *prout;
7539         int                     rval, success;
7540         mdi_pathinfo_t          *pip, *npip;
7541         scsi_vhci_priv_t        *osvp;
7542         dev_info_t              *cdip;
7543         uchar_t                 cdb_1;
7544         uchar_t                 temp_res_key[MHIOC_RESV_KEY_SIZE];
7545 
7546 
7547         /*
7548          * see if there are any other paths available; if none,
7549          * then there is nothing to do.
7550          */
7551         cdip = svp->svp_svl->svl_dip;
7552         rval = mdi_select_path(cdip, NULL, MDI_SELECT_ONLINE_PATH |
7553             MDI_SELECT_STANDBY_PATH, NULL, &pip);
7554         if ((rval != MDI_SUCCESS) || (pip == NULL)) {
7555                 VHCI_DEBUG(4, (CE_NOTE, NULL,
7556                     "%s%d: vhci_pgr_validate_and_register: first path\n",
7557                     ddi_driver_name(cdip), ddi_get_instance(cdip)));
7558                 return (1);
7559         }
7560 
7561         vlun = svp->svp_svl;
7562         prout = &vlun->svl_prout;
7563         ASSERT(vlun->svl_pgr_active != 0);
7564 
7565         /*
7566          * When the path was busy/offlined, some other host might have
7567          * cleared this key. Validate key on some other path first.
7568          * If it fails, return failure.
7569          */
7570 
7571         npip = pip;
7572         pip = NULL;
7573         success = 0;
7574 
7575         /* Save the res key */
7576         bcopy(prout->res_key, temp_res_key, MHIOC_RESV_KEY_SIZE);
7577 
7578         /*
7579          * Sometimes CDB from application can be a Register_And_Ignore.
7580          * Instead of validation, this cdb would result in force registration.
7581          * Convert it to normal cdb for validation.
7582          * After that be sure to restore the cdb.
7583          */
7584         cdb_1 = vlun->svl_cdb[1];
7585         vlun->svl_cdb[1] &= 0xe0;
7586 
7587         do {
7588                 osvp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(npip);
7589                 if (osvp == NULL) {
7590                         VHCI_DEBUG(4, (CE_NOTE, NULL,
7591                             "vhci_pgr_validate_and_register: no "
7592                             "client priv! 0x%p offlined?\n",
7593                             (void *)npip));
7594                         goto next_path_1;
7595                 }
7596 
7597                 if (osvp == svp) {
7598                         VHCI_DEBUG(4, (CE_NOTE, NULL,
7599                             "vhci_pgr_validate_and_register: same svp 0x%p"
7600                             " npip 0x%p vlun 0x%p\n",
7601                             (void *)svp, (void *)npip, (void *)vlun));
7602                         goto next_path_1;
7603                 }
7604 
7605                 VHCI_DEBUG(4, (CE_NOTE, NULL,
7606                     "vhci_pgr_validate_and_register: First validate on"
7607                     " osvp 0x%p being done. vlun 0x%p thread 0x%p Before bcopy"
7608                     " cdb1 %x\n", (void *)osvp, (void *)vlun,
7609                     (void *)curthread, vlun->svl_cdb[1]));
7610                 vhci_print_prout_keys(vlun, "v_pgr_val_reg: before bcopy:");
7611 
7612                 bcopy(prout->service_key, prout->res_key, MHIOC_RESV_KEY_SIZE);
7613 
7614                 VHCI_DEBUG(4, (CE_WARN, NULL, "vlun 0x%p After bcopy",
7615                     (void *)vlun));
7616                 vhci_print_prout_keys(vlun, "v_pgr_val_reg: after bcopy: ");
7617 
7618                 rval = vhci_do_prout(osvp);
7619                 if (rval == 1) {
7620                         VHCI_DEBUG(4, (CE_NOTE, NULL,
7621                             "%s%d: vhci_pgr_validate_and_register: key"
7622                             " validated thread 0x%p\n", ddi_driver_name(cdip),
7623                             ddi_get_instance(cdip), (void *)curthread));
7624                         pip = npip;
7625                         success = 1;
7626                         break;
7627                 } else {
7628                         VHCI_DEBUG(4, (CE_NOTE, NULL,
7629                             "vhci_pgr_validate_and_register: First validation"
7630                             " on osvp 0x%p failed %x\n", (void *)osvp, rval));
7631                         vhci_print_prout_keys(vlun, "v_pgr_val_reg: failed:");
7632                 }
7633 
7634                 /*
7635                  * Try other paths
7636                  */
7637 next_path_1:
7638                 pip = npip;
7639                 rval = mdi_select_path(cdip, NULL,
7640                     MDI_SELECT_ONLINE_PATH|MDI_SELECT_STANDBY_PATH,
7641                     pip, &npip);
7642                 mdi_rele_path(pip);
7643         } while ((rval == MDI_SUCCESS) && (npip != NULL));
7644 
7645 
7646         /* Be sure to restore original cdb */
7647         vlun->svl_cdb[1] = cdb_1;
7648 
7649         /* Restore the res_key */
7650         bcopy(temp_res_key, prout->res_key, MHIOC_RESV_KEY_SIZE);
7651 
7652         /*
7653          * If key could not be registered on any path for the first time,
7654          * return success as online should still continue.
7655          */
7656         if (success == 0) {
7657                 return (1);
7658         }
7659 
7660         ASSERT(pip != NULL);
7661 
7662         /*
7663          * Force register on new path
7664          */
7665         cdb_1 = vlun->svl_cdb[1];            /* store the cdb */
7666 
7667         vlun->svl_cdb[1] &= 0xe0;
7668         vlun->svl_cdb[1] |= VHCI_PROUT_R_AND_IGNORE;
7669 
7670         vhci_print_prout_keys(vlun, "v_pgr_val_reg: keys before bcopy: ");
7671 
7672         bcopy(prout->active_service_key, prout->service_key,
7673             MHIOC_RESV_KEY_SIZE);
7674         bcopy(prout->active_res_key, prout->res_key, MHIOC_RESV_KEY_SIZE);
7675 
7676         vhci_print_prout_keys(vlun, "v_pgr_val_reg:keys after bcopy: ");
7677 
7678         rval = vhci_do_prout(svp);
7679         vlun->svl_cdb[1] = cdb_1;            /* restore the cdb */
7680         if (rval != 1) {
7681                 VHCI_DEBUG(4, (CE_NOTE, NULL,
7682                     "vhci_pgr_validate_and_register: register on new"
7683                     " path 0x%p svp 0x%p failed %x\n",
7684                     (void *)pip, (void *)svp, rval));
7685                 vhci_print_prout_keys(vlun, "v_pgr_val_reg: reg failed: ");
7686                 mdi_rele_path(pip);
7687                 return (0);
7688         }
7689 
7690         if (bcmp(prout->service_key, zero_key, MHIOC_RESV_KEY_SIZE) == 0) {
7691                 VHCI_DEBUG(4, (CE_NOTE, NULL,
7692                     "vhci_pgr_validate_and_register: zero service key\n"));
7693                 mdi_rele_path(pip);
7694                 return (rval);
7695         }
7696 
7697         /*
7698          * While the key was force registered, some other host might have
7699          * cleared the key. Re-validate key on another pre-existing path
7700          * before declaring success.
7701          */
7702         npip = pip;
7703         pip = NULL;
7704 
7705         /*
7706          * Sometimes CDB from application can be Register and Ignore.
7707          * Instead of validation, it would result in force registration.
7708          * Convert it to normal cdb for validation.
7709          * After that be sure to restore the cdb.
7710          */
7711         cdb_1 = vlun->svl_cdb[1];
7712         vlun->svl_cdb[1] &= 0xe0;
7713         success = 0;
7714 
7715         do {
7716                 osvp = (scsi_vhci_priv_t *)
7717                     mdi_pi_get_vhci_private(npip);
7718                 if (osvp == NULL) {
7719                         VHCI_DEBUG(4, (CE_NOTE, NULL,
7720                             "vhci_pgr_validate_and_register: no "
7721                             "client priv! 0x%p offlined?\n",
7722                             (void *)npip));
7723                         goto next_path_2;
7724                 }
7725 
7726                 if (osvp == svp) {
7727                         VHCI_DEBUG(4, (CE_NOTE, NULL,
7728                             "vhci_pgr_validate_and_register: same osvp 0x%p"
7729                             " npip 0x%p vlun 0x%p\n",
7730                             (void *)svp, (void *)npip, (void *)vlun));
7731                         goto next_path_2;
7732                 }
7733 
7734                 VHCI_DEBUG(4, (CE_NOTE, NULL,
7735                     "vhci_pgr_validate_and_register: Re-validation on"
7736                     " osvp 0x%p being done. vlun 0x%p Before bcopy cdb1 %x\n",
7737                     (void *)osvp, (void *)vlun, vlun->svl_cdb[1]));
7738                 vhci_print_prout_keys(vlun, "v_pgr_val_reg: before bcopy: ");
7739 
7740                 bcopy(prout->service_key, prout->res_key, MHIOC_RESV_KEY_SIZE);
7741 
7742                 vhci_print_prout_keys(vlun, "v_pgr_val_reg: after bcopy: ");
7743 
7744                 rval = vhci_do_prout(osvp);
7745                 if (rval == 1) {
7746                         VHCI_DEBUG(4, (CE_NOTE, NULL,
7747                             "%s%d: vhci_pgr_validate_and_register: key"
7748                             " validated thread 0x%p\n", ddi_driver_name(cdip),
7749                             ddi_get_instance(cdip), (void *)curthread));
7750                         pip = npip;
7751                         success = 1;
7752                         break;
7753                 } else {
7754                         VHCI_DEBUG(4, (CE_NOTE, NULL,
7755                             "vhci_pgr_validate_and_register: Re-validation on"
7756                             " osvp 0x%p failed %x\n", (void *)osvp, rval));
7757                         vhci_print_prout_keys(vlun,
7758                             "v_pgr_val_reg: reval failed: ");
7759                 }
7760 
7761                 /*
7762                  * Try other paths
7763                  */
7764 next_path_2:
7765                 pip = npip;
7766                 rval = mdi_select_path(cdip, NULL,
7767                     MDI_SELECT_ONLINE_PATH|MDI_SELECT_STANDBY_PATH,
7768                     pip, &npip);
7769                 mdi_rele_path(pip);
7770         } while ((rval == MDI_SUCCESS) && (npip != NULL));
7771 
7772         /* Be sure to restore original cdb */
7773         vlun->svl_cdb[1] = cdb_1;
7774 
7775         if (success == 1) {
7776                 /* Successfully validated registration */
7777                 mdi_rele_path(pip);
7778                 return (1);
7779         }
7780 
7781         VHCI_DEBUG(4, (CE_WARN, NULL, "key validation failed"));
7782 
7783         /*
7784          * key invalid, back out by registering key value of 0
7785          */
7786         VHCI_DEBUG(4, (CE_NOTE, NULL,
7787             "vhci_pgr_validate_and_register: backout on"
7788             " svp 0x%p being done\n", (void *)svp));
7789         vhci_print_prout_keys(vlun, "v_pgr_val_reg: before bcopy: ");
7790 
7791         bcopy(prout->service_key, prout->res_key, MHIOC_RESV_KEY_SIZE);
7792         bzero(prout->service_key, MHIOC_RESV_KEY_SIZE);
7793 
7794         vhci_print_prout_keys(vlun, "v_pgr_val_reg: before bcopy: ");
7795 
7796         /*
7797          * Get a new path
7798          */
7799         rval = mdi_select_path(cdip, NULL, MDI_SELECT_ONLINE_PATH |
7800             MDI_SELECT_STANDBY_PATH, NULL, &pip);
7801         if ((rval != MDI_SUCCESS) || (pip == NULL)) {
7802                 VHCI_DEBUG(4, (CE_NOTE, NULL,
7803                     "%s%d: vhci_pgr_validate_and_register: no valid pip\n",
7804                     ddi_driver_name(cdip), ddi_get_instance(cdip)));
7805                 return (0);
7806         }
7807 
7808         if ((rval = vhci_do_prout(svp)) != 1) {
7809                 VHCI_DEBUG(4, (CE_NOTE, NULL,
7810                     "vhci_pgr_validate_and_register: backout on"
7811                     " svp 0x%p failed\n", (void *)svp));
7812                 vhci_print_prout_keys(vlun, "backout failed");
7813 
7814                 VHCI_DEBUG(4, (CE_WARN, NULL,
7815                     "%s%d: vhci_pgr_validate_and_register: key"
7816                     " validation and backout failed", ddi_driver_name(cdip),
7817                     ddi_get_instance(cdip)));
7818                 if (rval == VHCI_PGR_ILLEGALOP) {
7819                         VHCI_DEBUG(4, (CE_WARN, NULL,
7820                             "%s%d: vhci_pgr_validate_and_register: key"
7821                             " already cleared", ddi_driver_name(cdip),
7822                             ddi_get_instance(cdip)));
7823                         rval = 1;
7824                 } else
7825                         rval = 0;
7826         } else {
7827                 VHCI_DEBUG(4, (CE_NOTE, NULL,
7828                     "%s%d: vhci_pgr_validate_and_register: key"
7829                     " validation failed, key backed out\n",
7830                     ddi_driver_name(cdip), ddi_get_instance(cdip)));
7831                 vhci_print_prout_keys(vlun, "v_pgr_val_reg: key backed out: ");
7832         }
7833         mdi_rele_path(pip);
7834 
7835         return (rval);
7836 }
7837 
7838 /*
7839  * taskq routine to dispatch a scsi cmd to vhci_scsi_start.  This ensures
7840  * that vhci_scsi_start is not called in interrupt context.
7841  * As the upper layer gets TRAN_ACCEPT when the command is dispatched, we
7842  * need to complete the command if something goes wrong.
7843  */
7844 static void
7845 vhci_dispatch_scsi_start(void *arg)
7846 {
7847         struct vhci_pkt *vpkt   = (struct vhci_pkt *)arg;
7848         struct scsi_pkt *tpkt   = vpkt->vpkt_tgt_pkt;
7849         int rval                = TRAN_BUSY;
7850 
7851         VHCI_DEBUG(6, (CE_NOTE, NULL, "!vhci_dispatch_scsi_start: sending"
7852             " scsi-2 reserve for 0x%p\n",
7853             (void *)ADDR2DIP(&(vpkt->vpkt_tgt_pkt->pkt_address))));
7854 
7855         /*
7856          * To prevent the taskq from being called recursively we set the
7857          * the VHCI_PKT_THRU_TASKQ bit in the vhci_pkt_states.
7858          */
7859         vpkt->vpkt_state |= VHCI_PKT_THRU_TASKQ;
7860 
7861         /*
7862          * Wait for the transport to get ready to send packets
7863          * and if it times out, it will return something other than
7864          * TRAN_BUSY. The vhci_reserve_delay may want to
7865          * get tuned for other transports and is therefore a global.
7866          * Using delay since this routine is called by taskq dispatch
7867          * and not called during interrupt context.
7868          */
7869         while ((rval = vhci_scsi_start(&(vpkt->vpkt_tgt_pkt->pkt_address),
7870             vpkt->vpkt_tgt_pkt)) == TRAN_BUSY) {
7871                 delay(drv_usectohz(vhci_reserve_delay));
7872         }
7873 
7874         switch (rval) {
7875         case TRAN_ACCEPT:
7876                 return;
7877 
7878         default:
7879                 /*
7880                  * This pkt shall be retried, and to ensure another taskq
7881                  * is dispatched for it, clear the VHCI_PKT_THRU_TASKQ
7882                  * flag.
7883                  */
7884                 vpkt->vpkt_state &= ~VHCI_PKT_THRU_TASKQ;
7885 
7886                 /* Ensure that the pkt is retried without a reset */
7887                 tpkt->pkt_reason = CMD_ABORTED;
7888                 tpkt->pkt_statistics |= STAT_ABORTED;
7889                 VHCI_DEBUG(1, (CE_WARN, NULL, "!vhci_dispatch_scsi_start: "
7890                     "TRAN_rval %d returned for dip 0x%p", rval,
7891                     (void *)ADDR2DIP(&(vpkt->vpkt_tgt_pkt->pkt_address))));
7892                 break;
7893         }
7894 
7895         /*
7896          * vpkt_org_vpkt should always be NULL here if the retry command
7897          * has been successfully dispatched.  If vpkt_org_vpkt != NULL at
7898          * this point, it is an error so restore the original vpkt and
7899          * return an error to the target driver so it can retry the
7900          * command as appropriate.
7901          */
7902         if (vpkt->vpkt_org_vpkt != NULL) {
7903                 struct vhci_pkt         *new_vpkt = vpkt;
7904                 scsi_vhci_priv_t        *svp = (scsi_vhci_priv_t *)
7905                     mdi_pi_get_vhci_private(vpkt->vpkt_path);
7906 
7907                 vpkt = vpkt->vpkt_org_vpkt;
7908 
7909                 vpkt->vpkt_tgt_pkt->pkt_reason = tpkt->pkt_reason;
7910                 vpkt->vpkt_tgt_pkt->pkt_statistics = tpkt->pkt_statistics;
7911 
7912                 vhci_scsi_destroy_pkt(&svp->svp_psd->sd_address,
7913                     new_vpkt->vpkt_tgt_pkt);
7914 
7915                 tpkt = vpkt->vpkt_tgt_pkt;
7916         }
7917 
7918         scsi_hba_pkt_comp(tpkt);
7919 }
7920 
7921 static void
7922 vhci_initiate_auto_failback(void *arg)
7923 {
7924         struct scsi_vhci_lun    *vlun = (struct scsi_vhci_lun *)arg;
7925         dev_info_t              *vdip, *cdip;
7926         int                     held;
7927 
7928         cdip = vlun->svl_dip;
7929         vdip = ddi_get_parent(cdip);
7930 
7931         VHCI_HOLD_LUN(vlun, VH_SLEEP, held);
7932 
7933         /*
7934          * Perform a final check to see if the active path class is indeed
7935          * not the preferred path class.  As in the time the auto failback
7936          * was dispatched, an external failover could have been detected.
7937          * [Some other host could have detected this condition and triggered
7938          *  the auto failback before].
7939          * In such a case if we go ahead with failover we will be negating the
7940          * whole purpose of auto failback.
7941          */
7942         mutex_enter(&vlun->svl_mutex);
7943         if (vlun->svl_active_pclass != NULL) {
7944                 char                            *best_pclass;
7945                 struct scsi_failover_ops        *fo;
7946 
7947                 fo = vlun->svl_fops;
7948 
7949                 (void) fo->sfo_pathclass_next(NULL, &best_pclass,
7950                     vlun->svl_fops_ctpriv);
7951                 if (strcmp(vlun->svl_active_pclass, best_pclass) == 0) {
7952                         mutex_exit(&vlun->svl_mutex);
7953                         VHCI_RELEASE_LUN(vlun);
7954                         VHCI_DEBUG(1, (CE_NOTE, NULL, "Not initiating "
7955                             "auto failback for %s as %s pathclass already "
7956                             "active.\n", vlun->svl_lun_wwn, best_pclass));
7957                         return;
7958                 }
7959         }
7960         mutex_exit(&vlun->svl_mutex);
7961         if (mdi_failover(vdip, vlun->svl_dip, MDI_FAILOVER_SYNC)
7962             == MDI_SUCCESS) {
7963                 vhci_log(CE_NOTE, vdip, "!Auto failback operation "
7964                     "succeeded for device %s (GUID %s)",
7965                     ddi_node_name(cdip), vlun->svl_lun_wwn);
7966         } else {
7967                 vhci_log(CE_NOTE, vdip, "!Auto failback operation "
7968                     "failed for device %s (GUID %s)",
7969                     ddi_node_name(cdip), vlun->svl_lun_wwn);
7970         }
7971         VHCI_RELEASE_LUN(vlun);
7972 }
7973 
7974 #ifdef DEBUG
7975 static void
7976 vhci_print_prin_keys(vhci_prin_readkeys_t *prin, int numkeys)
7977 {
7978         vhci_clean_print(NULL, 5, "Current PGR Keys",
7979             (uchar_t *)prin, numkeys * 8);
7980 }
7981 #endif
7982 
7983 static void
7984 vhci_print_prout_keys(scsi_vhci_lun_t *vlun, char *msg)
7985 {
7986         int                     i;
7987         vhci_prout_t            *prout;
7988         char                    buf1[4*MHIOC_RESV_KEY_SIZE + 1];
7989         char                    buf2[4*MHIOC_RESV_KEY_SIZE + 1];
7990         char                    buf3[4*MHIOC_RESV_KEY_SIZE + 1];
7991         char                    buf4[4*MHIOC_RESV_KEY_SIZE + 1];
7992 
7993         prout = &vlun->svl_prout;
7994 
7995         for (i = 0; i < MHIOC_RESV_KEY_SIZE; i++)
7996                 (void) sprintf(&buf1[4*i], "[%02x]", prout->res_key[i]);
7997         for (i = 0; i < MHIOC_RESV_KEY_SIZE; i++)
7998                 (void) sprintf(&buf2[(4*i)], "[%02x]", prout->service_key[i]);
7999         for (i = 0; i < MHIOC_RESV_KEY_SIZE; i++)
8000                 (void) sprintf(&buf3[4*i], "[%02x]", prout->active_res_key[i]);
8001         for (i = 0; i < MHIOC_RESV_KEY_SIZE; i++)
8002                 (void) sprintf(&buf4[4*i], "[%02x]",
8003                     prout->active_service_key[i]);
8004 
8005         /* Printing all in one go. Otherwise it will jumble up */
8006         VHCI_DEBUG(5, (CE_CONT, NULL, "%s vlun 0x%p, thread 0x%p\n"
8007             "res_key:          : %s\n"
8008             "service_key       : %s\n"
8009             "active_res_key    : %s\n"
8010             "active_service_key: %s\n",
8011             msg, (void *)vlun, (void *)curthread, buf1, buf2, buf3, buf4));
8012 }
8013 
8014 /*
8015  * Called from vhci_scsi_start to update the pHCI pkt with target packet.
8016  */
8017 static void
8018 vhci_update_pHCI_pkt(struct vhci_pkt *vpkt, struct scsi_pkt *pkt)
8019 {
8020 
8021         ASSERT(vpkt->vpkt_hba_pkt);
8022 
8023         vpkt->vpkt_hba_pkt->pkt_flags = pkt->pkt_flags;
8024         vpkt->vpkt_hba_pkt->pkt_flags |= FLAG_NOQUEUE;
8025 
8026         if ((vpkt->vpkt_hba_pkt->pkt_flags & FLAG_NOINTR) ||
8027             MDI_PI_IS_SUSPENDED(vpkt->vpkt_path)) {
8028                 /*
8029                  * Polled Command is requested or HBA is in
8030                  * suspended state
8031                  */
8032                 vpkt->vpkt_hba_pkt->pkt_flags |= FLAG_NOINTR;
8033                 vpkt->vpkt_hba_pkt->pkt_comp = NULL;
8034         } else {
8035                 vpkt->vpkt_hba_pkt->pkt_comp = vhci_intr;
8036         }
8037         vpkt->vpkt_hba_pkt->pkt_time = pkt->pkt_time;
8038         bcopy(pkt->pkt_cdbp, vpkt->vpkt_hba_pkt->pkt_cdbp,
8039             vpkt->vpkt_tgt_init_cdblen);
8040         vpkt->vpkt_hba_pkt->pkt_resid = pkt->pkt_resid;
8041 
8042         /* Re-initialize the following pHCI packet state information */
8043         vpkt->vpkt_hba_pkt->pkt_state = 0;
8044         vpkt->vpkt_hba_pkt->pkt_statistics = 0;
8045         vpkt->vpkt_hba_pkt->pkt_reason = 0;
8046 }
8047 
8048 static int
8049 vhci_scsi_bus_power(dev_info_t *parent, void *impl_arg, pm_bus_power_op_t op,
8050     void *arg, void *result)
8051 {
8052         int ret = DDI_SUCCESS;
8053 
8054         /*
8055          * Generic processing in MPxIO framework
8056          */
8057         ret = mdi_bus_power(parent, impl_arg, op, arg, result);
8058 
8059         switch (ret) {
8060         case MDI_SUCCESS:
8061                 ret = DDI_SUCCESS;
8062                 break;
8063         case MDI_FAILURE:
8064                 ret = DDI_FAILURE;
8065                 break;
8066         default:
8067                 break;
8068         }
8069 
8070         return (ret);
8071 }
8072 
8073 static int
8074 vhci_pHCI_cap(struct scsi_address *ap, char *cap, int val, int whom,
8075     mdi_pathinfo_t *pip)
8076 {
8077         dev_info_t              *cdip;
8078         mdi_pathinfo_t          *npip = NULL;
8079         scsi_vhci_priv_t        *svp = NULL;
8080         struct scsi_address     *pap = NULL;
8081         scsi_hba_tran_t         *hba = NULL;
8082         int                     sps;
8083         int                     mps_flag;
8084         int                     rval = 0;
8085 
8086         mps_flag = (MDI_SELECT_ONLINE_PATH | MDI_SELECT_STANDBY_PATH);
8087         if (pip) {
8088                 /*
8089                  * If the call is from vhci_pathinfo_state_change,
8090                  * then this path was busy and is becoming ready to accept IO.
8091                  */
8092                 ASSERT(ap != NULL);
8093                 hba = ap->a_hba_tran;
8094                 ASSERT(hba != NULL);
8095                 rval = scsi_ifsetcap(ap, cap, val, whom);
8096 
8097                 VHCI_DEBUG(2, (CE_NOTE, NULL,
8098                     "!vhci_pHCI_cap: only on path %p, ap %p, rval %x\n",
8099                     (void *)pip, (void *)ap, rval));
8100 
8101                 return (rval);
8102         }
8103 
8104         /*
8105          * Set capability on all the pHCIs.
8106          * If any path is busy, then the capability would be set by
8107          * vhci_pathinfo_state_change.
8108          */
8109 
8110         cdip = ADDR2DIP(ap);
8111         ASSERT(cdip != NULL);
8112         sps = mdi_select_path(cdip, NULL, mps_flag, NULL, &pip);
8113         if ((sps != MDI_SUCCESS) || (pip == NULL)) {
8114                 VHCI_DEBUG(2, (CE_WARN, NULL,
8115                     "!vhci_pHCI_cap: Unable to get a path, dip 0x%p",
8116                     (void *)cdip));
8117                 return (0);
8118         }
8119 
8120 again:
8121         svp = (scsi_vhci_priv_t *)mdi_pi_get_vhci_private(pip);
8122         if (svp == NULL) {
8123                 VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_pHCI_cap: "
8124                     "priv is NULL, pip 0x%p", (void *)pip));
8125                 mdi_rele_path(pip);
8126                 return (rval);
8127         }
8128 
8129         if (svp->svp_psd == NULL) {
8130                 VHCI_DEBUG(2, (CE_WARN, NULL, "!vhci_pHCI_cap: "
8131                     "psd is NULL, pip 0x%p, svp 0x%p",
8132                     (void *)pip, (void *)svp));
8133                 mdi_rele_path(pip);
8134                 return (rval);
8135         }
8136 
8137         pap = &svp->svp_psd->sd_address;
8138         ASSERT(pap != NULL);
8139         hba = pap->a_hba_tran;
8140         ASSERT(hba != NULL);
8141 
8142         if (hba->tran_setcap != NULL) {
8143                 rval = scsi_ifsetcap(pap, cap, val, whom);
8144 
8145                 VHCI_DEBUG(2, (CE_NOTE, NULL,
8146                     "!vhci_pHCI_cap: path %p, ap %p, rval %x\n",
8147                     (void *)pip, (void *)ap, rval));
8148 
8149                 /*
8150                  * Select next path and issue the setcap, repeat
8151                  * until all paths are exhausted
8152                  */
8153                 sps = mdi_select_path(cdip, NULL, mps_flag, pip, &npip);
8154                 if ((sps != MDI_SUCCESS) || (npip == NULL)) {
8155                         mdi_rele_path(pip);
8156                         return (1);
8157                 }
8158                 mdi_rele_path(pip);
8159                 pip = npip;
8160                 goto again;
8161         }
8162         mdi_rele_path(pip);
8163         return (rval);
8164 }
8165 
8166 static int
8167 vhci_scsi_bus_config(dev_info_t *pdip, uint_t flags, ddi_bus_config_op_t op,
8168     void *arg, dev_info_t **child)
8169 {
8170         char *guid;
8171 
8172         if (vhci_bus_config_debug)
8173                 flags |= NDI_DEVI_DEBUG;
8174 
8175         if (op == BUS_CONFIG_ONE || op == BUS_UNCONFIG_ONE)
8176                 guid = vhci_devnm_to_guid((char *)arg);
8177         else
8178                 guid = NULL;
8179 
8180         if (mdi_vhci_bus_config(pdip, flags, op, arg, child, guid)
8181             == MDI_SUCCESS)
8182                 return (NDI_SUCCESS);
8183         else
8184                 return (NDI_FAILURE);
8185 }
8186 
8187 static int
8188 vhci_scsi_bus_unconfig(dev_info_t *pdip, uint_t flags, ddi_bus_config_op_t op,
8189     void *arg)
8190 {
8191         if (vhci_bus_config_debug)
8192                 flags |= NDI_DEVI_DEBUG;
8193 
8194         return (ndi_busop_bus_unconfig(pdip, flags, op, arg));
8195 }
8196 
8197 /*
8198  * Take the original vhci_pkt, create a duplicate of the pkt for resending
8199  * as though it originated in ssd.
8200  */
8201 static struct scsi_pkt *
8202 vhci_create_retry_pkt(struct vhci_pkt *vpkt)
8203 {
8204         struct vhci_pkt *new_vpkt = NULL;
8205         struct scsi_pkt *pkt = NULL;
8206 
8207         scsi_vhci_priv_t *svp = (scsi_vhci_priv_t *)
8208             mdi_pi_get_vhci_private(vpkt->vpkt_path);
8209 
8210         /*
8211          * Ensure consistent data at completion time by setting PKT_CONSISTENT
8212          */
8213         pkt = vhci_scsi_init_pkt(&svp->svp_psd->sd_address, pkt,
8214             vpkt->vpkt_tgt_init_bp, vpkt->vpkt_tgt_init_cdblen,
8215             vpkt->vpkt_tgt_init_scblen, 0, PKT_CONSISTENT, NULL_FUNC, NULL);
8216         if (pkt != NULL) {
8217                 new_vpkt = TGTPKT2VHCIPKT(pkt);
8218 
8219                 pkt->pkt_address = vpkt->vpkt_tgt_pkt->pkt_address;
8220                 pkt->pkt_flags = vpkt->vpkt_tgt_pkt->pkt_flags;
8221                 pkt->pkt_time = vpkt->vpkt_tgt_pkt->pkt_time;
8222                 pkt->pkt_comp = vpkt->vpkt_tgt_pkt->pkt_comp;
8223 
8224                 pkt->pkt_resid = 0;
8225                 pkt->pkt_statistics = 0;
8226                 pkt->pkt_reason = 0;
8227 
8228                 bcopy(vpkt->vpkt_tgt_pkt->pkt_cdbp,
8229                     pkt->pkt_cdbp, vpkt->vpkt_tgt_init_cdblen);
8230 
8231                 /*
8232                  * Save a pointer to the original vhci_pkt
8233                  */
8234                 new_vpkt->vpkt_org_vpkt = vpkt;
8235         }
8236 
8237         return (pkt);
8238 }
8239 
8240 /*
8241  * Copy the successful completion information from the hba packet into
8242  * the original target pkt from the upper layer.  Returns the original
8243  * vpkt and destroys the new vpkt from the internal retry.
8244  */
8245 static struct vhci_pkt *
8246 vhci_sync_retry_pkt(struct vhci_pkt *vpkt)
8247 {
8248         struct vhci_pkt         *ret_vpkt = NULL;
8249         struct scsi_pkt         *tpkt = NULL;
8250         struct scsi_pkt         *hba_pkt = NULL;
8251         scsi_vhci_priv_t        *svp = (scsi_vhci_priv_t *)
8252             mdi_pi_get_vhci_private(vpkt->vpkt_path);
8253 
8254         ASSERT(vpkt->vpkt_org_vpkt != NULL);
8255         VHCI_DEBUG(0, (CE_NOTE, NULL, "vhci_sync_retry_pkt: Retry pkt "
8256             "completed successfully!\n"));
8257 
8258         ret_vpkt = vpkt->vpkt_org_vpkt;
8259         tpkt = ret_vpkt->vpkt_tgt_pkt;
8260         hba_pkt = vpkt->vpkt_hba_pkt;
8261 
8262         /*
8263          * Copy the good status into the target driver's packet
8264          */
8265         *(tpkt->pkt_scbp) = *(hba_pkt->pkt_scbp);
8266         tpkt->pkt_resid = hba_pkt->pkt_resid;
8267         tpkt->pkt_state = hba_pkt->pkt_state;
8268         tpkt->pkt_statistics = hba_pkt->pkt_statistics;
8269         tpkt->pkt_reason = hba_pkt->pkt_reason;
8270 
8271         /*
8272          * Destroy the internally created vpkt for the retry
8273          */
8274         vhci_scsi_destroy_pkt(&svp->svp_psd->sd_address,
8275             vpkt->vpkt_tgt_pkt);
8276 
8277         return (ret_vpkt);
8278 }
8279 
8280 /* restart the request sense request */
8281 static void
8282 vhci_uscsi_restart_sense(void *arg)
8283 {
8284         struct buf      *rqbp;
8285         struct buf      *bp;
8286         struct scsi_pkt *rqpkt = (struct scsi_pkt *)arg;
8287         mp_uscsi_cmd_t  *mp_uscmdp;
8288 
8289         VHCI_DEBUG(4, (CE_WARN, NULL,
8290             "vhci_uscsi_restart_sense: enter: rqpkt: %p", (void *)rqpkt));
8291 
8292         if (scsi_transport(rqpkt) != TRAN_ACCEPT) {
8293                 /* if it fails - need to wakeup the original command */
8294                 mp_uscmdp = rqpkt->pkt_private;
8295                 bp = mp_uscmdp->cmdbp;
8296                 rqbp = mp_uscmdp->rqbp;
8297                 ASSERT(mp_uscmdp && bp && rqbp);
8298                 scsi_free_consistent_buf(rqbp);
8299                 scsi_destroy_pkt(rqpkt);
8300                 bp->b_resid = bp->b_bcount;
8301                 bioerror(bp, EIO);
8302                 biodone(bp);
8303         }
8304 }
8305 
8306 /*
8307  * auto-rqsense is not enabled so we have to retrieve the request sense
8308  * manually.
8309  */
8310 static int
8311 vhci_uscsi_send_sense(struct scsi_pkt *pkt, mp_uscsi_cmd_t *mp_uscmdp)
8312 {
8313         struct buf              *rqbp, *cmdbp;
8314         struct scsi_pkt         *rqpkt;
8315         int                     rval = 0;
8316 
8317         cmdbp = mp_uscmdp->cmdbp;
8318         ASSERT(cmdbp != NULL);
8319 
8320         VHCI_DEBUG(4, (CE_WARN, NULL,
8321             "vhci_uscsi_send_sense: enter: bp: %p pkt: %p scmd: %p",
8322             (void *)cmdbp, (void *)pkt, (void *)mp_uscmdp));
8323         /* set up the packet information and cdb */
8324         if ((rqbp = scsi_alloc_consistent_buf(mp_uscmdp->ap, NULL,
8325             SENSE_LENGTH, B_READ, NULL, NULL)) == NULL) {
8326                 return (-1);
8327         }
8328 
8329         if ((rqpkt = scsi_init_pkt(mp_uscmdp->ap, NULL, rqbp,
8330             CDB_GROUP0, 1, 0, PKT_CONSISTENT, NULL, NULL)) == NULL) {
8331                 scsi_free_consistent_buf(rqbp);
8332                 return (-1);
8333         }
8334 
8335         (void) scsi_setup_cdb((union scsi_cdb *)(intptr_t)rqpkt->pkt_cdbp,
8336             SCMD_REQUEST_SENSE, 0, SENSE_LENGTH, 0);
8337 
8338         mp_uscmdp->rqbp = rqbp;
8339         rqbp->b_private = mp_uscmdp;
8340         rqpkt->pkt_flags |= FLAG_SENSING;
8341         rqpkt->pkt_time = 60;
8342         rqpkt->pkt_comp = vhci_uscsi_iodone;
8343         rqpkt->pkt_private = mp_uscmdp;
8344 
8345         /*
8346          * NOTE: This code path is related to MPAPI uscsi(7I), so path
8347          * selection is not based on path_instance.
8348          */
8349         if (scsi_pkt_allocated_correctly(rqpkt))
8350                 rqpkt->pkt_path_instance = 0;
8351 
8352         /* get her done */
8353         switch (scsi_transport(rqpkt)) {
8354         case TRAN_ACCEPT:
8355                 VHCI_DEBUG(1, (CE_NOTE, NULL, "vhci_uscsi_send_sense: "
8356                     "transport accepted."));
8357                 break;
8358         case TRAN_BUSY:
8359                 VHCI_DEBUG(1, (CE_NOTE, NULL, "vhci_uscsi_send_sense: "
8360                     "transport busy, setting timeout."));
8361                 vhci_restart_timeid = timeout(vhci_uscsi_restart_sense, rqpkt,
8362                     (drv_usectohz(5 * 1000000)));
8363                 break;
8364         default:
8365                 VHCI_DEBUG(1, (CE_NOTE, NULL, "vhci_uscsi_send_sense: "
8366                     "transport failed"));
8367                 scsi_free_consistent_buf(rqbp);
8368                 scsi_destroy_pkt(rqpkt);
8369                 rval = -1;
8370         }
8371 
8372         return (rval);
8373 }
8374 
8375 /*
8376  * done routine for the mpapi uscsi command - this is behaving as though
8377  * FLAG_DIAGNOSE is set meaning there are no retries except for a manual
8378  * request sense.
8379  */
8380 void
8381 vhci_uscsi_iodone(struct scsi_pkt *pkt)
8382 {
8383         struct buf                      *bp;
8384         mp_uscsi_cmd_t                  *mp_uscmdp;
8385         struct uscsi_cmd                *uscmdp;
8386         struct scsi_arq_status          *arqstat;
8387         int                             err;
8388 
8389         mp_uscmdp = (mp_uscsi_cmd_t *)pkt->pkt_private;
8390         uscmdp = mp_uscmdp->uscmdp;
8391         bp = mp_uscmdp->cmdbp;
8392         ASSERT(bp != NULL);
8393         VHCI_DEBUG(4, (CE_WARN, NULL,
8394             "vhci_uscsi_iodone: enter: bp: %p pkt: %p scmd: %p",
8395             (void *)bp, (void *)pkt, (void *)mp_uscmdp));
8396         /* Save the status and the residual into the uscsi_cmd struct */
8397         uscmdp->uscsi_status = ((*(pkt)->pkt_scbp) & STATUS_MASK);
8398         uscmdp->uscsi_resid = bp->b_resid;
8399 
8400         /* return on a very successful command */
8401         if (pkt->pkt_reason == CMD_CMPLT &&
8402             SCBP_C(pkt) == 0 && ((pkt->pkt_flags & FLAG_SENSING) == 0) &&
8403             pkt->pkt_resid == 0) {
8404                 mdi_pi_kstat_iosupdate(mp_uscmdp->pip, bp);
8405                 scsi_destroy_pkt(pkt);
8406                 biodone(bp);
8407                 return;
8408         }
8409         VHCI_DEBUG(4, (CE_NOTE, NULL, "iodone: reason=0x%x "
8410             " pkt_resid=%ld pkt_state: 0x%x b_count: %ld b_resid: %ld",
8411             pkt->pkt_reason, pkt->pkt_resid,
8412             pkt->pkt_state, bp->b_bcount, bp->b_resid));
8413 
8414         err = EIO;
8415 
8416         arqstat = (struct scsi_arq_status *)(intptr_t)(pkt->pkt_scbp);
8417         if (pkt->pkt_reason != CMD_CMPLT) {
8418                 /*
8419                  * The command did not complete.
8420                  */
8421                 VHCI_DEBUG(4, (CE_NOTE, NULL,
8422                     "vhci_uscsi_iodone: command did not complete."
8423                     " reason: %x flag: %x", pkt->pkt_reason, pkt->pkt_flags));
8424                 if (pkt->pkt_flags & FLAG_SENSING) {
8425                         MDI_PI_ERRSTAT(mp_uscmdp->pip, MDI_PI_TRANSERR);
8426                 } else if (pkt->pkt_reason == CMD_TIMEOUT) {
8427                         MDI_PI_ERRSTAT(mp_uscmdp->pip, MDI_PI_HARDERR);
8428                         err = ETIMEDOUT;
8429                 }
8430         } else if (pkt->pkt_state & STATE_ARQ_DONE && mp_uscmdp->arq_enabled) {
8431                 /*
8432                  * The auto-rqsense happened, and the packet has a filled-in
8433                  * scsi_arq_status structure, pointed to by pkt_scbp.
8434                  */
8435                 VHCI_DEBUG(4, (CE_NOTE, NULL,
8436                     "vhci_uscsi_iodone: received auto-requested sense"));
8437                 if (uscmdp->uscsi_flags & USCSI_RQENABLE) {
8438                         /* get the amount of data to copy into rqbuf */
8439                         int rqlen = SENSE_LENGTH - arqstat->sts_rqpkt_resid;
8440                         rqlen = min(((int)uscmdp->uscsi_rqlen), rqlen);
8441                         uscmdp->uscsi_rqresid = uscmdp->uscsi_rqlen - rqlen;
8442                         uscmdp->uscsi_rqstatus =
8443                             *((char *)&arqstat->sts_rqpkt_status);
8444                         if (uscmdp->uscsi_rqbuf && uscmdp->uscsi_rqlen &&
8445                             rqlen != 0) {
8446                                 bcopy(&(arqstat->sts_sensedata),
8447                                     uscmdp->uscsi_rqbuf, rqlen);
8448                         }
8449                         mdi_pi_kstat_iosupdate(mp_uscmdp->pip, bp);
8450                         VHCI_DEBUG(4, (CE_NOTE, NULL,
8451                             "vhci_uscsi_iodone: ARQ "
8452                             "uscsi_rqstatus=0x%x uscsi_rqresid=%d rqlen: %d "
8453                             "xfer: %d rqpkt_resid: %d\n",
8454                             uscmdp->uscsi_rqstatus, uscmdp->uscsi_rqresid,
8455                             uscmdp->uscsi_rqlen, rqlen,
8456                             arqstat->sts_rqpkt_resid));
8457                 }
8458         } else if (pkt->pkt_flags & FLAG_SENSING) {
8459                 struct buf *rqbp;
8460                 struct scsi_status *rqstatus;
8461 
8462                 rqstatus = (struct scsi_status *)pkt->pkt_scbp;
8463                 /* a manual request sense was done - get the information */
8464                 if (uscmdp->uscsi_flags & USCSI_RQENABLE) {
8465                         int rqlen = SENSE_LENGTH - pkt->pkt_resid;
8466 
8467                         rqbp = mp_uscmdp->rqbp;
8468                         /* get the amount of data to copy into rqbuf */
8469                         rqlen = min(((int)uscmdp->uscsi_rqlen), rqlen);
8470                         uscmdp->uscsi_rqresid = uscmdp->uscsi_rqlen - rqlen;
8471                         uscmdp->uscsi_rqstatus = *((char *)rqstatus);
8472                         if (uscmdp->uscsi_rqlen && uscmdp->uscsi_rqbuf) {
8473                                 bcopy(rqbp->b_un.b_addr, uscmdp->uscsi_rqbuf,
8474                                     rqlen);
8475                         }
8476                         MDI_PI_ERRSTAT(mp_uscmdp->pip, MDI_PI_TRANSERR);
8477                         scsi_free_consistent_buf(rqbp);
8478                 }
8479                 VHCI_DEBUG(4, (CE_NOTE, NULL, "vhci_uscsi_iodone: FLAG_SENSING"
8480                     "uscsi_rqstatus=0x%x uscsi_rqresid=%d\n",
8481                     uscmdp->uscsi_rqstatus, uscmdp->uscsi_rqresid));
8482         } else {
8483                 struct scsi_status *status =
8484                     (struct scsi_status *)pkt->pkt_scbp;
8485                 /*
8486                  * Command completed and we're not getting sense. Check for
8487                  * errors and decide what to do next.
8488                  */
8489                 VHCI_DEBUG(4, (CE_NOTE, NULL,
8490                     "vhci_uscsi_iodone: command appears complete: reason: %x",
8491                     pkt->pkt_reason));
8492                 if (status->sts_chk) {
8493                         /* need to manually get the request sense */
8494                         if (vhci_uscsi_send_sense(pkt, mp_uscmdp) == 0) {
8495                                 scsi_destroy_pkt(pkt);
8496                                 return;
8497                         }
8498                 } else {
8499                         VHCI_DEBUG(4, (CE_NOTE, NULL,
8500                             "vhci_chk_err: appears complete"));
8501                         err = 0;
8502                         mdi_pi_kstat_iosupdate(mp_uscmdp->pip, bp);
8503                         if (pkt->pkt_resid) {
8504                                 bp->b_resid += pkt->pkt_resid;
8505                         }
8506                 }
8507         }
8508 
8509         if (err) {
8510                 if (bp->b_resid == 0)
8511                         bp->b_resid = bp->b_bcount;
8512                 bioerror(bp, err);
8513                 bp->b_flags |= B_ERROR;
8514         }
8515 
8516         scsi_destroy_pkt(pkt);
8517         biodone(bp);
8518 
8519         VHCI_DEBUG(4, (CE_WARN, NULL, "vhci_uscsi_iodone: exit"));
8520 }
8521 
8522 /*
8523  * start routine for the mpapi uscsi command
8524  */
8525 int
8526 vhci_uscsi_iostart(struct buf *bp)
8527 {
8528         struct scsi_pkt         *pkt;
8529         struct uscsi_cmd        *uscmdp;
8530         mp_uscsi_cmd_t          *mp_uscmdp;
8531         int                     stat_size, rval;
8532         int                     retry = 0;
8533 
8534         ASSERT(bp->b_private != NULL);
8535 
8536         mp_uscmdp = (mp_uscsi_cmd_t *)bp->b_private;
8537         uscmdp = mp_uscmdp->uscmdp;
8538         if (uscmdp->uscsi_flags & USCSI_RQENABLE) {
8539                 stat_size = SENSE_LENGTH;
8540         } else {
8541                 stat_size = 1;
8542         }
8543 
8544         pkt = scsi_init_pkt(mp_uscmdp->ap, NULL, bp, uscmdp->uscsi_cdblen,
8545             stat_size, 0, 0, SLEEP_FUNC, NULL);
8546         if (pkt == NULL) {
8547                 VHCI_DEBUG(4, (CE_NOTE, NULL,
8548                     "vhci_uscsi_iostart: rval: EINVAL"));
8549                 bp->b_resid = bp->b_bcount;
8550                 uscmdp->uscsi_resid = bp->b_bcount;
8551                 bioerror(bp, EINVAL);
8552                 biodone(bp);
8553                 return (EINVAL);
8554         }
8555 
8556         pkt->pkt_time = uscmdp->uscsi_timeout;
8557         bcopy(uscmdp->uscsi_cdb, pkt->pkt_cdbp, (size_t)uscmdp->uscsi_cdblen);
8558         pkt->pkt_comp = vhci_uscsi_iodone;
8559         pkt->pkt_private = mp_uscmdp;
8560         if (uscmdp->uscsi_flags & USCSI_SILENT)
8561                 pkt->pkt_flags |= FLAG_SILENT;
8562         if (uscmdp->uscsi_flags & USCSI_ISOLATE)
8563                 pkt->pkt_flags |= FLAG_ISOLATE;
8564         if (uscmdp->uscsi_flags & USCSI_DIAGNOSE)
8565                 pkt->pkt_flags |= FLAG_DIAGNOSE;
8566         if (uscmdp->uscsi_flags & USCSI_RENEGOT) {
8567                 pkt->pkt_flags |= FLAG_RENEGOTIATE_WIDE_SYNC;
8568         }
8569         VHCI_DEBUG(4, (CE_WARN, NULL,
8570             "vhci_uscsi_iostart: ap: %p pkt: %p pcdbp: %p uscmdp: %p"
8571             " ucdbp: %p pcdblen: %d bp: %p count: %ld pip: %p"
8572             " stat_size: %d",
8573             (void *)mp_uscmdp->ap, (void *)pkt, (void *)pkt->pkt_cdbp,
8574             (void *)uscmdp, (void *)uscmdp->uscsi_cdb, pkt->pkt_cdblen,
8575             (void *)bp, bp->b_bcount, (void *)mp_uscmdp->pip, stat_size));
8576 
8577         /*
8578          * NOTE: This code path is related to MPAPI uscsi(7I), so path
8579          * selection is not based on path_instance.
8580          */
8581         if (scsi_pkt_allocated_correctly(pkt))
8582                 pkt->pkt_path_instance = 0;
8583 
8584         while (((rval = scsi_transport(pkt)) == TRAN_BUSY) &&
8585             retry < vhci_uscsi_retry_count) {
8586                 delay(drv_usectohz(vhci_uscsi_delay));
8587                 retry++;
8588         }
8589         if (retry >= vhci_uscsi_retry_count) {
8590                 VHCI_DEBUG(4, (CE_NOTE, NULL,
8591                     "vhci_uscsi_iostart: tran_busy - retry: %d", retry));
8592         }
8593         switch (rval) {
8594         case TRAN_ACCEPT:
8595                 rval =  0;
8596                 break;
8597 
8598         default:
8599                 VHCI_DEBUG(4, (CE_NOTE, NULL,
8600                     "vhci_uscsi_iostart: rval: %d count: %ld res: %ld",
8601                     rval, bp->b_bcount, bp->b_resid));
8602                 bp->b_resid = bp->b_bcount;
8603                 uscmdp->uscsi_resid = bp->b_bcount;
8604                 bioerror(bp, EIO);
8605                 scsi_destroy_pkt(pkt);
8606                 biodone(bp);
8607                 rval = EIO;
8608                 MDI_PI_ERRSTAT(mp_uscmdp->pip, MDI_PI_TRANSERR);
8609                 break;
8610         }
8611         VHCI_DEBUG(4, (CE_NOTE, NULL,
8612             "vhci_uscsi_iostart: exit: rval: %d", rval));
8613         return (rval);
8614 }
8615 
8616 /* ARGSUSED */
8617 static struct scsi_failover_ops *
8618 vhci_dev_fo(dev_info_t *vdip, struct scsi_device *psd,
8619     void **ctprivp, char **fo_namep)
8620 {
8621         struct scsi_failover_ops        *sfo;
8622         char                            *sfo_name;
8623         char                            *override;
8624         struct scsi_failover            *sf;
8625 
8626         ASSERT(psd && psd->sd_inq);
8627         if ((psd == NULL) || (psd->sd_inq == NULL)) {
8628                 VHCI_DEBUG(1, (CE_NOTE, NULL,
8629                     "!vhci_dev_fo:return NULL no scsi_device or inquiry"));
8630                 return (NULL);
8631         }
8632 
8633         /*
8634          * Determine if device is supported under scsi_vhci, and select
8635          * failover module.
8636          *
8637          * See if there is a scsi_vhci.conf file override for this devices's
8638          * VID/PID. The following values can be returned:
8639          *
8640          * NULL         If the NULL is returned then there is no scsi_vhci.conf
8641          *              override.  For NULL, we determine the failover_ops for
8642          *              this device by checking the sfo_device_probe entry
8643          *              point for each 'fops' module, in order.
8644          *
8645          *              NOTE: Correct operation may depend on module ordering
8646          *              of 'specific' (failover modules that are completely
8647          *              VID/PID table based) to 'generic' (failover modules
8648          *              that based on T10 standards like TPGS).  Currently,
8649          *              the value of 'ddi-forceload' in scsi_vhci.conf is used
8650          *              to establish the module list and probe order.
8651          *
8652          * "NONE"       If value "NONE" is returned then there is a
8653          *              scsi_vhci.conf VID/PID override to indicate the device
8654          *              should not be supported under scsi_vhci (even if there
8655          *              is an 'fops' module supporting the device).
8656          *
8657          * "<other>"      If another value is returned then that value is the
8658          *              name of the 'fops' module that should be used.
8659          */
8660         sfo = NULL;     /* "NONE" */
8661         override = scsi_get_device_type_string(
8662             "scsi-vhci-failover-override", vdip, psd);
8663         if (override == NULL) {
8664                 /* NULL: default: select based on sfo_device_probe results */
8665                 for (sf = scsi_failover_table; sf->sf_mod; sf++) {
8666                         if ((sf->sf_sfo == NULL) ||
8667                             sf->sf_sfo->sfo_device_probe(psd, psd->sd_inq,
8668                             ctprivp) == SFO_DEVICE_PROBE_PHCI)
8669                                 continue;
8670 
8671                         /* found failover module, supported under scsi_vhci */
8672                         sfo = sf->sf_sfo;
8673                         if (fo_namep && (*fo_namep == NULL)) {
8674                                 sfo_name = i_ddi_strdup(sfo->sfo_name,
8675                                     KM_SLEEP);
8676                                 *fo_namep = sfo_name;
8677                         }
8678                         break;
8679                 }
8680         } else if (strcasecmp(override, "NONE")) {
8681                 /* !"NONE": select based on driver.conf specified name */
8682                 for (sf = scsi_failover_table, sfo = NULL; sf->sf_mod; sf++) {
8683                         if ((sf->sf_sfo == NULL) ||
8684                             (sf->sf_sfo->sfo_name == NULL) ||
8685                             strcmp(override, sf->sf_sfo->sfo_name))
8686                                 continue;
8687 
8688                         /*
8689                          * NOTE: If sfo_device_probe() has side-effects,
8690                          * including setting *ctprivp, these are not going
8691                          * to occur with override config.
8692                          */
8693 
8694                         /* found failover module, supported under scsi_vhci */
8695                         sfo = sf->sf_sfo;
8696                         if (fo_namep && (*fo_namep == NULL)) {
8697                                 sfo_name = kmem_alloc(strlen("conf ") +
8698                                     strlen(sfo->sfo_name) + 1, KM_SLEEP);
8699                                 (void) sprintf(sfo_name, "conf %s",
8700                                     sfo->sfo_name);
8701                                 *fo_namep = sfo_name;
8702                         }
8703                         break;
8704                 }
8705         }
8706         if (override)
8707                 kmem_free(override, strlen(override) + 1);
8708         return (sfo);
8709 }
8710 
8711 /*
8712  * Determine the device described by cinfo should be enumerated under
8713  * the vHCI or the pHCI - if there is a failover ops then device is
8714  * supported under vHCI.  By agreement with SCSA cinfo is a pointer
8715  * to a scsi_device structure associated with a decorated pHCI probe node.
8716  */
8717 /* ARGSUSED */
8718 int
8719 vhci_is_dev_supported(dev_info_t *vdip, dev_info_t *pdip, void *cinfo)
8720 {
8721         struct scsi_device      *psd = (struct scsi_device *)cinfo;
8722 
8723         return (vhci_dev_fo(vdip, psd, NULL, NULL) ? MDI_SUCCESS : MDI_FAILURE);
8724 }
8725 
8726 
8727 #ifdef DEBUG
8728 extern struct scsi_key_strings scsi_cmds[];
8729 
8730 static char *
8731 vhci_print_scsi_cmd(char cmd)
8732 {
8733         char tmp[64];
8734         char *cpnt;
8735 
8736         cpnt = scsi_cmd_name(cmd, scsi_cmds, tmp);
8737         /* tmp goes out of scope on return and caller sees garbage */
8738         if (cpnt == tmp) {
8739                 cpnt = "Unknown Command";
8740         }
8741         return (cpnt);
8742 }
8743 
8744 extern uchar_t  scsi_cdb_size[];
8745 
8746 static void
8747 vhci_print_cdb(dev_info_t *dip, uint_t level, char *title, uchar_t *cdb)
8748 {
8749         int len = scsi_cdb_size[CDB_GROUPID(cdb[0])];
8750         char buf[256];
8751 
8752         if (level == CE_NOTE) {
8753                 vhci_log(level, dip, "path cmd %s\n",
8754                     vhci_print_scsi_cmd(*cdb));
8755                 return;
8756         }
8757 
8758         (void) sprintf(buf, "%s for cmd(%s)", title, vhci_print_scsi_cmd(*cdb));
8759         vhci_clean_print(dip, level, buf, cdb, len);
8760 }
8761 
8762 static void
8763 vhci_clean_print(dev_info_t *dev, uint_t level, char *title, uchar_t *data,
8764     int len)
8765 {
8766         int     i;
8767         int     c;
8768         char    *format;
8769         char    buf[256];
8770         uchar_t byte;
8771 
8772         (void) sprintf(buf, "%s:\n", title);
8773         vhci_log(level, dev, "%s", buf);
8774         level = CE_CONT;
8775         for (i = 0; i < len; ) {
8776                 buf[0] = 0;
8777                 for (c = 0; c < 8 && i < len; c++, i++) {
8778                         byte = (uchar_t)data[i];
8779                         if (byte < 0x10)
8780                                 format = "0x0%x ";
8781                         else
8782                                 format = "0x%x ";
8783                         (void) sprintf(&buf[(int)strlen(buf)], format, byte);
8784                 }
8785                 (void) sprintf(&buf[(int)strlen(buf)], "\n");
8786 
8787                 vhci_log(level, dev, "%s\n", buf);
8788         }
8789 }
8790 #endif
8791 static void
8792 vhci_invalidate_mpapi_lu(struct scsi_vhci *vhci, scsi_vhci_lun_t *vlun)
8793 {
8794         char                    *svl_wwn;
8795         mpapi_item_list_t       *ilist;
8796         mpapi_lu_data_t         *ld;
8797 
8798         if (vlun == NULL) {
8799                 return;
8800         } else {
8801                 svl_wwn = vlun->svl_lun_wwn;
8802         }
8803 
8804         ilist = vhci->mp_priv->obj_hdr_list[MP_OBJECT_TYPE_MULTIPATH_LU]->head;
8805 
8806         while (ilist != NULL) {
8807                 ld = (mpapi_lu_data_t *)(ilist->item->idata);
8808                 if ((ld != NULL) && (strncmp(ld->prop.name, svl_wwn,
8809                     strlen(svl_wwn)) == 0)) {
8810                         ld->valid = 0;
8811                         VHCI_DEBUG(6, (CE_WARN, NULL,
8812                             "vhci_invalidate_mpapi_lu: "
8813                             "Invalidated LU(%s)", svl_wwn));
8814                         return;
8815                 }
8816                 ilist = ilist->next;
8817         }
8818         VHCI_DEBUG(6, (CE_WARN, NULL, "vhci_invalidate_mpapi_lu: "
8819             "Could not find LU(%s) to invalidate.", svl_wwn));
8820 }