1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25 /*
  26  * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
  27  * Copyright (c) 2011 Bayard G. Bell.  All rights reserved.
  28  * Copyright (c) 2012 by Delphix. All rights reserved.
  29  */
  30 /*
  31  * Copyright 2011 cyril.galibern@opensvc.com
  32  */
  33 
  34 /*
  35  * SCSI disk target driver.
  36  */
  37 #include <sys/scsi/scsi.h>
  38 #include <sys/dkbad.h>
  39 #include <sys/dklabel.h>
  40 #include <sys/dkio.h>
  41 #include <sys/fdio.h>
  42 #include <sys/cdio.h>
  43 #include <sys/mhd.h>
  44 #include <sys/vtoc.h>
  45 #include <sys/dktp/fdisk.h>
  46 #include <sys/kstat.h>
  47 #include <sys/vtrace.h>
  48 #include <sys/note.h>
  49 #include <sys/thread.h>
  50 #include <sys/proc.h>
  51 #include <sys/efi_partition.h>
  52 #include <sys/var.h>
  53 #include <sys/aio_req.h>
  54 
  55 #ifdef __lock_lint
  56 #define _LP64
  57 #define __amd64
  58 #endif
  59 
  60 #if (defined(__fibre))
  61 /* Note: is there a leadville version of the following? */
  62 #include <sys/fc4/fcal_linkapp.h>
  63 #endif
  64 #include <sys/taskq.h>
  65 #include <sys/uuid.h>
  66 #include <sys/byteorder.h>
  67 #include <sys/sdt.h>
  68 
  69 #include "sd_xbuf.h"
  70 
  71 #include <sys/scsi/targets/sddef.h>
  72 #include <sys/cmlb.h>
  73 #include <sys/sysevent/eventdefs.h>
  74 #include <sys/sysevent/dev.h>
  75 
  76 #include <sys/fm/protocol.h>
  77 
  78 /*
  79  * Loadable module info.
  80  */
  81 #if (defined(__fibre))
  82 #define SD_MODULE_NAME  "SCSI SSA/FCAL Disk Driver"
  83 #else /* !__fibre */
  84 #define SD_MODULE_NAME  "SCSI Disk Driver"
  85 #endif /* !__fibre */
  86 
  87 /*
  88  * Define the interconnect type, to allow the driver to distinguish
  89  * between parallel SCSI (sd) and fibre channel (ssd) behaviors.
  90  *
  91  * This is really for backward compatibility. In the future, the driver
  92  * should actually check the "interconnect-type" property as reported by
  93  * the HBA; however at present this property is not defined by all HBAs,
  94  * so we will use this #define (1) to permit the driver to run in
  95  * backward-compatibility mode; and (2) to print a notification message
  96  * if an FC HBA does not support the "interconnect-type" property.  The
  97  * behavior of the driver will be to assume parallel SCSI behaviors unless
  98  * the "interconnect-type" property is defined by the HBA **AND** has a
  99  * value of either INTERCONNECT_FIBRE, INTERCONNECT_SSA, or
 100  * INTERCONNECT_FABRIC, in which case the driver will assume Fibre
 101  * Channel behaviors (as per the old ssd).  (Note that the
 102  * INTERCONNECT_1394 and INTERCONNECT_USB types are not supported and
 103  * will result in the driver assuming parallel SCSI behaviors.)
 104  *
 105  * (see common/sys/scsi/impl/services.h)
 106  *
 107  * Note: For ssd semantics, don't use INTERCONNECT_FABRIC as the default
 108  * since some FC HBAs may already support that, and there is some code in
 109  * the driver that already looks for it.  Using INTERCONNECT_FABRIC as the
 110  * default would confuse that code, and besides things should work fine
 111  * anyways if the FC HBA already reports INTERCONNECT_FABRIC for the
 112  * "interconnect_type" property.
 113  *
 114  */
 115 #if (defined(__fibre))
 116 #define SD_DEFAULT_INTERCONNECT_TYPE    SD_INTERCONNECT_FIBRE
 117 #else
 118 #define SD_DEFAULT_INTERCONNECT_TYPE    SD_INTERCONNECT_PARALLEL
 119 #endif
 120 
 121 /*
 122  * The name of the driver, established from the module name in _init.
 123  */
 124 static  char *sd_label                  = NULL;
 125 
 126 /*
 127  * Driver name is unfortunately prefixed on some driver.conf properties.
 128  */
 129 #if (defined(__fibre))
 130 #define sd_max_xfer_size                ssd_max_xfer_size
 131 #define sd_config_list                  ssd_config_list
 132 static  char *sd_max_xfer_size          = "ssd_max_xfer_size";
 133 static  char *sd_config_list            = "ssd-config-list";
 134 #else
 135 static  char *sd_max_xfer_size          = "sd_max_xfer_size";
 136 static  char *sd_config_list            = "sd-config-list";
 137 #endif
 138 
 139 /*
 140  * Driver global variables
 141  */
 142 
 143 #if (defined(__fibre))
 144 /*
 145  * These #defines are to avoid namespace collisions that occur because this
 146  * code is currently used to compile two separate driver modules: sd and ssd.
 147  * All global variables need to be treated this way (even if declared static)
 148  * in order to allow the debugger to resolve the names properly.
 149  * It is anticipated that in the near future the ssd module will be obsoleted,
 150  * at which time this namespace issue should go away.
 151  */
 152 #define sd_state                        ssd_state
 153 #define sd_io_time                      ssd_io_time
 154 #define sd_failfast_enable              ssd_failfast_enable
 155 #define sd_ua_retry_count               ssd_ua_retry_count
 156 #define sd_report_pfa                   ssd_report_pfa
 157 #define sd_max_throttle                 ssd_max_throttle
 158 #define sd_min_throttle                 ssd_min_throttle
 159 #define sd_rot_delay                    ssd_rot_delay
 160 
 161 #define sd_retry_on_reservation_conflict        \
 162                                         ssd_retry_on_reservation_conflict
 163 #define sd_reinstate_resv_delay         ssd_reinstate_resv_delay
 164 #define sd_resv_conflict_name           ssd_resv_conflict_name
 165 
 166 #define sd_component_mask               ssd_component_mask
 167 #define sd_level_mask                   ssd_level_mask
 168 #define sd_debug_un                     ssd_debug_un
 169 #define sd_error_level                  ssd_error_level
 170 
 171 #define sd_xbuf_active_limit            ssd_xbuf_active_limit
 172 #define sd_xbuf_reserve_limit           ssd_xbuf_reserve_limit
 173 
 174 #define sd_tr                           ssd_tr
 175 #define sd_reset_throttle_timeout       ssd_reset_throttle_timeout
 176 #define sd_qfull_throttle_timeout       ssd_qfull_throttle_timeout
 177 #define sd_qfull_throttle_enable        ssd_qfull_throttle_enable
 178 #define sd_check_media_time             ssd_check_media_time
 179 #define sd_wait_cmds_complete           ssd_wait_cmds_complete
 180 #define sd_label_mutex                  ssd_label_mutex
 181 #define sd_detach_mutex                 ssd_detach_mutex
 182 #define sd_log_buf                      ssd_log_buf
 183 #define sd_log_mutex                    ssd_log_mutex
 184 
 185 #define sd_disk_table                   ssd_disk_table
 186 #define sd_disk_table_size              ssd_disk_table_size
 187 #define sd_sense_mutex                  ssd_sense_mutex
 188 #define sd_cdbtab                       ssd_cdbtab
 189 
 190 #define sd_cb_ops                       ssd_cb_ops
 191 #define sd_ops                          ssd_ops
 192 #define sd_additional_codes             ssd_additional_codes
 193 #define sd_tgops                        ssd_tgops
 194 
 195 #define sd_minor_data                   ssd_minor_data
 196 #define sd_minor_data_efi               ssd_minor_data_efi
 197 
 198 #define sd_tq                           ssd_tq
 199 #define sd_wmr_tq                       ssd_wmr_tq
 200 #define sd_taskq_name                   ssd_taskq_name
 201 #define sd_wmr_taskq_name               ssd_wmr_taskq_name
 202 #define sd_taskq_minalloc               ssd_taskq_minalloc
 203 #define sd_taskq_maxalloc               ssd_taskq_maxalloc
 204 
 205 #define sd_dump_format_string           ssd_dump_format_string
 206 
 207 #define sd_iostart_chain                ssd_iostart_chain
 208 #define sd_iodone_chain                 ssd_iodone_chain
 209 
 210 #define sd_pm_idletime                  ssd_pm_idletime
 211 
 212 #define sd_force_pm_supported           ssd_force_pm_supported
 213 
 214 #define sd_dtype_optical_bind           ssd_dtype_optical_bind
 215 
 216 #define sd_ssc_init                     ssd_ssc_init
 217 #define sd_ssc_send                     ssd_ssc_send
 218 #define sd_ssc_fini                     ssd_ssc_fini
 219 #define sd_ssc_assessment               ssd_ssc_assessment
 220 #define sd_ssc_post                     ssd_ssc_post
 221 #define sd_ssc_print                    ssd_ssc_print
 222 #define sd_ssc_ereport_post             ssd_ssc_ereport_post
 223 #define sd_ssc_set_info                 ssd_ssc_set_info
 224 #define sd_ssc_extract_info             ssd_ssc_extract_info
 225 
 226 #endif
 227 
 228 #ifdef  SDDEBUG
 229 int     sd_force_pm_supported           = 0;
 230 #endif  /* SDDEBUG */
 231 
 232 void *sd_state                          = NULL;
 233 int sd_io_time                          = SD_IO_TIME;
 234 int sd_failfast_enable                  = 1;
 235 int sd_ua_retry_count                   = SD_UA_RETRY_COUNT;
 236 int sd_report_pfa                       = 1;
 237 int sd_max_throttle                     = SD_MAX_THROTTLE;
 238 int sd_min_throttle                     = SD_MIN_THROTTLE;
 239 int sd_rot_delay                        = 4; /* Default 4ms Rotation delay */
 240 int sd_qfull_throttle_enable            = TRUE;
 241 
 242 int sd_retry_on_reservation_conflict    = 1;
 243 int sd_reinstate_resv_delay             = SD_REINSTATE_RESV_DELAY;
 244 _NOTE(SCHEME_PROTECTS_DATA("safe sharing", sd_reinstate_resv_delay))
 245 
 246 static int sd_dtype_optical_bind        = -1;
 247 
 248 /* Note: the following is not a bug, it really is "sd_" and not "ssd_" */
 249 static  char *sd_resv_conflict_name     = "sd_retry_on_reservation_conflict";
 250 
 251 /*
 252  * Global data for debug logging. To enable debug printing, sd_component_mask
 253  * and sd_level_mask should be set to the desired bit patterns as outlined in
 254  * sddef.h.
 255  */
 256 uint_t  sd_component_mask               = 0x0;
 257 uint_t  sd_level_mask                   = 0x0;
 258 struct  sd_lun *sd_debug_un             = NULL;
 259 uint_t  sd_error_level                  = SCSI_ERR_RETRYABLE;
 260 
 261 /* Note: these may go away in the future... */
 262 static uint32_t sd_xbuf_active_limit    = 512;
 263 static uint32_t sd_xbuf_reserve_limit   = 16;
 264 
 265 static struct sd_resv_reclaim_request   sd_tr = { NULL, NULL, NULL, 0, 0, 0 };
 266 
 267 /*
 268  * Timer value used to reset the throttle after it has been reduced
 269  * (typically in response to TRAN_BUSY or STATUS_QFULL)
 270  */
 271 static int sd_reset_throttle_timeout    = SD_RESET_THROTTLE_TIMEOUT;
 272 static int sd_qfull_throttle_timeout    = SD_QFULL_THROTTLE_TIMEOUT;
 273 
 274 /*
 275  * Interval value associated with the media change scsi watch.
 276  */
 277 static int sd_check_media_time          = 3000000;
 278 
 279 /*
 280  * Wait value used for in progress operations during a DDI_SUSPEND
 281  */
 282 static int sd_wait_cmds_complete        = SD_WAIT_CMDS_COMPLETE;
 283 
 284 /*
 285  * sd_label_mutex protects a static buffer used in the disk label
 286  * component of the driver
 287  */
 288 static kmutex_t sd_label_mutex;
 289 
 290 /*
 291  * sd_detach_mutex protects un_layer_count, un_detach_count, and
 292  * un_opens_in_progress in the sd_lun structure.
 293  */
 294 static kmutex_t sd_detach_mutex;
 295 
 296 _NOTE(MUTEX_PROTECTS_DATA(sd_detach_mutex,
 297         sd_lun::{un_layer_count un_detach_count un_opens_in_progress}))
 298 
 299 /*
 300  * Global buffer and mutex for debug logging
 301  */
 302 static char     sd_log_buf[1024];
 303 static kmutex_t sd_log_mutex;
 304 
 305 /*
 306  * Structs and globals for recording attached lun information.
 307  * This maintains a chain. Each node in the chain represents a SCSI controller.
 308  * The structure records the number of luns attached to each target connected
 309  * with the controller.
 310  * For parallel scsi device only.
 311  */
 312 struct sd_scsi_hba_tgt_lun {
 313         struct sd_scsi_hba_tgt_lun      *next;
 314         dev_info_t                      *pdip;
 315         int                             nlun[NTARGETS_WIDE];
 316 };
 317 
 318 /*
 319  * Flag to indicate the lun is attached or detached
 320  */
 321 #define SD_SCSI_LUN_ATTACH      0
 322 #define SD_SCSI_LUN_DETACH      1
 323 
 324 static kmutex_t sd_scsi_target_lun_mutex;
 325 static struct sd_scsi_hba_tgt_lun       *sd_scsi_target_lun_head = NULL;
 326 
 327 _NOTE(MUTEX_PROTECTS_DATA(sd_scsi_target_lun_mutex,
 328     sd_scsi_hba_tgt_lun::next sd_scsi_hba_tgt_lun::pdip))
 329 
 330 _NOTE(MUTEX_PROTECTS_DATA(sd_scsi_target_lun_mutex,
 331     sd_scsi_target_lun_head))
 332 
 333 /*
 334  * "Smart" Probe Caching structs, globals, #defines, etc.
 335  * For parallel scsi and non-self-identify device only.
 336  */
 337 
 338 /*
 339  * The following resources and routines are implemented to support
 340  * "smart" probing, which caches the scsi_probe() results in an array,
 341  * in order to help avoid long probe times.
 342  */
 343 struct sd_scsi_probe_cache {
 344         struct  sd_scsi_probe_cache     *next;
 345         dev_info_t      *pdip;
 346         int             cache[NTARGETS_WIDE];
 347 };
 348 
 349 static kmutex_t sd_scsi_probe_cache_mutex;
 350 static struct   sd_scsi_probe_cache *sd_scsi_probe_cache_head = NULL;
 351 
 352 /*
 353  * Really we only need protection on the head of the linked list, but
 354  * better safe than sorry.
 355  */
 356 _NOTE(MUTEX_PROTECTS_DATA(sd_scsi_probe_cache_mutex,
 357     sd_scsi_probe_cache::next sd_scsi_probe_cache::pdip))
 358 
 359 _NOTE(MUTEX_PROTECTS_DATA(sd_scsi_probe_cache_mutex,
 360     sd_scsi_probe_cache_head))
 361 
 362 /*
 363  * Power attribute table
 364  */
 365 static sd_power_attr_ss sd_pwr_ss = {
 366         { "NAME=spindle-motor", "0=off", "1=on", NULL },
 367         {0, 100},
 368         {30, 0},
 369         {20000, 0}
 370 };
 371 
 372 static sd_power_attr_pc sd_pwr_pc = {
 373         { "NAME=spindle-motor", "0=stopped", "1=standby", "2=idle",
 374                 "3=active", NULL },
 375         {0, 0, 0, 100},
 376         {90, 90, 20, 0},
 377         {15000, 15000, 1000, 0}
 378 };
 379 
 380 /*
 381  * Power level to power condition
 382  */
 383 static int sd_pl2pc[] = {
 384         SD_TARGET_START_VALID,
 385         SD_TARGET_STANDBY,
 386         SD_TARGET_IDLE,
 387         SD_TARGET_ACTIVE
 388 };
 389 
 390 /*
 391  * Vendor specific data name property declarations
 392  */
 393 
 394 #if defined(__fibre) || defined(__i386) ||defined(__amd64)
 395 
 396 static sd_tunables seagate_properties = {
 397         SEAGATE_THROTTLE_VALUE,
 398         0,
 399         0,
 400         0,
 401         0,
 402         0,
 403         0,
 404         0,
 405         0
 406 };
 407 
 408 
 409 static sd_tunables fujitsu_properties = {
 410         FUJITSU_THROTTLE_VALUE,
 411         0,
 412         0,
 413         0,
 414         0,
 415         0,
 416         0,
 417         0,
 418         0
 419 };
 420 
 421 static sd_tunables ibm_properties = {
 422         IBM_THROTTLE_VALUE,
 423         0,
 424         0,
 425         0,
 426         0,
 427         0,
 428         0,
 429         0,
 430         0
 431 };
 432 
 433 static sd_tunables purple_properties = {
 434         PURPLE_THROTTLE_VALUE,
 435         0,
 436         0,
 437         PURPLE_BUSY_RETRIES,
 438         PURPLE_RESET_RETRY_COUNT,
 439         PURPLE_RESERVE_RELEASE_TIME,
 440         0,
 441         0,
 442         0
 443 };
 444 
 445 static sd_tunables sve_properties = {
 446         SVE_THROTTLE_VALUE,
 447         0,
 448         0,
 449         SVE_BUSY_RETRIES,
 450         SVE_RESET_RETRY_COUNT,
 451         SVE_RESERVE_RELEASE_TIME,
 452         SVE_MIN_THROTTLE_VALUE,
 453         SVE_DISKSORT_DISABLED_FLAG,
 454         0
 455 };
 456 
 457 static sd_tunables maserati_properties = {
 458         0,
 459         0,
 460         0,
 461         0,
 462         0,
 463         0,
 464         0,
 465         MASERATI_DISKSORT_DISABLED_FLAG,
 466         MASERATI_LUN_RESET_ENABLED_FLAG
 467 };
 468 
 469 static sd_tunables pirus_properties = {
 470         PIRUS_THROTTLE_VALUE,
 471         0,
 472         PIRUS_NRR_COUNT,
 473         PIRUS_BUSY_RETRIES,
 474         PIRUS_RESET_RETRY_COUNT,
 475         0,
 476         PIRUS_MIN_THROTTLE_VALUE,
 477         PIRUS_DISKSORT_DISABLED_FLAG,
 478         PIRUS_LUN_RESET_ENABLED_FLAG
 479 };
 480 
 481 #endif
 482 
 483 #if (defined(__sparc) && !defined(__fibre)) || \
 484         (defined(__i386) || defined(__amd64))
 485 
 486 
 487 static sd_tunables elite_properties = {
 488         ELITE_THROTTLE_VALUE,
 489         0,
 490         0,
 491         0,
 492         0,
 493         0,
 494         0,
 495         0,
 496         0
 497 };
 498 
 499 static sd_tunables st31200n_properties = {
 500         ST31200N_THROTTLE_VALUE,
 501         0,
 502         0,
 503         0,
 504         0,
 505         0,
 506         0,
 507         0,
 508         0
 509 };
 510 
 511 #endif /* Fibre or not */
 512 
 513 static sd_tunables lsi_properties_scsi = {
 514         LSI_THROTTLE_VALUE,
 515         0,
 516         LSI_NOTREADY_RETRIES,
 517         0,
 518         0,
 519         0,
 520         0,
 521         0,
 522         0
 523 };
 524 
 525 static sd_tunables symbios_properties = {
 526         SYMBIOS_THROTTLE_VALUE,
 527         0,
 528         SYMBIOS_NOTREADY_RETRIES,
 529         0,
 530         0,
 531         0,
 532         0,
 533         0,
 534         0
 535 };
 536 
 537 static sd_tunables lsi_properties = {
 538         0,
 539         0,
 540         LSI_NOTREADY_RETRIES,
 541         0,
 542         0,
 543         0,
 544         0,
 545         0,
 546         0
 547 };
 548 
 549 static sd_tunables lsi_oem_properties = {
 550         0,
 551         0,
 552         LSI_OEM_NOTREADY_RETRIES,
 553         0,
 554         0,
 555         0,
 556         0,
 557         0,
 558         0,
 559         1
 560 };
 561 
 562 
 563 
 564 #if (defined(SD_PROP_TST))
 565 
 566 #define SD_TST_CTYPE_VAL        CTYPE_CDROM
 567 #define SD_TST_THROTTLE_VAL     16
 568 #define SD_TST_NOTREADY_VAL     12
 569 #define SD_TST_BUSY_VAL         60
 570 #define SD_TST_RST_RETRY_VAL    36
 571 #define SD_TST_RSV_REL_TIME     60
 572 
 573 static sd_tunables tst_properties = {
 574         SD_TST_THROTTLE_VAL,
 575         SD_TST_CTYPE_VAL,
 576         SD_TST_NOTREADY_VAL,
 577         SD_TST_BUSY_VAL,
 578         SD_TST_RST_RETRY_VAL,
 579         SD_TST_RSV_REL_TIME,
 580         0,
 581         0,
 582         0
 583 };
 584 #endif
 585 
 586 /* This is similar to the ANSI toupper implementation */
 587 #define SD_TOUPPER(C)   (((C) >= 'a' && (C) <= 'z') ? (C) - 'a' + 'A' : (C))
 588 
 589 /*
 590  * Static Driver Configuration Table
 591  *
 592  * This is the table of disks which need throttle adjustment (or, perhaps
 593  * something else as defined by the flags at a future time.)  device_id
 594  * is a string consisting of concatenated vid (vendor), pid (product/model)
 595  * and revision strings as defined in the scsi_inquiry structure.  Offsets of
 596  * the parts of the string are as defined by the sizes in the scsi_inquiry
 597  * structure.  Device type is searched as far as the device_id string is
 598  * defined.  Flags defines which values are to be set in the driver from the
 599  * properties list.
 600  *
 601  * Entries below which begin and end with a "*" are a special case.
 602  * These do not have a specific vendor, and the string which follows
 603  * can appear anywhere in the 16 byte PID portion of the inquiry data.
 604  *
 605  * Entries below which begin and end with a " " (blank) are a special
 606  * case. The comparison function will treat multiple consecutive blanks
 607  * as equivalent to a single blank. For example, this causes a
 608  * sd_disk_table entry of " NEC CDROM " to match a device's id string
 609  * of  "NEC       CDROM".
 610  *
 611  * Note: The MD21 controller type has been obsoleted.
 612  *       ST318202F is a Legacy device
 613  *       MAM3182FC, MAM3364FC, MAM3738FC do not appear to have ever been
 614  *       made with an FC connection. The entries here are a legacy.
 615  */
 616 static sd_disk_config_t sd_disk_table[] = {
 617 #if defined(__fibre) || defined(__i386) || defined(__amd64)
 618         { "SEAGATE ST34371FC", SD_CONF_BSET_THROTTLE, &seagate_properties },
 619         { "SEAGATE ST19171FC", SD_CONF_BSET_THROTTLE, &seagate_properties },
 620         { "SEAGATE ST39102FC", SD_CONF_BSET_THROTTLE, &seagate_properties },
 621         { "SEAGATE ST39103FC", SD_CONF_BSET_THROTTLE, &seagate_properties },
 622         { "SEAGATE ST118273F", SD_CONF_BSET_THROTTLE, &seagate_properties },
 623         { "SEAGATE ST318202F", SD_CONF_BSET_THROTTLE, &seagate_properties },
 624         { "SEAGATE ST318203F", SD_CONF_BSET_THROTTLE, &seagate_properties },
 625         { "SEAGATE ST136403F", SD_CONF_BSET_THROTTLE, &seagate_properties },
 626         { "SEAGATE ST318304F", SD_CONF_BSET_THROTTLE, &seagate_properties },
 627         { "SEAGATE ST336704F", SD_CONF_BSET_THROTTLE, &seagate_properties },
 628         { "SEAGATE ST373405F", SD_CONF_BSET_THROTTLE, &seagate_properties },
 629         { "SEAGATE ST336605F", SD_CONF_BSET_THROTTLE, &seagate_properties },
 630         { "SEAGATE ST336752F", SD_CONF_BSET_THROTTLE, &seagate_properties },
 631         { "SEAGATE ST318452F", SD_CONF_BSET_THROTTLE, &seagate_properties },
 632         { "FUJITSU MAG3091F",  SD_CONF_BSET_THROTTLE, &fujitsu_properties },
 633         { "FUJITSU MAG3182F",  SD_CONF_BSET_THROTTLE, &fujitsu_properties },
 634         { "FUJITSU MAA3182F",  SD_CONF_BSET_THROTTLE, &fujitsu_properties },
 635         { "FUJITSU MAF3364F",  SD_CONF_BSET_THROTTLE, &fujitsu_properties },
 636         { "FUJITSU MAL3364F",  SD_CONF_BSET_THROTTLE, &fujitsu_properties },
 637         { "FUJITSU MAL3738F",  SD_CONF_BSET_THROTTLE, &fujitsu_properties },
 638         { "FUJITSU MAM3182FC",  SD_CONF_BSET_THROTTLE, &fujitsu_properties },
 639         { "FUJITSU MAM3364FC",  SD_CONF_BSET_THROTTLE, &fujitsu_properties },
 640         { "FUJITSU MAM3738FC",  SD_CONF_BSET_THROTTLE, &fujitsu_properties },
 641         { "IBM     DDYFT1835",  SD_CONF_BSET_THROTTLE, &ibm_properties },
 642         { "IBM     DDYFT3695",  SD_CONF_BSET_THROTTLE, &ibm_properties },
 643         { "IBM     IC35LF2D2",  SD_CONF_BSET_THROTTLE, &ibm_properties },
 644         { "IBM     IC35LF2PR",  SD_CONF_BSET_THROTTLE, &ibm_properties },
 645         { "IBM     1724-100",   SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 646         { "IBM     1726-2xx",   SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 647         { "IBM     1726-22x",   SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 648         { "IBM     1726-4xx",   SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 649         { "IBM     1726-42x",   SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 650         { "IBM     1726-3xx",   SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 651         { "IBM     3526",       SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 652         { "IBM     3542",       SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 653         { "IBM     3552",       SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 654         { "IBM     1722",       SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 655         { "IBM     1742",       SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 656         { "IBM     1815",       SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 657         { "IBM     FAStT",      SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 658         { "IBM     1814",       SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 659         { "IBM     1814-200",   SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 660         { "IBM     1818",       SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 661         { "DELL    MD3000",     SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 662         { "DELL    MD3000i",    SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 663         { "LSI     INF",        SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 664         { "ENGENIO INF",        SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 665         { "SGI     TP",         SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 666         { "SGI     IS",         SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 667         { "*CSM100_*",          SD_CONF_BSET_NRR_COUNT |
 668                         SD_CONF_BSET_CACHE_IS_NV, &lsi_oem_properties },
 669         { "*CSM200_*",          SD_CONF_BSET_NRR_COUNT |
 670                         SD_CONF_BSET_CACHE_IS_NV, &lsi_oem_properties },
 671         { "Fujitsu SX300",      SD_CONF_BSET_THROTTLE,  &lsi_oem_properties },
 672         { "LSI",                SD_CONF_BSET_NRR_COUNT, &lsi_properties },
 673         { "SUN     T3", SD_CONF_BSET_THROTTLE |
 674                         SD_CONF_BSET_BSY_RETRY_COUNT|
 675                         SD_CONF_BSET_RST_RETRIES|
 676                         SD_CONF_BSET_RSV_REL_TIME,
 677                 &purple_properties },
 678         { "SUN     SESS01", SD_CONF_BSET_THROTTLE |
 679                 SD_CONF_BSET_BSY_RETRY_COUNT|
 680                 SD_CONF_BSET_RST_RETRIES|
 681                 SD_CONF_BSET_RSV_REL_TIME|
 682                 SD_CONF_BSET_MIN_THROTTLE|
 683                 SD_CONF_BSET_DISKSORT_DISABLED,
 684                 &sve_properties },
 685         { "SUN     T4", SD_CONF_BSET_THROTTLE |
 686                         SD_CONF_BSET_BSY_RETRY_COUNT|
 687                         SD_CONF_BSET_RST_RETRIES|
 688                         SD_CONF_BSET_RSV_REL_TIME,
 689                 &purple_properties },
 690         { "SUN     SVE01", SD_CONF_BSET_DISKSORT_DISABLED |
 691                 SD_CONF_BSET_LUN_RESET_ENABLED,
 692                 &maserati_properties },
 693         { "SUN     SE6920", SD_CONF_BSET_THROTTLE |
 694                 SD_CONF_BSET_NRR_COUNT|
 695                 SD_CONF_BSET_BSY_RETRY_COUNT|
 696                 SD_CONF_BSET_RST_RETRIES|
 697                 SD_CONF_BSET_MIN_THROTTLE|
 698                 SD_CONF_BSET_DISKSORT_DISABLED|
 699                 SD_CONF_BSET_LUN_RESET_ENABLED,
 700                 &pirus_properties },
 701         { "SUN     SE6940", SD_CONF_BSET_THROTTLE |
 702                 SD_CONF_BSET_NRR_COUNT|
 703                 SD_CONF_BSET_BSY_RETRY_COUNT|
 704                 SD_CONF_BSET_RST_RETRIES|
 705                 SD_CONF_BSET_MIN_THROTTLE|
 706                 SD_CONF_BSET_DISKSORT_DISABLED|
 707                 SD_CONF_BSET_LUN_RESET_ENABLED,
 708                 &pirus_properties },
 709         { "SUN     StorageTek 6920", SD_CONF_BSET_THROTTLE |
 710                 SD_CONF_BSET_NRR_COUNT|
 711                 SD_CONF_BSET_BSY_RETRY_COUNT|
 712                 SD_CONF_BSET_RST_RETRIES|
 713                 SD_CONF_BSET_MIN_THROTTLE|
 714                 SD_CONF_BSET_DISKSORT_DISABLED|
 715                 SD_CONF_BSET_LUN_RESET_ENABLED,
 716                 &pirus_properties },
 717         { "SUN     StorageTek 6940", SD_CONF_BSET_THROTTLE |
 718                 SD_CONF_BSET_NRR_COUNT|
 719                 SD_CONF_BSET_BSY_RETRY_COUNT|
 720                 SD_CONF_BSET_RST_RETRIES|
 721                 SD_CONF_BSET_MIN_THROTTLE|
 722                 SD_CONF_BSET_DISKSORT_DISABLED|
 723                 SD_CONF_BSET_LUN_RESET_ENABLED,
 724                 &pirus_properties },
 725         { "SUN     PSX1000", SD_CONF_BSET_THROTTLE |
 726                 SD_CONF_BSET_NRR_COUNT|
 727                 SD_CONF_BSET_BSY_RETRY_COUNT|
 728                 SD_CONF_BSET_RST_RETRIES|
 729                 SD_CONF_BSET_MIN_THROTTLE|
 730                 SD_CONF_BSET_DISKSORT_DISABLED|
 731                 SD_CONF_BSET_LUN_RESET_ENABLED,
 732                 &pirus_properties },
 733         { "SUN     SE6330", SD_CONF_BSET_THROTTLE |
 734                 SD_CONF_BSET_NRR_COUNT|
 735                 SD_CONF_BSET_BSY_RETRY_COUNT|
 736                 SD_CONF_BSET_RST_RETRIES|
 737                 SD_CONF_BSET_MIN_THROTTLE|
 738                 SD_CONF_BSET_DISKSORT_DISABLED|
 739                 SD_CONF_BSET_LUN_RESET_ENABLED,
 740                 &pirus_properties },
 741         { "SUN     STK6580_6780", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 742         { "SUN     SUN_6180", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 743         { "STK     OPENstorage", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 744         { "STK     OpenStorage", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 745         { "STK     BladeCtlr",  SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 746         { "STK     FLEXLINE",   SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties },
 747         { "SYMBIOS", SD_CONF_BSET_NRR_COUNT, &symbios_properties },
 748 #endif /* fibre or NON-sparc platforms */
 749 #if ((defined(__sparc) && !defined(__fibre)) ||\
 750         (defined(__i386) || defined(__amd64)))
 751         { "SEAGATE ST42400N", SD_CONF_BSET_THROTTLE, &elite_properties },
 752         { "SEAGATE ST31200N", SD_CONF_BSET_THROTTLE, &st31200n_properties },
 753         { "SEAGATE ST41600N", SD_CONF_BSET_TUR_CHECK, NULL },
 754         { "CONNER  CP30540",  SD_CONF_BSET_NOCACHE,  NULL },
 755         { "*SUN0104*", SD_CONF_BSET_FAB_DEVID, NULL },
 756         { "*SUN0207*", SD_CONF_BSET_FAB_DEVID, NULL },
 757         { "*SUN0327*", SD_CONF_BSET_FAB_DEVID, NULL },
 758         { "*SUN0340*", SD_CONF_BSET_FAB_DEVID, NULL },
 759         { "*SUN0424*", SD_CONF_BSET_FAB_DEVID, NULL },
 760         { "*SUN0669*", SD_CONF_BSET_FAB_DEVID, NULL },
 761         { "*SUN1.0G*", SD_CONF_BSET_FAB_DEVID, NULL },
 762         { "SYMBIOS INF-01-00       ", SD_CONF_BSET_FAB_DEVID, NULL },
 763         { "SYMBIOS", SD_CONF_BSET_THROTTLE|SD_CONF_BSET_NRR_COUNT,
 764             &symbios_properties },
 765         { "LSI", SD_CONF_BSET_THROTTLE | SD_CONF_BSET_NRR_COUNT,
 766             &lsi_properties_scsi },
 767 #if defined(__i386) || defined(__amd64)
 768         { " NEC CD-ROM DRIVE:260 ", (SD_CONF_BSET_PLAYMSF_BCD
 769                                     | SD_CONF_BSET_READSUB_BCD
 770                                     | SD_CONF_BSET_READ_TOC_ADDR_BCD
 771                                     | SD_CONF_BSET_NO_READ_HEADER
 772                                     | SD_CONF_BSET_READ_CD_XD4), NULL },
 773 
 774         { " NEC CD-ROM DRIVE:270 ", (SD_CONF_BSET_PLAYMSF_BCD
 775                                     | SD_CONF_BSET_READSUB_BCD
 776                                     | SD_CONF_BSET_READ_TOC_ADDR_BCD
 777                                     | SD_CONF_BSET_NO_READ_HEADER
 778                                     | SD_CONF_BSET_READ_CD_XD4), NULL },
 779 #endif /* __i386 || __amd64 */
 780 #endif /* sparc NON-fibre or NON-sparc platforms */
 781 
 782 #if (defined(SD_PROP_TST))
 783         { "VENDOR  PRODUCT ", (SD_CONF_BSET_THROTTLE
 784                                 | SD_CONF_BSET_CTYPE
 785                                 | SD_CONF_BSET_NRR_COUNT
 786                                 | SD_CONF_BSET_FAB_DEVID
 787                                 | SD_CONF_BSET_NOCACHE
 788                                 | SD_CONF_BSET_BSY_RETRY_COUNT
 789                                 | SD_CONF_BSET_PLAYMSF_BCD
 790                                 | SD_CONF_BSET_READSUB_BCD
 791                                 | SD_CONF_BSET_READ_TOC_TRK_BCD
 792                                 | SD_CONF_BSET_READ_TOC_ADDR_BCD
 793                                 | SD_CONF_BSET_NO_READ_HEADER
 794                                 | SD_CONF_BSET_READ_CD_XD4
 795                                 | SD_CONF_BSET_RST_RETRIES
 796                                 | SD_CONF_BSET_RSV_REL_TIME
 797                                 | SD_CONF_BSET_TUR_CHECK), &tst_properties},
 798 #endif
 799 };
 800 
 801 static const int sd_disk_table_size =
 802         sizeof (sd_disk_table)/ sizeof (sd_disk_config_t);
 803 
 804 /*
 805  * Emulation mode disk drive VID/PID table
 806  */
 807 static char sd_flash_dev_table[][25] = {
 808         "ATA     MARVELL SD88SA02",
 809         "MARVELL SD88SA02",
 810         "TOSHIBA THNSNV05",
 811 };
 812 
 813 static const int sd_flash_dev_table_size =
 814         sizeof (sd_flash_dev_table) / sizeof (sd_flash_dev_table[0]);
 815 
 816 #define SD_INTERCONNECT_PARALLEL        0
 817 #define SD_INTERCONNECT_FABRIC          1
 818 #define SD_INTERCONNECT_FIBRE           2
 819 #define SD_INTERCONNECT_SSA             3
 820 #define SD_INTERCONNECT_SATA            4
 821 #define SD_INTERCONNECT_SAS             5
 822 
 823 #define SD_IS_PARALLEL_SCSI(un)         \
 824         ((un)->un_interconnect_type == SD_INTERCONNECT_PARALLEL)
 825 #define SD_IS_SERIAL(un)                \
 826         (((un)->un_interconnect_type == SD_INTERCONNECT_SATA) ||\
 827         ((un)->un_interconnect_type == SD_INTERCONNECT_SAS))
 828 
 829 /*
 830  * Definitions used by device id registration routines
 831  */
 832 #define VPD_HEAD_OFFSET         3       /* size of head for vpd page */
 833 #define VPD_PAGE_LENGTH         3       /* offset for pge length data */
 834 #define VPD_MODE_PAGE           1       /* offset into vpd pg for "page code" */
 835 
 836 static kmutex_t sd_sense_mutex = {0};
 837 
 838 /*
 839  * Macros for updates of the driver state
 840  */
 841 #define New_state(un, s)        \
 842         (un)->un_last_state = (un)->un_state, (un)->un_state = (s)
 843 #define Restore_state(un)       \
 844         { uchar_t tmp = (un)->un_last_state; New_state((un), tmp); }
 845 
 846 static struct sd_cdbinfo sd_cdbtab[] = {
 847         { CDB_GROUP0, 0x00,        0x1FFFFF,   0xFF,        },
 848         { CDB_GROUP1, SCMD_GROUP1, 0xFFFFFFFF, 0xFFFF,      },
 849         { CDB_GROUP5, SCMD_GROUP5, 0xFFFFFFFF, 0xFFFFFFFF,  },
 850         { CDB_GROUP4, SCMD_GROUP4, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFF, },
 851 };
 852 
 853 /*
 854  * Specifies the number of seconds that must have elapsed since the last
 855  * cmd. has completed for a device to be declared idle to the PM framework.
 856  */
 857 static int sd_pm_idletime = 1;
 858 
 859 /*
 860  * Internal function prototypes
 861  */
 862 
 863 #if (defined(__fibre))
 864 /*
 865  * These #defines are to avoid namespace collisions that occur because this
 866  * code is currently used to compile two separate driver modules: sd and ssd.
 867  * All function names need to be treated this way (even if declared static)
 868  * in order to allow the debugger to resolve the names properly.
 869  * It is anticipated that in the near future the ssd module will be obsoleted,
 870  * at which time this ugliness should go away.
 871  */
 872 #define sd_log_trace                    ssd_log_trace
 873 #define sd_log_info                     ssd_log_info
 874 #define sd_log_err                      ssd_log_err
 875 #define sdprobe                         ssdprobe
 876 #define sdinfo                          ssdinfo
 877 #define sd_prop_op                      ssd_prop_op
 878 #define sd_scsi_probe_cache_init        ssd_scsi_probe_cache_init
 879 #define sd_scsi_probe_cache_fini        ssd_scsi_probe_cache_fini
 880 #define sd_scsi_clear_probe_cache       ssd_scsi_clear_probe_cache
 881 #define sd_scsi_probe_with_cache        ssd_scsi_probe_with_cache
 882 #define sd_scsi_target_lun_init         ssd_scsi_target_lun_init
 883 #define sd_scsi_target_lun_fini         ssd_scsi_target_lun_fini
 884 #define sd_scsi_get_target_lun_count    ssd_scsi_get_target_lun_count
 885 #define sd_scsi_update_lun_on_target    ssd_scsi_update_lun_on_target
 886 #define sd_spin_up_unit                 ssd_spin_up_unit
 887 #define sd_enable_descr_sense           ssd_enable_descr_sense
 888 #define sd_reenable_dsense_task         ssd_reenable_dsense_task
 889 #define sd_set_mmc_caps                 ssd_set_mmc_caps
 890 #define sd_read_unit_properties         ssd_read_unit_properties
 891 #define sd_process_sdconf_file          ssd_process_sdconf_file
 892 #define sd_process_sdconf_table         ssd_process_sdconf_table
 893 #define sd_sdconf_id_match              ssd_sdconf_id_match
 894 #define sd_blank_cmp                    ssd_blank_cmp
 895 #define sd_chk_vers1_data               ssd_chk_vers1_data
 896 #define sd_set_vers1_properties         ssd_set_vers1_properties
 897 #define sd_check_solid_state            ssd_check_solid_state
 898 #define sd_check_emulation_mode         ssd_check_emulation_mode
 899 
 900 #define sd_get_physical_geometry        ssd_get_physical_geometry
 901 #define sd_get_virtual_geometry         ssd_get_virtual_geometry
 902 #define sd_update_block_info            ssd_update_block_info
 903 #define sd_register_devid               ssd_register_devid
 904 #define sd_get_devid                    ssd_get_devid
 905 #define sd_create_devid                 ssd_create_devid
 906 #define sd_write_deviceid               ssd_write_deviceid
 907 #define sd_check_vpd_page_support       ssd_check_vpd_page_support
 908 #define sd_setup_pm                     ssd_setup_pm
 909 #define sd_create_pm_components         ssd_create_pm_components
 910 #define sd_ddi_suspend                  ssd_ddi_suspend
 911 #define sd_ddi_resume                   ssd_ddi_resume
 912 #define sd_pm_state_change              ssd_pm_state_change
 913 #define sdpower                         ssdpower
 914 #define sdattach                        ssdattach
 915 #define sddetach                        ssddetach
 916 #define sd_unit_attach                  ssd_unit_attach
 917 #define sd_unit_detach                  ssd_unit_detach
 918 #define sd_set_unit_attributes          ssd_set_unit_attributes
 919 #define sd_create_errstats              ssd_create_errstats
 920 #define sd_set_errstats                 ssd_set_errstats
 921 #define sd_set_pstats                   ssd_set_pstats
 922 #define sddump                          ssddump
 923 #define sd_scsi_poll                    ssd_scsi_poll
 924 #define sd_send_polled_RQS              ssd_send_polled_RQS
 925 #define sd_ddi_scsi_poll                ssd_ddi_scsi_poll
 926 #define sd_init_event_callbacks         ssd_init_event_callbacks
 927 #define sd_event_callback               ssd_event_callback
 928 #define sd_cache_control                ssd_cache_control
 929 #define sd_get_write_cache_enabled      ssd_get_write_cache_enabled
 930 #define sd_get_nv_sup                   ssd_get_nv_sup
 931 #define sd_make_device                  ssd_make_device
 932 #define sdopen                          ssdopen
 933 #define sdclose                         ssdclose
 934 #define sd_ready_and_valid              ssd_ready_and_valid
 935 #define sdmin                           ssdmin
 936 #define sdread                          ssdread
 937 #define sdwrite                         ssdwrite
 938 #define sdaread                         ssdaread
 939 #define sdawrite                        ssdawrite
 940 #define sdstrategy                      ssdstrategy
 941 #define sdioctl                         ssdioctl
 942 #define sd_mapblockaddr_iostart         ssd_mapblockaddr_iostart
 943 #define sd_mapblocksize_iostart         ssd_mapblocksize_iostart
 944 #define sd_checksum_iostart             ssd_checksum_iostart
 945 #define sd_checksum_uscsi_iostart       ssd_checksum_uscsi_iostart
 946 #define sd_pm_iostart                   ssd_pm_iostart
 947 #define sd_core_iostart                 ssd_core_iostart
 948 #define sd_mapblockaddr_iodone          ssd_mapblockaddr_iodone
 949 #define sd_mapblocksize_iodone          ssd_mapblocksize_iodone
 950 #define sd_checksum_iodone              ssd_checksum_iodone
 951 #define sd_checksum_uscsi_iodone        ssd_checksum_uscsi_iodone
 952 #define sd_pm_iodone                    ssd_pm_iodone
 953 #define sd_initpkt_for_buf              ssd_initpkt_for_buf
 954 #define sd_destroypkt_for_buf           ssd_destroypkt_for_buf
 955 #define sd_setup_rw_pkt                 ssd_setup_rw_pkt
 956 #define sd_setup_next_rw_pkt            ssd_setup_next_rw_pkt
 957 #define sd_buf_iodone                   ssd_buf_iodone
 958 #define sd_uscsi_strategy               ssd_uscsi_strategy
 959 #define sd_initpkt_for_uscsi            ssd_initpkt_for_uscsi
 960 #define sd_destroypkt_for_uscsi         ssd_destroypkt_for_uscsi
 961 #define sd_uscsi_iodone                 ssd_uscsi_iodone
 962 #define sd_xbuf_strategy                ssd_xbuf_strategy
 963 #define sd_xbuf_init                    ssd_xbuf_init
 964 #define sd_pm_entry                     ssd_pm_entry
 965 #define sd_pm_exit                      ssd_pm_exit
 966 
 967 #define sd_pm_idletimeout_handler       ssd_pm_idletimeout_handler
 968 #define sd_pm_timeout_handler           ssd_pm_timeout_handler
 969 
 970 #define sd_add_buf_to_waitq             ssd_add_buf_to_waitq
 971 #define sdintr                          ssdintr
 972 #define sd_start_cmds                   ssd_start_cmds
 973 #define sd_send_scsi_cmd                ssd_send_scsi_cmd
 974 #define sd_bioclone_alloc               ssd_bioclone_alloc
 975 #define sd_bioclone_free                ssd_bioclone_free
 976 #define sd_shadow_buf_alloc             ssd_shadow_buf_alloc
 977 #define sd_shadow_buf_free              ssd_shadow_buf_free
 978 #define sd_print_transport_rejected_message     \
 979                                         ssd_print_transport_rejected_message
 980 #define sd_retry_command                ssd_retry_command
 981 #define sd_set_retry_bp                 ssd_set_retry_bp
 982 #define sd_send_request_sense_command   ssd_send_request_sense_command
 983 #define sd_start_retry_command          ssd_start_retry_command
 984 #define sd_start_direct_priority_command        \
 985                                         ssd_start_direct_priority_command
 986 #define sd_return_failed_command        ssd_return_failed_command
 987 #define sd_return_failed_command_no_restart     \
 988                                         ssd_return_failed_command_no_restart
 989 #define sd_return_command               ssd_return_command
 990 #define sd_sync_with_callback           ssd_sync_with_callback
 991 #define sdrunout                        ssdrunout
 992 #define sd_mark_rqs_busy                ssd_mark_rqs_busy
 993 #define sd_mark_rqs_idle                ssd_mark_rqs_idle
 994 #define sd_reduce_throttle              ssd_reduce_throttle
 995 #define sd_restore_throttle             ssd_restore_throttle
 996 #define sd_print_incomplete_msg         ssd_print_incomplete_msg
 997 #define sd_init_cdb_limits              ssd_init_cdb_limits
 998 #define sd_pkt_status_good              ssd_pkt_status_good
 999 #define sd_pkt_status_check_condition   ssd_pkt_status_check_condition
1000 #define sd_pkt_status_busy              ssd_pkt_status_busy
1001 #define sd_pkt_status_reservation_conflict      \
1002                                         ssd_pkt_status_reservation_conflict
1003 #define sd_pkt_status_qfull             ssd_pkt_status_qfull
1004 #define sd_handle_request_sense         ssd_handle_request_sense
1005 #define sd_handle_auto_request_sense    ssd_handle_auto_request_sense
1006 #define sd_print_sense_failed_msg       ssd_print_sense_failed_msg
1007 #define sd_validate_sense_data          ssd_validate_sense_data
1008 #define sd_decode_sense                 ssd_decode_sense
1009 #define sd_print_sense_msg              ssd_print_sense_msg
1010 #define sd_sense_key_no_sense           ssd_sense_key_no_sense
1011 #define sd_sense_key_recoverable_error  ssd_sense_key_recoverable_error
1012 #define sd_sense_key_not_ready          ssd_sense_key_not_ready
1013 #define sd_sense_key_medium_or_hardware_error   \
1014                                         ssd_sense_key_medium_or_hardware_error
1015 #define sd_sense_key_illegal_request    ssd_sense_key_illegal_request
1016 #define sd_sense_key_unit_attention     ssd_sense_key_unit_attention
1017 #define sd_sense_key_fail_command       ssd_sense_key_fail_command
1018 #define sd_sense_key_blank_check        ssd_sense_key_blank_check
1019 #define sd_sense_key_aborted_command    ssd_sense_key_aborted_command
1020 #define sd_sense_key_default            ssd_sense_key_default
1021 #define sd_print_retry_msg              ssd_print_retry_msg
1022 #define sd_print_cmd_incomplete_msg     ssd_print_cmd_incomplete_msg
1023 #define sd_pkt_reason_cmd_incomplete    ssd_pkt_reason_cmd_incomplete
1024 #define sd_pkt_reason_cmd_tran_err      ssd_pkt_reason_cmd_tran_err
1025 #define sd_pkt_reason_cmd_reset         ssd_pkt_reason_cmd_reset
1026 #define sd_pkt_reason_cmd_aborted       ssd_pkt_reason_cmd_aborted
1027 #define sd_pkt_reason_cmd_timeout       ssd_pkt_reason_cmd_timeout
1028 #define sd_pkt_reason_cmd_unx_bus_free  ssd_pkt_reason_cmd_unx_bus_free
1029 #define sd_pkt_reason_cmd_tag_reject    ssd_pkt_reason_cmd_tag_reject
1030 #define sd_pkt_reason_default           ssd_pkt_reason_default
1031 #define sd_reset_target                 ssd_reset_target
1032 #define sd_start_stop_unit_callback     ssd_start_stop_unit_callback
1033 #define sd_start_stop_unit_task         ssd_start_stop_unit_task
1034 #define sd_taskq_create                 ssd_taskq_create
1035 #define sd_taskq_delete                 ssd_taskq_delete
1036 #define sd_target_change_task           ssd_target_change_task
1037 #define sd_log_dev_status_event         ssd_log_dev_status_event
1038 #define sd_log_lun_expansion_event      ssd_log_lun_expansion_event
1039 #define sd_log_eject_request_event      ssd_log_eject_request_event
1040 #define sd_media_change_task            ssd_media_change_task
1041 #define sd_handle_mchange               ssd_handle_mchange
1042 #define sd_send_scsi_DOORLOCK           ssd_send_scsi_DOORLOCK
1043 #define sd_send_scsi_READ_CAPACITY      ssd_send_scsi_READ_CAPACITY
1044 #define sd_send_scsi_READ_CAPACITY_16   ssd_send_scsi_READ_CAPACITY_16
1045 #define sd_send_scsi_GET_CONFIGURATION  ssd_send_scsi_GET_CONFIGURATION
1046 #define sd_send_scsi_feature_GET_CONFIGURATION  \
1047                                         sd_send_scsi_feature_GET_CONFIGURATION
1048 #define sd_send_scsi_START_STOP_UNIT    ssd_send_scsi_START_STOP_UNIT
1049 #define sd_send_scsi_INQUIRY            ssd_send_scsi_INQUIRY
1050 #define sd_send_scsi_TEST_UNIT_READY    ssd_send_scsi_TEST_UNIT_READY
1051 #define sd_send_scsi_PERSISTENT_RESERVE_IN      \
1052                                         ssd_send_scsi_PERSISTENT_RESERVE_IN
1053 #define sd_send_scsi_PERSISTENT_RESERVE_OUT     \
1054                                         ssd_send_scsi_PERSISTENT_RESERVE_OUT
1055 #define sd_send_scsi_SYNCHRONIZE_CACHE  ssd_send_scsi_SYNCHRONIZE_CACHE
1056 #define sd_send_scsi_SYNCHRONIZE_CACHE_biodone  \
1057                                         ssd_send_scsi_SYNCHRONIZE_CACHE_biodone
1058 #define sd_send_scsi_MODE_SENSE         ssd_send_scsi_MODE_SENSE
1059 #define sd_send_scsi_MODE_SELECT        ssd_send_scsi_MODE_SELECT
1060 #define sd_send_scsi_RDWR               ssd_send_scsi_RDWR
1061 #define sd_send_scsi_LOG_SENSE          ssd_send_scsi_LOG_SENSE
1062 #define sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION      \
1063                                 ssd_send_scsi_GET_EVENT_STATUS_NOTIFICATION
1064 #define sd_gesn_media_data_valid        ssd_gesn_media_data_valid
1065 #define sd_alloc_rqs                    ssd_alloc_rqs
1066 #define sd_free_rqs                     ssd_free_rqs
1067 #define sd_dump_memory                  ssd_dump_memory
1068 #define sd_get_media_info_com           ssd_get_media_info_com
1069 #define sd_get_media_info               ssd_get_media_info
1070 #define sd_get_media_info_ext           ssd_get_media_info_ext
1071 #define sd_dkio_ctrl_info               ssd_dkio_ctrl_info
1072 #define sd_nvpair_str_decode            ssd_nvpair_str_decode
1073 #define sd_strtok_r                     ssd_strtok_r
1074 #define sd_set_properties               ssd_set_properties
1075 #define sd_get_tunables_from_conf       ssd_get_tunables_from_conf
1076 #define sd_setup_next_xfer              ssd_setup_next_xfer
1077 #define sd_dkio_get_temp                ssd_dkio_get_temp
1078 #define sd_check_mhd                    ssd_check_mhd
1079 #define sd_mhd_watch_cb                 ssd_mhd_watch_cb
1080 #define sd_mhd_watch_incomplete         ssd_mhd_watch_incomplete
1081 #define sd_sname                        ssd_sname
1082 #define sd_mhd_resvd_recover            ssd_mhd_resvd_recover
1083 #define sd_resv_reclaim_thread          ssd_resv_reclaim_thread
1084 #define sd_take_ownership               ssd_take_ownership
1085 #define sd_reserve_release              ssd_reserve_release
1086 #define sd_rmv_resv_reclaim_req         ssd_rmv_resv_reclaim_req
1087 #define sd_mhd_reset_notify_cb          ssd_mhd_reset_notify_cb
1088 #define sd_persistent_reservation_in_read_keys  \
1089                                         ssd_persistent_reservation_in_read_keys
1090 #define sd_persistent_reservation_in_read_resv  \
1091                                         ssd_persistent_reservation_in_read_resv
1092 #define sd_mhdioc_takeown               ssd_mhdioc_takeown
1093 #define sd_mhdioc_failfast              ssd_mhdioc_failfast
1094 #define sd_mhdioc_release               ssd_mhdioc_release
1095 #define sd_mhdioc_register_devid        ssd_mhdioc_register_devid
1096 #define sd_mhdioc_inkeys                ssd_mhdioc_inkeys
1097 #define sd_mhdioc_inresv                ssd_mhdioc_inresv
1098 #define sr_change_blkmode               ssr_change_blkmode
1099 #define sr_change_speed                 ssr_change_speed
1100 #define sr_atapi_change_speed           ssr_atapi_change_speed
1101 #define sr_pause_resume                 ssr_pause_resume
1102 #define sr_play_msf                     ssr_play_msf
1103 #define sr_play_trkind                  ssr_play_trkind
1104 #define sr_read_all_subcodes            ssr_read_all_subcodes
1105 #define sr_read_subchannel              ssr_read_subchannel
1106 #define sr_read_tocentry                ssr_read_tocentry
1107 #define sr_read_tochdr                  ssr_read_tochdr
1108 #define sr_read_cdda                    ssr_read_cdda
1109 #define sr_read_cdxa                    ssr_read_cdxa
1110 #define sr_read_mode1                   ssr_read_mode1
1111 #define sr_read_mode2                   ssr_read_mode2
1112 #define sr_read_cd_mode2                ssr_read_cd_mode2
1113 #define sr_sector_mode                  ssr_sector_mode
1114 #define sr_eject                        ssr_eject
1115 #define sr_ejected                      ssr_ejected
1116 #define sr_check_wp                     ssr_check_wp
1117 #define sd_watch_request_submit         ssd_watch_request_submit
1118 #define sd_check_media                  ssd_check_media
1119 #define sd_media_watch_cb               ssd_media_watch_cb
1120 #define sd_delayed_cv_broadcast         ssd_delayed_cv_broadcast
1121 #define sr_volume_ctrl                  ssr_volume_ctrl
1122 #define sr_read_sony_session_offset     ssr_read_sony_session_offset
1123 #define sd_log_page_supported           ssd_log_page_supported
1124 #define sd_check_for_writable_cd        ssd_check_for_writable_cd
1125 #define sd_wm_cache_constructor         ssd_wm_cache_constructor
1126 #define sd_wm_cache_destructor          ssd_wm_cache_destructor
1127 #define sd_range_lock                   ssd_range_lock
1128 #define sd_get_range                    ssd_get_range
1129 #define sd_free_inlist_wmap             ssd_free_inlist_wmap
1130 #define sd_range_unlock                 ssd_range_unlock
1131 #define sd_read_modify_write_task       ssd_read_modify_write_task
1132 #define sddump_do_read_of_rmw           ssddump_do_read_of_rmw
1133 
1134 #define sd_iostart_chain                ssd_iostart_chain
1135 #define sd_iodone_chain                 ssd_iodone_chain
1136 #define sd_initpkt_map                  ssd_initpkt_map
1137 #define sd_destroypkt_map               ssd_destroypkt_map
1138 #define sd_chain_type_map               ssd_chain_type_map
1139 #define sd_chain_index_map              ssd_chain_index_map
1140 
1141 #define sd_failfast_flushctl            ssd_failfast_flushctl
1142 #define sd_failfast_flushq              ssd_failfast_flushq
1143 #define sd_failfast_flushq_callback     ssd_failfast_flushq_callback
1144 
1145 #define sd_is_lsi                       ssd_is_lsi
1146 #define sd_tg_rdwr                      ssd_tg_rdwr
1147 #define sd_tg_getinfo                   ssd_tg_getinfo
1148 #define sd_rmw_msg_print_handler        ssd_rmw_msg_print_handler
1149 
1150 #endif  /* #if (defined(__fibre)) */
1151 
1152 
1153 int _init(void);
1154 int _fini(void);
1155 int _info(struct modinfo *modinfop);
1156 
1157 /*PRINTFLIKE3*/
1158 static void sd_log_trace(uint_t comp, struct sd_lun *un, const char *fmt, ...);
1159 /*PRINTFLIKE3*/
1160 static void sd_log_info(uint_t comp, struct sd_lun *un, const char *fmt, ...);
1161 /*PRINTFLIKE3*/
1162 static void sd_log_err(uint_t comp, struct sd_lun *un, const char *fmt, ...);
1163 
1164 static int sdprobe(dev_info_t *devi);
1165 static int sdinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
1166     void **result);
1167 static int sd_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
1168     int mod_flags, char *name, caddr_t valuep, int *lengthp);
1169 
1170 /*
1171  * Smart probe for parallel scsi
1172  */
1173 static void sd_scsi_probe_cache_init(void);
1174 static void sd_scsi_probe_cache_fini(void);
1175 static void sd_scsi_clear_probe_cache(void);
1176 static int  sd_scsi_probe_with_cache(struct scsi_device *devp, int (*fn)());
1177 
1178 /*
1179  * Attached luns on target for parallel scsi
1180  */
1181 static void sd_scsi_target_lun_init(void);
1182 static void sd_scsi_target_lun_fini(void);
1183 static int  sd_scsi_get_target_lun_count(dev_info_t *dip, int target);
1184 static void sd_scsi_update_lun_on_target(dev_info_t *dip, int target, int flag);
1185 
1186 static int      sd_spin_up_unit(sd_ssc_t *ssc);
1187 
1188 /*
1189  * Using sd_ssc_init to establish sd_ssc_t struct
1190  * Using sd_ssc_send to send uscsi internal command
1191  * Using sd_ssc_fini to free sd_ssc_t struct
1192  */
1193 static sd_ssc_t *sd_ssc_init(struct sd_lun *un);
1194 static int sd_ssc_send(sd_ssc_t *ssc, struct uscsi_cmd *incmd,
1195     int flag, enum uio_seg dataspace, int path_flag);
1196 static void sd_ssc_fini(sd_ssc_t *ssc);
1197 
1198 /*
1199  * Using sd_ssc_assessment to set correct type-of-assessment
1200  * Using sd_ssc_post to post ereport & system log
1201  *       sd_ssc_post will call sd_ssc_print to print system log
1202  *       sd_ssc_post will call sd_ssd_ereport_post to post ereport
1203  */
1204 static void sd_ssc_assessment(sd_ssc_t *ssc,
1205     enum sd_type_assessment tp_assess);
1206 
1207 static void sd_ssc_post(sd_ssc_t *ssc, enum sd_driver_assessment sd_assess);
1208 static void sd_ssc_print(sd_ssc_t *ssc, int sd_severity);
1209 static void sd_ssc_ereport_post(sd_ssc_t *ssc,
1210     enum sd_driver_assessment drv_assess);
1211 
1212 /*
1213  * Using sd_ssc_set_info to mark an un-decodable-data error.
1214  * Using sd_ssc_extract_info to transfer information from internal
1215  *       data structures to sd_ssc_t.
1216  */
1217 static void sd_ssc_set_info(sd_ssc_t *ssc, int ssc_flags, uint_t comp,
1218     const char *fmt, ...);
1219 static void sd_ssc_extract_info(sd_ssc_t *ssc, struct sd_lun *un,
1220     struct scsi_pkt *pktp, struct buf *bp, struct sd_xbuf *xp);
1221 
1222 static int sd_send_scsi_cmd(dev_t dev, struct uscsi_cmd *incmd, int flag,
1223     enum uio_seg dataspace, int path_flag);
1224 
1225 #ifdef _LP64
1226 static void     sd_enable_descr_sense(sd_ssc_t *ssc);
1227 static void     sd_reenable_dsense_task(void *arg);
1228 #endif /* _LP64 */
1229 
1230 static void     sd_set_mmc_caps(sd_ssc_t *ssc);
1231 
1232 static void sd_read_unit_properties(struct sd_lun *un);
1233 static int  sd_process_sdconf_file(struct sd_lun *un);
1234 static void sd_nvpair_str_decode(struct sd_lun *un, char *nvpair_str);
1235 static char *sd_strtok_r(char *string, const char *sepset, char **lasts);
1236 static void sd_set_properties(struct sd_lun *un, char *name, char *value);
1237 static void sd_get_tunables_from_conf(struct sd_lun *un, int flags,
1238     int *data_list, sd_tunables *values);
1239 static void sd_process_sdconf_table(struct sd_lun *un);
1240 static int  sd_sdconf_id_match(struct sd_lun *un, char *id, int idlen);
1241 static int  sd_blank_cmp(struct sd_lun *un, char *id, int idlen);
1242 static int  sd_chk_vers1_data(struct sd_lun *un, int flags, int *prop_list,
1243         int list_len, char *dataname_ptr);
1244 static void sd_set_vers1_properties(struct sd_lun *un, int flags,
1245     sd_tunables *prop_list);
1246 
1247 static void sd_register_devid(sd_ssc_t *ssc, dev_info_t *devi,
1248     int reservation_flag);
1249 static int  sd_get_devid(sd_ssc_t *ssc);
1250 static ddi_devid_t sd_create_devid(sd_ssc_t *ssc);
1251 static int  sd_write_deviceid(sd_ssc_t *ssc);
1252 static int  sd_get_devid_page(struct sd_lun *un, uchar_t *wwn, int *len);
1253 static int  sd_check_vpd_page_support(sd_ssc_t *ssc);
1254 
1255 static void sd_setup_pm(sd_ssc_t *ssc, dev_info_t *devi);
1256 static void sd_create_pm_components(dev_info_t *devi, struct sd_lun *un);
1257 
1258 static int  sd_ddi_suspend(dev_info_t *devi);
1259 static int  sd_ddi_resume(dev_info_t *devi);
1260 static int  sd_pm_state_change(struct sd_lun *un, int level, int flag);
1261 static int  sdpower(dev_info_t *devi, int component, int level);
1262 
1263 static int  sdattach(dev_info_t *devi, ddi_attach_cmd_t cmd);
1264 static int  sddetach(dev_info_t *devi, ddi_detach_cmd_t cmd);
1265 static int  sd_unit_attach(dev_info_t *devi);
1266 static int  sd_unit_detach(dev_info_t *devi);
1267 
1268 static void sd_set_unit_attributes(struct sd_lun *un, dev_info_t *devi);
1269 static void sd_create_errstats(struct sd_lun *un, int instance);
1270 static void sd_set_errstats(struct sd_lun *un);
1271 static void sd_set_pstats(struct sd_lun *un);
1272 
1273 static int  sddump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk);
1274 static int  sd_scsi_poll(struct sd_lun *un, struct scsi_pkt *pkt);
1275 static int  sd_send_polled_RQS(struct sd_lun *un);
1276 static int  sd_ddi_scsi_poll(struct scsi_pkt *pkt);
1277 
1278 #if (defined(__fibre))
1279 /*
1280  * Event callbacks (photon)
1281  */
1282 static void sd_init_event_callbacks(struct sd_lun *un);
1283 static void  sd_event_callback(dev_info_t *, ddi_eventcookie_t, void *, void *);
1284 #endif
1285 
1286 /*
1287  * Defines for sd_cache_control
1288  */
1289 
1290 #define SD_CACHE_ENABLE         1
1291 #define SD_CACHE_DISABLE        0
1292 #define SD_CACHE_NOCHANGE       -1
1293 
1294 static int   sd_cache_control(sd_ssc_t *ssc, int rcd_flag, int wce_flag);
1295 static int   sd_get_write_cache_enabled(sd_ssc_t *ssc, int *is_enabled);
1296 static void  sd_get_nv_sup(sd_ssc_t *ssc);
1297 static dev_t sd_make_device(dev_info_t *devi);
1298 static void  sd_check_solid_state(sd_ssc_t *ssc);
1299 static void  sd_check_emulation_mode(sd_ssc_t *ssc);
1300 static void  sd_update_block_info(struct sd_lun *un, uint32_t lbasize,
1301         uint64_t capacity);
1302 
1303 /*
1304  * Driver entry point functions.
1305  */
1306 static int  sdopen(dev_t *dev_p, int flag, int otyp, cred_t *cred_p);
1307 static int  sdclose(dev_t dev, int flag, int otyp, cred_t *cred_p);
1308 static int  sd_ready_and_valid(sd_ssc_t *ssc, int part);
1309 
1310 static void sdmin(struct buf *bp);
1311 static int sdread(dev_t dev, struct uio *uio, cred_t *cred_p);
1312 static int sdwrite(dev_t dev, struct uio *uio, cred_t *cred_p);
1313 static int sdaread(dev_t dev, struct aio_req *aio, cred_t *cred_p);
1314 static int sdawrite(dev_t dev, struct aio_req *aio, cred_t *cred_p);
1315 
1316 static int sdstrategy(struct buf *bp);
1317 static int sdioctl(dev_t, int, intptr_t, int, cred_t *, int *);
1318 
1319 /*
1320  * Function prototypes for layering functions in the iostart chain.
1321  */
1322 static void sd_mapblockaddr_iostart(int index, struct sd_lun *un,
1323         struct buf *bp);
1324 static void sd_mapblocksize_iostart(int index, struct sd_lun *un,
1325         struct buf *bp);
1326 static void sd_checksum_iostart(int index, struct sd_lun *un, struct buf *bp);
1327 static void sd_checksum_uscsi_iostart(int index, struct sd_lun *un,
1328         struct buf *bp);
1329 static void sd_pm_iostart(int index, struct sd_lun *un, struct buf *bp);
1330 static void sd_core_iostart(int index, struct sd_lun *un, struct buf *bp);
1331 
1332 /*
1333  * Function prototypes for layering functions in the iodone chain.
1334  */
1335 static void sd_buf_iodone(int index, struct sd_lun *un, struct buf *bp);
1336 static void sd_uscsi_iodone(int index, struct sd_lun *un, struct buf *bp);
1337 static void sd_mapblockaddr_iodone(int index, struct sd_lun *un,
1338         struct buf *bp);
1339 static void sd_mapblocksize_iodone(int index, struct sd_lun *un,
1340         struct buf *bp);
1341 static void sd_checksum_iodone(int index, struct sd_lun *un, struct buf *bp);
1342 static void sd_checksum_uscsi_iodone(int index, struct sd_lun *un,
1343         struct buf *bp);
1344 static void sd_pm_iodone(int index, struct sd_lun *un, struct buf *bp);
1345 
1346 /*
1347  * Prototypes for functions to support buf(9S) based IO.
1348  */
1349 static void sd_xbuf_strategy(struct buf *bp, ddi_xbuf_t xp, void *arg);
1350 static int sd_initpkt_for_buf(struct buf *, struct scsi_pkt **);
1351 static void sd_destroypkt_for_buf(struct buf *);
1352 static int sd_setup_rw_pkt(struct sd_lun *un, struct scsi_pkt **pktpp,
1353         struct buf *bp, int flags,
1354         int (*callback)(caddr_t), caddr_t callback_arg,
1355         diskaddr_t lba, uint32_t blockcount);
1356 static int sd_setup_next_rw_pkt(struct sd_lun *un, struct scsi_pkt *pktp,
1357         struct buf *bp, diskaddr_t lba, uint32_t blockcount);
1358 
1359 /*
1360  * Prototypes for functions to support USCSI IO.
1361  */
1362 static int sd_uscsi_strategy(struct buf *bp);
1363 static int sd_initpkt_for_uscsi(struct buf *, struct scsi_pkt **);
1364 static void sd_destroypkt_for_uscsi(struct buf *);
1365 
1366 static void sd_xbuf_init(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
1367         uchar_t chain_type, void *pktinfop);
1368 
1369 static int  sd_pm_entry(struct sd_lun *un);
1370 static void sd_pm_exit(struct sd_lun *un);
1371 
1372 static void sd_pm_idletimeout_handler(void *arg);
1373 
1374 /*
1375  * sd_core internal functions (used at the sd_core_io layer).
1376  */
1377 static void sd_add_buf_to_waitq(struct sd_lun *un, struct buf *bp);
1378 static void sdintr(struct scsi_pkt *pktp);
1379 static void sd_start_cmds(struct sd_lun *un, struct buf *immed_bp);
1380 
1381 static int sd_send_scsi_cmd(dev_t dev, struct uscsi_cmd *incmd, int flag,
1382         enum uio_seg dataspace, int path_flag);
1383 
1384 static struct buf *sd_bioclone_alloc(struct buf *bp, size_t datalen,
1385         daddr_t blkno, int (*func)(struct buf *));
1386 static struct buf *sd_shadow_buf_alloc(struct buf *bp, size_t datalen,
1387         uint_t bflags, daddr_t blkno, int (*func)(struct buf *));
1388 static void sd_bioclone_free(struct buf *bp);
1389 static void sd_shadow_buf_free(struct buf *bp);
1390 
1391 static void sd_print_transport_rejected_message(struct sd_lun *un,
1392         struct sd_xbuf *xp, int code);
1393 static void sd_print_incomplete_msg(struct sd_lun *un, struct buf *bp,
1394     void *arg, int code);
1395 static void sd_print_sense_failed_msg(struct sd_lun *un, struct buf *bp,
1396     void *arg, int code);
1397 static void sd_print_cmd_incomplete_msg(struct sd_lun *un, struct buf *bp,
1398     void *arg, int code);
1399 
1400 static void sd_retry_command(struct sd_lun *un, struct buf *bp,
1401         int retry_check_flag,
1402         void (*user_funcp)(struct sd_lun *un, struct buf *bp, void *argp,
1403                 int c),
1404         void *user_arg, int failure_code,  clock_t retry_delay,
1405         void (*statp)(kstat_io_t *));
1406 
1407 static void sd_set_retry_bp(struct sd_lun *un, struct buf *bp,
1408         clock_t retry_delay, void (*statp)(kstat_io_t *));
1409 
1410 static void sd_send_request_sense_command(struct sd_lun *un, struct buf *bp,
1411         struct scsi_pkt *pktp);
1412 static void sd_start_retry_command(void *arg);
1413 static void sd_start_direct_priority_command(void *arg);
1414 static void sd_return_failed_command(struct sd_lun *un, struct buf *bp,
1415         int errcode);
1416 static void sd_return_failed_command_no_restart(struct sd_lun *un,
1417         struct buf *bp, int errcode);
1418 static void sd_return_command(struct sd_lun *un, struct buf *bp);
1419 static void sd_sync_with_callback(struct sd_lun *un);
1420 static int sdrunout(caddr_t arg);
1421 
1422 static void sd_mark_rqs_busy(struct sd_lun *un, struct buf *bp);
1423 static struct buf *sd_mark_rqs_idle(struct sd_lun *un, struct sd_xbuf *xp);
1424 
1425 static void sd_reduce_throttle(struct sd_lun *un, int throttle_type);
1426 static void sd_restore_throttle(void *arg);
1427 
1428 static void sd_init_cdb_limits(struct sd_lun *un);
1429 
1430 static void sd_pkt_status_good(struct sd_lun *un, struct buf *bp,
1431         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1432 
1433 /*
1434  * Error handling functions
1435  */
1436 static void sd_pkt_status_check_condition(struct sd_lun *un, struct buf *bp,
1437         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1438 static void sd_pkt_status_busy(struct sd_lun *un, struct buf *bp,
1439         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1440 static void sd_pkt_status_reservation_conflict(struct sd_lun *un,
1441         struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1442 static void sd_pkt_status_qfull(struct sd_lun *un, struct buf *bp,
1443         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1444 
1445 static void sd_handle_request_sense(struct sd_lun *un, struct buf *bp,
1446         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1447 static void sd_handle_auto_request_sense(struct sd_lun *un, struct buf *bp,
1448         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1449 static int sd_validate_sense_data(struct sd_lun *un, struct buf *bp,
1450         struct sd_xbuf *xp, size_t actual_len);
1451 static void sd_decode_sense(struct sd_lun *un, struct buf *bp,
1452         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1453 
1454 static void sd_print_sense_msg(struct sd_lun *un, struct buf *bp,
1455         void *arg, int code);
1456 
1457 static void sd_sense_key_no_sense(struct sd_lun *un, struct buf *bp,
1458         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1459 static void sd_sense_key_recoverable_error(struct sd_lun *un,
1460         uint8_t *sense_datap,
1461         struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1462 static void sd_sense_key_not_ready(struct sd_lun *un,
1463         uint8_t *sense_datap,
1464         struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1465 static void sd_sense_key_medium_or_hardware_error(struct sd_lun *un,
1466         uint8_t *sense_datap,
1467         struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1468 static void sd_sense_key_illegal_request(struct sd_lun *un, struct buf *bp,
1469         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1470 static void sd_sense_key_unit_attention(struct sd_lun *un,
1471         uint8_t *sense_datap,
1472         struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1473 static void sd_sense_key_fail_command(struct sd_lun *un, struct buf *bp,
1474         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1475 static void sd_sense_key_blank_check(struct sd_lun *un, struct buf *bp,
1476         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1477 static void sd_sense_key_aborted_command(struct sd_lun *un, struct buf *bp,
1478         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1479 static void sd_sense_key_default(struct sd_lun *un,
1480         uint8_t *sense_datap,
1481         struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp);
1482 
1483 static void sd_print_retry_msg(struct sd_lun *un, struct buf *bp,
1484         void *arg, int flag);
1485 
1486 static void sd_pkt_reason_cmd_incomplete(struct sd_lun *un, struct buf *bp,
1487         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1488 static void sd_pkt_reason_cmd_tran_err(struct sd_lun *un, struct buf *bp,
1489         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1490 static void sd_pkt_reason_cmd_reset(struct sd_lun *un, struct buf *bp,
1491         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1492 static void sd_pkt_reason_cmd_aborted(struct sd_lun *un, struct buf *bp,
1493         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1494 static void sd_pkt_reason_cmd_timeout(struct sd_lun *un, struct buf *bp,
1495         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1496 static void sd_pkt_reason_cmd_unx_bus_free(struct sd_lun *un, struct buf *bp,
1497         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1498 static void sd_pkt_reason_cmd_tag_reject(struct sd_lun *un, struct buf *bp,
1499         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1500 static void sd_pkt_reason_default(struct sd_lun *un, struct buf *bp,
1501         struct sd_xbuf *xp, struct scsi_pkt *pktp);
1502 
1503 static void sd_reset_target(struct sd_lun *un, struct scsi_pkt *pktp);
1504 
1505 static void sd_start_stop_unit_callback(void *arg);
1506 static void sd_start_stop_unit_task(void *arg);
1507 
1508 static void sd_taskq_create(void);
1509 static void sd_taskq_delete(void);
1510 static void sd_target_change_task(void *arg);
1511 static void sd_log_dev_status_event(struct sd_lun *un, char *esc, int km_flag);
1512 static void sd_log_lun_expansion_event(struct sd_lun *un, int km_flag);
1513 static void sd_log_eject_request_event(struct sd_lun *un, int km_flag);
1514 static void sd_media_change_task(void *arg);
1515 
1516 static int sd_handle_mchange(struct sd_lun *un);
1517 static int sd_send_scsi_DOORLOCK(sd_ssc_t *ssc, int flag, int path_flag);
1518 static int sd_send_scsi_READ_CAPACITY(sd_ssc_t *ssc, uint64_t *capp,
1519         uint32_t *lbap, int path_flag);
1520 static int sd_send_scsi_READ_CAPACITY_16(sd_ssc_t *ssc, uint64_t *capp,
1521         uint32_t *lbap, uint32_t *psp, int path_flag);
1522 static int sd_send_scsi_START_STOP_UNIT(sd_ssc_t *ssc, int pc_flag,
1523         int flag, int path_flag);
1524 static int sd_send_scsi_INQUIRY(sd_ssc_t *ssc, uchar_t *bufaddr,
1525         size_t buflen, uchar_t evpd, uchar_t page_code, size_t *residp);
1526 static int sd_send_scsi_TEST_UNIT_READY(sd_ssc_t *ssc, int flag);
1527 static int sd_send_scsi_PERSISTENT_RESERVE_IN(sd_ssc_t *ssc,
1528         uchar_t usr_cmd, uint16_t data_len, uchar_t *data_bufp);
1529 static int sd_send_scsi_PERSISTENT_RESERVE_OUT(sd_ssc_t *ssc,
1530         uchar_t usr_cmd, uchar_t *usr_bufp);
1531 static int sd_send_scsi_SYNCHRONIZE_CACHE(struct sd_lun *un,
1532         struct dk_callback *dkc);
1533 static int sd_send_scsi_SYNCHRONIZE_CACHE_biodone(struct buf *bp);
1534 static int sd_send_scsi_GET_CONFIGURATION(sd_ssc_t *ssc,
1535         struct uscsi_cmd *ucmdbuf, uchar_t *rqbuf, uint_t rqbuflen,
1536         uchar_t *bufaddr, uint_t buflen, int path_flag);
1537 static int sd_send_scsi_feature_GET_CONFIGURATION(sd_ssc_t *ssc,
1538         struct uscsi_cmd *ucmdbuf, uchar_t *rqbuf, uint_t rqbuflen,
1539         uchar_t *bufaddr, uint_t buflen, char feature, int path_flag);
1540 static int sd_send_scsi_MODE_SENSE(sd_ssc_t *ssc, int cdbsize,
1541         uchar_t *bufaddr, size_t buflen, uchar_t page_code, int path_flag);
1542 static int sd_send_scsi_MODE_SELECT(sd_ssc_t *ssc, int cdbsize,
1543         uchar_t *bufaddr, size_t buflen, uchar_t save_page, int path_flag);
1544 static int sd_send_scsi_RDWR(sd_ssc_t *ssc, uchar_t cmd, void *bufaddr,
1545         size_t buflen, daddr_t start_block, int path_flag);
1546 #define sd_send_scsi_READ(ssc, bufaddr, buflen, start_block, path_flag) \
1547         sd_send_scsi_RDWR(ssc, SCMD_READ, bufaddr, buflen, start_block, \
1548         path_flag)
1549 #define sd_send_scsi_WRITE(ssc, bufaddr, buflen, start_block, path_flag)\
1550         sd_send_scsi_RDWR(ssc, SCMD_WRITE, bufaddr, buflen, start_block,\
1551         path_flag)
1552 
1553 static int sd_send_scsi_LOG_SENSE(sd_ssc_t *ssc, uchar_t *bufaddr,
1554         uint16_t buflen, uchar_t page_code, uchar_t page_control,
1555         uint16_t param_ptr, int path_flag);
1556 static int sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION(sd_ssc_t *ssc,
1557         uchar_t *bufaddr, size_t buflen, uchar_t class_req);
1558 static boolean_t sd_gesn_media_data_valid(uchar_t *data);
1559 
1560 static int  sd_alloc_rqs(struct scsi_device *devp, struct sd_lun *un);
1561 static void sd_free_rqs(struct sd_lun *un);
1562 
1563 static void sd_dump_memory(struct sd_lun *un, uint_t comp, char *title,
1564         uchar_t *data, int len, int fmt);
1565 static void sd_panic_for_res_conflict(struct sd_lun *un);
1566 
1567 /*
1568  * Disk Ioctl Function Prototypes
1569  */
1570 static int sd_get_media_info(dev_t dev, caddr_t arg, int flag);
1571 static int sd_get_media_info_ext(dev_t dev, caddr_t arg, int flag);
1572 static int sd_dkio_ctrl_info(dev_t dev, caddr_t arg, int flag);
1573 static int sd_dkio_get_temp(dev_t dev, caddr_t arg, int flag);
1574 
1575 /*
1576  * Multi-host Ioctl Prototypes
1577  */
1578 static int sd_check_mhd(dev_t dev, int interval);
1579 static int sd_mhd_watch_cb(caddr_t arg, struct scsi_watch_result *resultp);
1580 static void sd_mhd_watch_incomplete(struct sd_lun *un, struct scsi_pkt *pkt);
1581 static char *sd_sname(uchar_t status);
1582 static void sd_mhd_resvd_recover(void *arg);
1583 static void sd_resv_reclaim_thread();
1584 static int sd_take_ownership(dev_t dev, struct mhioctkown *p);
1585 static int sd_reserve_release(dev_t dev, int cmd);
1586 static void sd_rmv_resv_reclaim_req(dev_t dev);
1587 static void sd_mhd_reset_notify_cb(caddr_t arg);
1588 static int sd_persistent_reservation_in_read_keys(struct sd_lun *un,
1589         mhioc_inkeys_t *usrp, int flag);
1590 static int sd_persistent_reservation_in_read_resv(struct sd_lun *un,
1591         mhioc_inresvs_t *usrp, int flag);
1592 static int sd_mhdioc_takeown(dev_t dev, caddr_t arg, int flag);
1593 static int sd_mhdioc_failfast(dev_t dev, caddr_t arg, int flag);
1594 static int sd_mhdioc_release(dev_t dev);
1595 static int sd_mhdioc_register_devid(dev_t dev);
1596 static int sd_mhdioc_inkeys(dev_t dev, caddr_t arg, int flag);
1597 static int sd_mhdioc_inresv(dev_t dev, caddr_t arg, int flag);
1598 
1599 /*
1600  * SCSI removable prototypes
1601  */
1602 static int sr_change_blkmode(dev_t dev, int cmd, intptr_t data, int flag);
1603 static int sr_change_speed(dev_t dev, int cmd, intptr_t data, int flag);
1604 static int sr_atapi_change_speed(dev_t dev, int cmd, intptr_t data, int flag);
1605 static int sr_pause_resume(dev_t dev, int mode);
1606 static int sr_play_msf(dev_t dev, caddr_t data, int flag);
1607 static int sr_play_trkind(dev_t dev, caddr_t data, int flag);
1608 static int sr_read_all_subcodes(dev_t dev, caddr_t data, int flag);
1609 static int sr_read_subchannel(dev_t dev, caddr_t data, int flag);
1610 static int sr_read_tocentry(dev_t dev, caddr_t data, int flag);
1611 static int sr_read_tochdr(dev_t dev, caddr_t data, int flag);
1612 static int sr_read_cdda(dev_t dev, caddr_t data, int flag);
1613 static int sr_read_cdxa(dev_t dev, caddr_t data, int flag);
1614 static int sr_read_mode1(dev_t dev, caddr_t data, int flag);
1615 static int sr_read_mode2(dev_t dev, caddr_t data, int flag);
1616 static int sr_read_cd_mode2(dev_t dev, caddr_t data, int flag);
1617 static int sr_sector_mode(dev_t dev, uint32_t blksize);
1618 static int sr_eject(dev_t dev);
1619 static void sr_ejected(register struct sd_lun *un);
1620 static int sr_check_wp(dev_t dev);
1621 static opaque_t sd_watch_request_submit(struct sd_lun *un);
1622 static int sd_check_media(dev_t dev, enum dkio_state state);
1623 static int sd_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp);
1624 static void sd_delayed_cv_broadcast(void *arg);
1625 static int sr_volume_ctrl(dev_t dev, caddr_t data, int flag);
1626 static int sr_read_sony_session_offset(dev_t dev, caddr_t data, int flag);
1627 
1628 static int sd_log_page_supported(sd_ssc_t *ssc, int log_page);
1629 
1630 /*
1631  * Function Prototype for the non-512 support (DVDRAM, MO etc.) functions.
1632  */
1633 static void sd_check_for_writable_cd(sd_ssc_t *ssc, int path_flag);
1634 static int sd_wm_cache_constructor(void *wm, void *un, int flags);
1635 static void sd_wm_cache_destructor(void *wm, void *un);
1636 static struct sd_w_map *sd_range_lock(struct sd_lun *un, daddr_t startb,
1637         daddr_t endb, ushort_t typ);
1638 static struct sd_w_map *sd_get_range(struct sd_lun *un, daddr_t startb,
1639         daddr_t endb);
1640 static void sd_free_inlist_wmap(struct sd_lun *un, struct sd_w_map *wmp);
1641 static void sd_range_unlock(struct sd_lun *un, struct sd_w_map *wm);
1642 static void sd_read_modify_write_task(void * arg);
1643 static int
1644 sddump_do_read_of_rmw(struct sd_lun *un, uint64_t blkno, uint64_t nblk,
1645         struct buf **bpp);
1646 
1647 
1648 /*
1649  * Function prototypes for failfast support.
1650  */
1651 static void sd_failfast_flushq(struct sd_lun *un);
1652 static int sd_failfast_flushq_callback(struct buf *bp);
1653 
1654 /*
1655  * Function prototypes to check for lsi devices
1656  */
1657 static void sd_is_lsi(struct sd_lun *un);
1658 
1659 /*
1660  * Function prototypes for partial DMA support
1661  */
1662 static int sd_setup_next_xfer(struct sd_lun *un, struct buf *bp,
1663                 struct scsi_pkt *pkt, struct sd_xbuf *xp);
1664 
1665 
1666 /* Function prototypes for cmlb */
1667 static int sd_tg_rdwr(dev_info_t *devi, uchar_t cmd, void *bufaddr,
1668     diskaddr_t start_block, size_t reqlength, void *tg_cookie);
1669 
1670 static int sd_tg_getinfo(dev_info_t *devi, int cmd, void *arg, void *tg_cookie);
1671 
1672 /*
1673  * For printing RMW warning message timely
1674  */
1675 static void sd_rmw_msg_print_handler(void *arg);
1676 
1677 /*
1678  * Constants for failfast support:
1679  *
1680  * SD_FAILFAST_INACTIVE: Instance is currently in a normal state, with NO
1681  * failfast processing being performed.
1682  *
1683  * SD_FAILFAST_ACTIVE: Instance is in the failfast state and is performing
1684  * failfast processing on all bufs with B_FAILFAST set.
1685  */
1686 
1687 #define SD_FAILFAST_INACTIVE            0
1688 #define SD_FAILFAST_ACTIVE              1
1689 
1690 /*
1691  * Bitmask to control behavior of buf(9S) flushes when a transition to
1692  * the failfast state occurs. Optional bits include:
1693  *
1694  * SD_FAILFAST_FLUSH_ALL_BUFS: When set, flush ALL bufs including those that
1695  * do NOT have B_FAILFAST set. When clear, only bufs with B_FAILFAST will
1696  * be flushed.
1697  *
1698  * SD_FAILFAST_FLUSH_ALL_QUEUES: When set, flush any/all other queues in the
1699  * driver, in addition to the regular wait queue. This includes the xbuf
1700  * queues. When clear, only the driver's wait queue will be flushed.
1701  */
1702 #define SD_FAILFAST_FLUSH_ALL_BUFS      0x01
1703 #define SD_FAILFAST_FLUSH_ALL_QUEUES    0x02
1704 
1705 /*
1706  * The default behavior is to only flush bufs that have B_FAILFAST set, but
1707  * to flush all queues within the driver.
1708  */
1709 static int sd_failfast_flushctl = SD_FAILFAST_FLUSH_ALL_QUEUES;
1710 
1711 
1712 /*
1713  * SD Testing Fault Injection
1714  */
1715 #ifdef SD_FAULT_INJECTION
1716 static void sd_faultinjection_ioctl(int cmd, intptr_t arg, struct sd_lun *un);
1717 static void sd_faultinjection(struct scsi_pkt *pktp);
1718 static void sd_injection_log(char *buf, struct sd_lun *un);
1719 #endif
1720 
1721 /*
1722  * Device driver ops vector
1723  */
1724 static struct cb_ops sd_cb_ops = {
1725         sdopen,                 /* open */
1726         sdclose,                /* close */
1727         sdstrategy,             /* strategy */
1728         nodev,                  /* print */
1729         sddump,                 /* dump */
1730         sdread,                 /* read */
1731         sdwrite,                /* write */
1732         sdioctl,                /* ioctl */
1733         nodev,                  /* devmap */
1734         nodev,                  /* mmap */
1735         nodev,                  /* segmap */
1736         nochpoll,               /* poll */
1737         sd_prop_op,             /* cb_prop_op */
1738         0,                      /* streamtab  */
1739         D_64BIT | D_MP | D_NEW | D_HOTPLUG, /* Driver compatibility flags */
1740         CB_REV,                 /* cb_rev */
1741         sdaread,                /* async I/O read entry point */
1742         sdawrite                /* async I/O write entry point */
1743 };
1744 
1745 struct dev_ops sd_ops = {
1746         DEVO_REV,               /* devo_rev, */
1747         0,                      /* refcnt  */
1748         sdinfo,                 /* info */
1749         nulldev,                /* identify */
1750         sdprobe,                /* probe */
1751         sdattach,               /* attach */
1752         sddetach,               /* detach */
1753         nodev,                  /* reset */
1754         &sd_cb_ops,         /* driver operations */
1755         NULL,                   /* bus operations */
1756         sdpower,                /* power */
1757         ddi_quiesce_not_needed,         /* quiesce */
1758 };
1759 
1760 /*
1761  * This is the loadable module wrapper.
1762  */
1763 #include <sys/modctl.h>
1764 
1765 #ifndef XPV_HVM_DRIVER
1766 static struct modldrv modldrv = {
1767         &mod_driverops,             /* Type of module. This one is a driver */
1768         SD_MODULE_NAME,         /* Module name. */
1769         &sd_ops                     /* driver ops */
1770 };
1771 
1772 static struct modlinkage modlinkage = {
1773         MODREV_1, &modldrv, NULL
1774 };
1775 
1776 #else /* XPV_HVM_DRIVER */
1777 static struct modlmisc modlmisc = {
1778         &mod_miscops,               /* Type of module. This one is a misc */
1779         "HVM " SD_MODULE_NAME,          /* Module name. */
1780 };
1781 
1782 static struct modlinkage modlinkage = {
1783         MODREV_1, &modlmisc, NULL
1784 };
1785 
1786 #endif /* XPV_HVM_DRIVER */
1787 
1788 static cmlb_tg_ops_t sd_tgops = {
1789         TG_DK_OPS_VERSION_1,
1790         sd_tg_rdwr,
1791         sd_tg_getinfo
1792 };
1793 
1794 static struct scsi_asq_key_strings sd_additional_codes[] = {
1795         0x81, 0, "Logical Unit is Reserved",
1796         0x85, 0, "Audio Address Not Valid",
1797         0xb6, 0, "Media Load Mechanism Failed",
1798         0xB9, 0, "Audio Play Operation Aborted",
1799         0xbf, 0, "Buffer Overflow for Read All Subcodes Command",
1800         0x53, 2, "Medium removal prevented",
1801         0x6f, 0, "Authentication failed during key exchange",
1802         0x6f, 1, "Key not present",
1803         0x6f, 2, "Key not established",
1804         0x6f, 3, "Read without proper authentication",
1805         0x6f, 4, "Mismatched region to this logical unit",
1806         0x6f, 5, "Region reset count error",
1807         0xffff, 0x0, NULL
1808 };
1809 
1810 
1811 /*
1812  * Struct for passing printing information for sense data messages
1813  */
1814 struct sd_sense_info {
1815         int     ssi_severity;
1816         int     ssi_pfa_flag;
1817 };
1818 
1819 /*
1820  * Table of function pointers for iostart-side routines. Separate "chains"
1821  * of layered function calls are formed by placing the function pointers
1822  * sequentially in the desired order. Functions are called according to an
1823  * incrementing table index ordering. The last function in each chain must
1824  * be sd_core_iostart(). The corresponding iodone-side routines are expected
1825  * in the sd_iodone_chain[] array.
1826  *
1827  * Note: It may seem more natural to organize both the iostart and iodone
1828  * functions together, into an array of structures (or some similar
1829  * organization) with a common index, rather than two separate arrays which
1830  * must be maintained in synchronization. The purpose of this division is
1831  * to achieve improved performance: individual arrays allows for more
1832  * effective cache line utilization on certain platforms.
1833  */
1834 
1835 typedef void (*sd_chain_t)(int index, struct sd_lun *un, struct buf *bp);
1836 
1837 
1838 static sd_chain_t sd_iostart_chain[] = {
1839 
1840         /* Chain for buf IO for disk drive targets (PM enabled) */
1841         sd_mapblockaddr_iostart,        /* Index: 0 */
1842         sd_pm_iostart,                  /* Index: 1 */
1843         sd_core_iostart,                /* Index: 2 */
1844 
1845         /* Chain for buf IO for disk drive targets (PM disabled) */
1846         sd_mapblockaddr_iostart,        /* Index: 3 */
1847         sd_core_iostart,                /* Index: 4 */
1848 
1849         /*
1850          * Chain for buf IO for removable-media or large sector size
1851          * disk drive targets with RMW needed (PM enabled)
1852          */
1853         sd_mapblockaddr_iostart,        /* Index: 5 */
1854         sd_mapblocksize_iostart,        /* Index: 6 */
1855         sd_pm_iostart,                  /* Index: 7 */
1856         sd_core_iostart,                /* Index: 8 */
1857 
1858         /*
1859          * Chain for buf IO for removable-media or large sector size
1860          * disk drive targets with RMW needed (PM disabled)
1861          */
1862         sd_mapblockaddr_iostart,        /* Index: 9 */
1863         sd_mapblocksize_iostart,        /* Index: 10 */
1864         sd_core_iostart,                /* Index: 11 */
1865 
1866         /* Chain for buf IO for disk drives with checksumming (PM enabled) */
1867         sd_mapblockaddr_iostart,        /* Index: 12 */
1868         sd_checksum_iostart,            /* Index: 13 */
1869         sd_pm_iostart,                  /* Index: 14 */
1870         sd_core_iostart,                /* Index: 15 */
1871 
1872         /* Chain for buf IO for disk drives with checksumming (PM disabled) */
1873         sd_mapblockaddr_iostart,        /* Index: 16 */
1874         sd_checksum_iostart,            /* Index: 17 */
1875         sd_core_iostart,                /* Index: 18 */
1876 
1877         /* Chain for USCSI commands (all targets) */
1878         sd_pm_iostart,                  /* Index: 19 */
1879         sd_core_iostart,                /* Index: 20 */
1880 
1881         /* Chain for checksumming USCSI commands (all targets) */
1882         sd_checksum_uscsi_iostart,      /* Index: 21 */
1883         sd_pm_iostart,                  /* Index: 22 */
1884         sd_core_iostart,                /* Index: 23 */
1885 
1886         /* Chain for "direct" USCSI commands (all targets) */
1887         sd_core_iostart,                /* Index: 24 */
1888 
1889         /* Chain for "direct priority" USCSI commands (all targets) */
1890         sd_core_iostart,                /* Index: 25 */
1891 
1892         /*
1893          * Chain for buf IO for large sector size disk drive targets
1894          * with RMW needed with checksumming (PM enabled)
1895          */
1896         sd_mapblockaddr_iostart,        /* Index: 26 */
1897         sd_mapblocksize_iostart,        /* Index: 27 */
1898         sd_checksum_iostart,            /* Index: 28 */
1899         sd_pm_iostart,                  /* Index: 29 */
1900         sd_core_iostart,                /* Index: 30 */
1901 
1902         /*
1903          * Chain for buf IO for large sector size disk drive targets
1904          * with RMW needed with checksumming (PM disabled)
1905          */
1906         sd_mapblockaddr_iostart,        /* Index: 31 */
1907         sd_mapblocksize_iostart,        /* Index: 32 */
1908         sd_checksum_iostart,            /* Index: 33 */
1909         sd_core_iostart,                /* Index: 34 */
1910 
1911 };
1912 
1913 /*
1914  * Macros to locate the first function of each iostart chain in the
1915  * sd_iostart_chain[] array. These are located by the index in the array.
1916  */
1917 #define SD_CHAIN_DISK_IOSTART                   0
1918 #define SD_CHAIN_DISK_IOSTART_NO_PM             3
1919 #define SD_CHAIN_MSS_DISK_IOSTART               5
1920 #define SD_CHAIN_RMMEDIA_IOSTART                5
1921 #define SD_CHAIN_MSS_DISK_IOSTART_NO_PM         9
1922 #define SD_CHAIN_RMMEDIA_IOSTART_NO_PM          9
1923 #define SD_CHAIN_CHKSUM_IOSTART                 12
1924 #define SD_CHAIN_CHKSUM_IOSTART_NO_PM           16
1925 #define SD_CHAIN_USCSI_CMD_IOSTART              19
1926 #define SD_CHAIN_USCSI_CHKSUM_IOSTART           21
1927 #define SD_CHAIN_DIRECT_CMD_IOSTART             24
1928 #define SD_CHAIN_PRIORITY_CMD_IOSTART           25
1929 #define SD_CHAIN_MSS_CHKSUM_IOSTART             26
1930 #define SD_CHAIN_MSS_CHKSUM_IOSTART_NO_PM       31
1931 
1932 
1933 /*
1934  * Table of function pointers for the iodone-side routines for the driver-
1935  * internal layering mechanism.  The calling sequence for iodone routines
1936  * uses a decrementing table index, so the last routine called in a chain
1937  * must be at the lowest array index location for that chain.  The last
1938  * routine for each chain must be either sd_buf_iodone() (for buf(9S) IOs)
1939  * or sd_uscsi_iodone() (for uscsi IOs).  Other than this, the ordering
1940  * of the functions in an iodone side chain must correspond to the ordering
1941  * of the iostart routines for that chain.  Note that there is no iodone
1942  * side routine that corresponds to sd_core_iostart(), so there is no
1943  * entry in the table for this.
1944  */
1945 
1946 static sd_chain_t sd_iodone_chain[] = {
1947 
1948         /* Chain for buf IO for disk drive targets (PM enabled) */
1949         sd_buf_iodone,                  /* Index: 0 */
1950         sd_mapblockaddr_iodone,         /* Index: 1 */
1951         sd_pm_iodone,                   /* Index: 2 */
1952 
1953         /* Chain for buf IO for disk drive targets (PM disabled) */
1954         sd_buf_iodone,                  /* Index: 3 */
1955         sd_mapblockaddr_iodone,         /* Index: 4 */
1956 
1957         /*
1958          * Chain for buf IO for removable-media or large sector size
1959          * disk drive targets with RMW needed (PM enabled)
1960          */
1961         sd_buf_iodone,                  /* Index: 5 */
1962         sd_mapblockaddr_iodone,         /* Index: 6 */
1963         sd_mapblocksize_iodone,         /* Index: 7 */
1964         sd_pm_iodone,                   /* Index: 8 */
1965 
1966         /*
1967          * Chain for buf IO for removable-media or large sector size
1968          * disk drive targets with RMW needed (PM disabled)
1969          */
1970         sd_buf_iodone,                  /* Index: 9 */
1971         sd_mapblockaddr_iodone,         /* Index: 10 */
1972         sd_mapblocksize_iodone,         /* Index: 11 */
1973 
1974         /* Chain for buf IO for disk drives with checksumming (PM enabled) */
1975         sd_buf_iodone,                  /* Index: 12 */
1976         sd_mapblockaddr_iodone,         /* Index: 13 */
1977         sd_checksum_iodone,             /* Index: 14 */
1978         sd_pm_iodone,                   /* Index: 15 */
1979 
1980         /* Chain for buf IO for disk drives with checksumming (PM disabled) */
1981         sd_buf_iodone,                  /* Index: 16 */
1982         sd_mapblockaddr_iodone,         /* Index: 17 */
1983         sd_checksum_iodone,             /* Index: 18 */
1984 
1985         /* Chain for USCSI commands (non-checksum targets) */
1986         sd_uscsi_iodone,                /* Index: 19 */
1987         sd_pm_iodone,                   /* Index: 20 */
1988 
1989         /* Chain for USCSI commands (checksum targets) */
1990         sd_uscsi_iodone,                /* Index: 21 */
1991         sd_checksum_uscsi_iodone,       /* Index: 22 */
1992         sd_pm_iodone,                   /* Index: 22 */
1993 
1994         /* Chain for "direct" USCSI commands (all targets) */
1995         sd_uscsi_iodone,                /* Index: 24 */
1996 
1997         /* Chain for "direct priority" USCSI commands (all targets) */
1998         sd_uscsi_iodone,                /* Index: 25 */
1999 
2000         /*
2001          * Chain for buf IO for large sector size disk drive targets
2002          * with checksumming (PM enabled)
2003          */
2004         sd_buf_iodone,                  /* Index: 26 */
2005         sd_mapblockaddr_iodone,         /* Index: 27 */
2006         sd_mapblocksize_iodone,         /* Index: 28 */
2007         sd_checksum_iodone,             /* Index: 29 */
2008         sd_pm_iodone,                   /* Index: 30 */
2009 
2010         /*
2011          * Chain for buf IO for large sector size disk drive targets
2012          * with checksumming (PM disabled)
2013          */
2014         sd_buf_iodone,                  /* Index: 31 */
2015         sd_mapblockaddr_iodone,         /* Index: 32 */
2016         sd_mapblocksize_iodone,         /* Index: 33 */
2017         sd_checksum_iodone,             /* Index: 34 */
2018 };
2019 
2020 
2021 /*
2022  * Macros to locate the "first" function in the sd_iodone_chain[] array for
2023  * each iodone-side chain. These are located by the array index, but as the
2024  * iodone side functions are called in a decrementing-index order, the
2025  * highest index number in each chain must be specified (as these correspond
2026  * to the first function in the iodone chain that will be called by the core
2027  * at IO completion time).
2028  */
2029 
2030 #define SD_CHAIN_DISK_IODONE                    2
2031 #define SD_CHAIN_DISK_IODONE_NO_PM              4
2032 #define SD_CHAIN_RMMEDIA_IODONE                 8
2033 #define SD_CHAIN_MSS_DISK_IODONE                8
2034 #define SD_CHAIN_RMMEDIA_IODONE_NO_PM           11
2035 #define SD_CHAIN_MSS_DISK_IODONE_NO_PM          11
2036 #define SD_CHAIN_CHKSUM_IODONE                  15
2037 #define SD_CHAIN_CHKSUM_IODONE_NO_PM            18
2038 #define SD_CHAIN_USCSI_CMD_IODONE               20
2039 #define SD_CHAIN_USCSI_CHKSUM_IODONE            22
2040 #define SD_CHAIN_DIRECT_CMD_IODONE              24
2041 #define SD_CHAIN_PRIORITY_CMD_IODONE            25
2042 #define SD_CHAIN_MSS_CHKSUM_IODONE              30
2043 #define SD_CHAIN_MSS_CHKSUM_IODONE_NO_PM        34
2044 
2045 
2046 
2047 /*
2048  * Array to map a layering chain index to the appropriate initpkt routine.
2049  * The redundant entries are present so that the index used for accessing
2050  * the above sd_iostart_chain and sd_iodone_chain tables can be used directly
2051  * with this table as well.
2052  */
2053 typedef int (*sd_initpkt_t)(struct buf *, struct scsi_pkt **);
2054 
2055 static sd_initpkt_t     sd_initpkt_map[] = {
2056 
2057         /* Chain for buf IO for disk drive targets (PM enabled) */
2058         sd_initpkt_for_buf,             /* Index: 0 */
2059         sd_initpkt_for_buf,             /* Index: 1 */
2060         sd_initpkt_for_buf,             /* Index: 2 */
2061 
2062         /* Chain for buf IO for disk drive targets (PM disabled) */
2063         sd_initpkt_for_buf,             /* Index: 3 */
2064         sd_initpkt_for_buf,             /* Index: 4 */
2065 
2066         /*
2067          * Chain for buf IO for removable-media or large sector size
2068          * disk drive targets (PM enabled)
2069          */
2070         sd_initpkt_for_buf,             /* Index: 5 */
2071         sd_initpkt_for_buf,             /* Index: 6 */
2072         sd_initpkt_for_buf,             /* Index: 7 */
2073         sd_initpkt_for_buf,             /* Index: 8 */
2074 
2075         /*
2076          * Chain for buf IO for removable-media or large sector size
2077          * disk drive targets (PM disabled)
2078          */
2079         sd_initpkt_for_buf,             /* Index: 9 */
2080         sd_initpkt_for_buf,             /* Index: 10 */
2081         sd_initpkt_for_buf,             /* Index: 11 */
2082 
2083         /* Chain for buf IO for disk drives with checksumming (PM enabled) */
2084         sd_initpkt_for_buf,             /* Index: 12 */
2085         sd_initpkt_for_buf,             /* Index: 13 */
2086         sd_initpkt_for_buf,             /* Index: 14 */
2087         sd_initpkt_for_buf,             /* Index: 15 */
2088 
2089         /* Chain for buf IO for disk drives with checksumming (PM disabled) */
2090         sd_initpkt_for_buf,             /* Index: 16 */
2091         sd_initpkt_for_buf,             /* Index: 17 */
2092         sd_initpkt_for_buf,             /* Index: 18 */
2093 
2094         /* Chain for USCSI commands (non-checksum targets) */
2095         sd_initpkt_for_uscsi,           /* Index: 19 */
2096         sd_initpkt_for_uscsi,           /* Index: 20 */
2097 
2098         /* Chain for USCSI commands (checksum targets) */
2099         sd_initpkt_for_uscsi,           /* Index: 21 */
2100         sd_initpkt_for_uscsi,           /* Index: 22 */
2101         sd_initpkt_for_uscsi,           /* Index: 22 */
2102 
2103         /* Chain for "direct" USCSI commands (all targets) */
2104         sd_initpkt_for_uscsi,           /* Index: 24 */
2105 
2106         /* Chain for "direct priority" USCSI commands (all targets) */
2107         sd_initpkt_for_uscsi,           /* Index: 25 */
2108 
2109         /*
2110          * Chain for buf IO for large sector size disk drive targets
2111          * with checksumming (PM enabled)
2112          */
2113         sd_initpkt_for_buf,             /* Index: 26 */
2114         sd_initpkt_for_buf,             /* Index: 27 */
2115         sd_initpkt_for_buf,             /* Index: 28 */
2116         sd_initpkt_for_buf,             /* Index: 29 */
2117         sd_initpkt_for_buf,             /* Index: 30 */
2118 
2119         /*
2120          * Chain for buf IO for large sector size disk drive targets
2121          * with checksumming (PM disabled)
2122          */
2123         sd_initpkt_for_buf,             /* Index: 31 */
2124         sd_initpkt_for_buf,             /* Index: 32 */
2125         sd_initpkt_for_buf,             /* Index: 33 */
2126         sd_initpkt_for_buf,             /* Index: 34 */
2127 };
2128 
2129 
2130 /*
2131  * Array to map a layering chain index to the appropriate destroypktpkt routine.
2132  * The redundant entries are present so that the index used for accessing
2133  * the above sd_iostart_chain and sd_iodone_chain tables can be used directly
2134  * with this table as well.
2135  */
2136 typedef void (*sd_destroypkt_t)(struct buf *);
2137 
2138 static sd_destroypkt_t  sd_destroypkt_map[] = {
2139 
2140         /* Chain for buf IO for disk drive targets (PM enabled) */
2141         sd_destroypkt_for_buf,          /* Index: 0 */
2142         sd_destroypkt_for_buf,          /* Index: 1 */
2143         sd_destroypkt_for_buf,          /* Index: 2 */
2144 
2145         /* Chain for buf IO for disk drive targets (PM disabled) */
2146         sd_destroypkt_for_buf,          /* Index: 3 */
2147         sd_destroypkt_for_buf,          /* Index: 4 */
2148 
2149         /*
2150          * Chain for buf IO for removable-media or large sector size
2151          * disk drive targets (PM enabled)
2152          */
2153         sd_destroypkt_for_buf,          /* Index: 5 */
2154         sd_destroypkt_for_buf,          /* Index: 6 */
2155         sd_destroypkt_for_buf,          /* Index: 7 */
2156         sd_destroypkt_for_buf,          /* Index: 8 */
2157 
2158         /*
2159          * Chain for buf IO for removable-media or large sector size
2160          * disk drive targets (PM disabled)
2161          */
2162         sd_destroypkt_for_buf,          /* Index: 9 */
2163         sd_destroypkt_for_buf,          /* Index: 10 */
2164         sd_destroypkt_for_buf,          /* Index: 11 */
2165 
2166         /* Chain for buf IO for disk drives with checksumming (PM enabled) */
2167         sd_destroypkt_for_buf,          /* Index: 12 */
2168         sd_destroypkt_for_buf,          /* Index: 13 */
2169         sd_destroypkt_for_buf,          /* Index: 14 */
2170         sd_destroypkt_for_buf,          /* Index: 15 */
2171 
2172         /* Chain for buf IO for disk drives with checksumming (PM disabled) */
2173         sd_destroypkt_for_buf,          /* Index: 16 */
2174         sd_destroypkt_for_buf,          /* Index: 17 */
2175         sd_destroypkt_for_buf,          /* Index: 18 */
2176 
2177         /* Chain for USCSI commands (non-checksum targets) */
2178         sd_destroypkt_for_uscsi,        /* Index: 19 */
2179         sd_destroypkt_for_uscsi,        /* Index: 20 */
2180 
2181         /* Chain for USCSI commands (checksum targets) */
2182         sd_destroypkt_for_uscsi,        /* Index: 21 */
2183         sd_destroypkt_for_uscsi,        /* Index: 22 */
2184         sd_destroypkt_for_uscsi,        /* Index: 22 */
2185 
2186         /* Chain for "direct" USCSI commands (all targets) */
2187         sd_destroypkt_for_uscsi,        /* Index: 24 */
2188 
2189         /* Chain for "direct priority" USCSI commands (all targets) */
2190         sd_destroypkt_for_uscsi,        /* Index: 25 */
2191 
2192         /*
2193          * Chain for buf IO for large sector size disk drive targets
2194          * with checksumming (PM disabled)
2195          */
2196         sd_destroypkt_for_buf,          /* Index: 26 */
2197         sd_destroypkt_for_buf,          /* Index: 27 */
2198         sd_destroypkt_for_buf,          /* Index: 28 */
2199         sd_destroypkt_for_buf,          /* Index: 29 */
2200         sd_destroypkt_for_buf,          /* Index: 30 */
2201 
2202         /*
2203          * Chain for buf IO for large sector size disk drive targets
2204          * with checksumming (PM enabled)
2205          */
2206         sd_destroypkt_for_buf,          /* Index: 31 */
2207         sd_destroypkt_for_buf,          /* Index: 32 */
2208         sd_destroypkt_for_buf,          /* Index: 33 */
2209         sd_destroypkt_for_buf,          /* Index: 34 */
2210 };
2211 
2212 
2213 
2214 /*
2215  * Array to map a layering chain index to the appropriate chain "type".
2216  * The chain type indicates a specific property/usage of the chain.
2217  * The redundant entries are present so that the index used for accessing
2218  * the above sd_iostart_chain and sd_iodone_chain tables can be used directly
2219  * with this table as well.
2220  */
2221 
2222 #define SD_CHAIN_NULL                   0       /* for the special RQS cmd */
2223 #define SD_CHAIN_BUFIO                  1       /* regular buf IO */
2224 #define SD_CHAIN_USCSI                  2       /* regular USCSI commands */
2225 #define SD_CHAIN_DIRECT                 3       /* uscsi, w/ bypass power mgt */
2226 #define SD_CHAIN_DIRECT_PRIORITY        4       /* uscsi, w/ bypass power mgt */
2227                                                 /* (for error recovery) */
2228 
2229 static int sd_chain_type_map[] = {
2230 
2231         /* Chain for buf IO for disk drive targets (PM enabled) */
2232         SD_CHAIN_BUFIO,                 /* Index: 0 */
2233         SD_CHAIN_BUFIO,                 /* Index: 1 */
2234         SD_CHAIN_BUFIO,                 /* Index: 2 */
2235 
2236         /* Chain for buf IO for disk drive targets (PM disabled) */
2237         SD_CHAIN_BUFIO,                 /* Index: 3 */
2238         SD_CHAIN_BUFIO,                 /* Index: 4 */
2239 
2240         /*
2241          * Chain for buf IO for removable-media or large sector size
2242          * disk drive targets (PM enabled)
2243          */
2244         SD_CHAIN_BUFIO,                 /* Index: 5 */
2245         SD_CHAIN_BUFIO,                 /* Index: 6 */
2246         SD_CHAIN_BUFIO,                 /* Index: 7 */
2247         SD_CHAIN_BUFIO,                 /* Index: 8 */
2248 
2249         /*
2250          * Chain for buf IO for removable-media or large sector size
2251          * disk drive targets (PM disabled)
2252          */
2253         SD_CHAIN_BUFIO,                 /* Index: 9 */
2254         SD_CHAIN_BUFIO,                 /* Index: 10 */
2255         SD_CHAIN_BUFIO,                 /* Index: 11 */
2256 
2257         /* Chain for buf IO for disk drives with checksumming (PM enabled) */
2258         SD_CHAIN_BUFIO,                 /* Index: 12 */
2259         SD_CHAIN_BUFIO,                 /* Index: 13 */
2260         SD_CHAIN_BUFIO,                 /* Index: 14 */
2261         SD_CHAIN_BUFIO,                 /* Index: 15 */
2262 
2263         /* Chain for buf IO for disk drives with checksumming (PM disabled) */
2264         SD_CHAIN_BUFIO,                 /* Index: 16 */
2265         SD_CHAIN_BUFIO,                 /* Index: 17 */
2266         SD_CHAIN_BUFIO,                 /* Index: 18 */
2267 
2268         /* Chain for USCSI commands (non-checksum targets) */
2269         SD_CHAIN_USCSI,                 /* Index: 19 */
2270         SD_CHAIN_USCSI,                 /* Index: 20 */
2271 
2272         /* Chain for USCSI commands (checksum targets) */
2273         SD_CHAIN_USCSI,                 /* Index: 21 */
2274         SD_CHAIN_USCSI,                 /* Index: 22 */
2275         SD_CHAIN_USCSI,                 /* Index: 23 */
2276 
2277         /* Chain for "direct" USCSI commands (all targets) */
2278         SD_CHAIN_DIRECT,                /* Index: 24 */
2279 
2280         /* Chain for "direct priority" USCSI commands (all targets) */
2281         SD_CHAIN_DIRECT_PRIORITY,       /* Index: 25 */
2282 
2283         /*
2284          * Chain for buf IO for large sector size disk drive targets
2285          * with checksumming (PM enabled)
2286          */
2287         SD_CHAIN_BUFIO,                 /* Index: 26 */
2288         SD_CHAIN_BUFIO,                 /* Index: 27 */
2289         SD_CHAIN_BUFIO,                 /* Index: 28 */
2290         SD_CHAIN_BUFIO,                 /* Index: 29 */
2291         SD_CHAIN_BUFIO,                 /* Index: 30 */
2292 
2293         /*
2294          * Chain for buf IO for large sector size disk drive targets
2295          * with checksumming (PM disabled)
2296          */
2297         SD_CHAIN_BUFIO,                 /* Index: 31 */
2298         SD_CHAIN_BUFIO,                 /* Index: 32 */
2299         SD_CHAIN_BUFIO,                 /* Index: 33 */
2300         SD_CHAIN_BUFIO,                 /* Index: 34 */
2301 };
2302 
2303 
2304 /* Macro to return TRUE if the IO has come from the sd_buf_iostart() chain. */
2305 #define SD_IS_BUFIO(xp)                 \
2306         (sd_chain_type_map[(xp)->xb_chain_iostart] == SD_CHAIN_BUFIO)
2307 
2308 /* Macro to return TRUE if the IO has come from the "direct priority" chain. */
2309 #define SD_IS_DIRECT_PRIORITY(xp)       \
2310         (sd_chain_type_map[(xp)->xb_chain_iostart] == SD_CHAIN_DIRECT_PRIORITY)
2311 
2312 
2313 
2314 /*
2315  * Struct, array, and macros to map a specific chain to the appropriate
2316  * layering indexes in the sd_iostart_chain[] and sd_iodone_chain[] arrays.
2317  *
2318  * The sd_chain_index_map[] array is used at attach time to set the various
2319  * un_xxx_chain type members of the sd_lun softstate to the specific layering
2320  * chain to be used with the instance. This allows different instances to use
2321  * different chain for buf IO, uscsi IO, etc.. Also, since the xb_chain_iostart
2322  * and xb_chain_iodone index values in the sd_xbuf are initialized to these
2323  * values at sd_xbuf init time, this allows (1) layering chains may be changed
2324  * dynamically & without the use of locking; and (2) a layer may update the
2325  * xb_chain_io[start|done] member in a given xbuf with its current index value,
2326  * to allow for deferred processing of an IO within the same chain from a
2327  * different execution context.
2328  */
2329 
2330 struct sd_chain_index {
2331         int     sci_iostart_index;
2332         int     sci_iodone_index;
2333 };
2334 
2335 static struct sd_chain_index    sd_chain_index_map[] = {
2336         { SD_CHAIN_DISK_IOSTART,                SD_CHAIN_DISK_IODONE },
2337         { SD_CHAIN_DISK_IOSTART_NO_PM,          SD_CHAIN_DISK_IODONE_NO_PM },
2338         { SD_CHAIN_RMMEDIA_IOSTART,             SD_CHAIN_RMMEDIA_IODONE },
2339         { SD_CHAIN_RMMEDIA_IOSTART_NO_PM,       SD_CHAIN_RMMEDIA_IODONE_NO_PM },
2340         { SD_CHAIN_CHKSUM_IOSTART,              SD_CHAIN_CHKSUM_IODONE },
2341         { SD_CHAIN_CHKSUM_IOSTART_NO_PM,        SD_CHAIN_CHKSUM_IODONE_NO_PM },
2342         { SD_CHAIN_USCSI_CMD_IOSTART,           SD_CHAIN_USCSI_CMD_IODONE },
2343         { SD_CHAIN_USCSI_CHKSUM_IOSTART,        SD_CHAIN_USCSI_CHKSUM_IODONE },
2344         { SD_CHAIN_DIRECT_CMD_IOSTART,          SD_CHAIN_DIRECT_CMD_IODONE },
2345         { SD_CHAIN_PRIORITY_CMD_IOSTART,        SD_CHAIN_PRIORITY_CMD_IODONE },
2346         { SD_CHAIN_MSS_CHKSUM_IOSTART,          SD_CHAIN_MSS_CHKSUM_IODONE },
2347         { SD_CHAIN_MSS_CHKSUM_IOSTART_NO_PM, SD_CHAIN_MSS_CHKSUM_IODONE_NO_PM },
2348 
2349 };
2350 
2351 
2352 /*
2353  * The following are indexes into the sd_chain_index_map[] array.
2354  */
2355 
2356 /* un->un_buf_chain_type must be set to one of these */
2357 #define SD_CHAIN_INFO_DISK              0
2358 #define SD_CHAIN_INFO_DISK_NO_PM        1
2359 #define SD_CHAIN_INFO_RMMEDIA           2
2360 #define SD_CHAIN_INFO_MSS_DISK          2
2361 #define SD_CHAIN_INFO_RMMEDIA_NO_PM     3
2362 #define SD_CHAIN_INFO_MSS_DSK_NO_PM     3
2363 #define SD_CHAIN_INFO_CHKSUM            4
2364 #define SD_CHAIN_INFO_CHKSUM_NO_PM      5
2365 #define SD_CHAIN_INFO_MSS_DISK_CHKSUM   10
2366 #define SD_CHAIN_INFO_MSS_DISK_CHKSUM_NO_PM     11
2367 
2368 /* un->un_uscsi_chain_type must be set to one of these */
2369 #define SD_CHAIN_INFO_USCSI_CMD         6
2370 /* USCSI with PM disabled is the same as DIRECT */
2371 #define SD_CHAIN_INFO_USCSI_CMD_NO_PM   8
2372 #define SD_CHAIN_INFO_USCSI_CHKSUM      7
2373 
2374 /* un->un_direct_chain_type must be set to one of these */
2375 #define SD_CHAIN_INFO_DIRECT_CMD        8
2376 
2377 /* un->un_priority_chain_type must be set to one of these */
2378 #define SD_CHAIN_INFO_PRIORITY_CMD      9
2379 
2380 /* size for devid inquiries */
2381 #define MAX_INQUIRY_SIZE                0xF0
2382 
2383 /*
2384  * Macros used by functions to pass a given buf(9S) struct along to the
2385  * next function in the layering chain for further processing.
2386  *
2387  * In the following macros, passing more than three arguments to the called
2388  * routines causes the optimizer for the SPARC compiler to stop doing tail
2389  * call elimination which results in significant performance degradation.
2390  */
2391 #define SD_BEGIN_IOSTART(index, un, bp) \
2392         ((*(sd_iostart_chain[index]))(index, un, bp))
2393 
2394 #define SD_BEGIN_IODONE(index, un, bp)  \
2395         ((*(sd_iodone_chain[index]))(index, un, bp))
2396 
2397 #define SD_NEXT_IOSTART(index, un, bp)                          \
2398         ((*(sd_iostart_chain[(index) + 1]))((index) + 1, un, bp))
2399 
2400 #define SD_NEXT_IODONE(index, un, bp)                           \
2401         ((*(sd_iodone_chain[(index) - 1]))((index) - 1, un, bp))
2402 
2403 /*
2404  *    Function: _init
2405  *
2406  * Description: This is the driver _init(9E) entry point.
2407  *
2408  * Return Code: Returns the value from mod_install(9F) or
2409  *              ddi_soft_state_init(9F) as appropriate.
2410  *
2411  *     Context: Called when driver module loaded.
2412  */
2413 
2414 int
2415 _init(void)
2416 {
2417         int     err;
2418 
2419         /* establish driver name from module name */
2420         sd_label = (char *)mod_modname(&modlinkage);
2421 
2422 #ifndef XPV_HVM_DRIVER
2423         err = ddi_soft_state_init(&sd_state, sizeof (struct sd_lun),
2424             SD_MAXUNIT);
2425         if (err != 0) {
2426                 return (err);
2427         }
2428 
2429 #else /* XPV_HVM_DRIVER */
2430         /* Remove the leading "hvm_" from the module name */
2431         ASSERT(strncmp(sd_label, "hvm_", strlen("hvm_")) == 0);
2432         sd_label += strlen("hvm_");
2433 
2434 #endif /* XPV_HVM_DRIVER */
2435 
2436         mutex_init(&sd_detach_mutex, NULL, MUTEX_DRIVER, NULL);
2437         mutex_init(&sd_log_mutex,    NULL, MUTEX_DRIVER, NULL);
2438         mutex_init(&sd_label_mutex,  NULL, MUTEX_DRIVER, NULL);
2439 
2440         mutex_init(&sd_tr.srq_resv_reclaim_mutex, NULL, MUTEX_DRIVER, NULL);
2441         cv_init(&sd_tr.srq_resv_reclaim_cv, NULL, CV_DRIVER, NULL);
2442         cv_init(&sd_tr.srq_inprocess_cv, NULL, CV_DRIVER, NULL);
2443 
2444         /*
2445          * it's ok to init here even for fibre device
2446          */
2447         sd_scsi_probe_cache_init();
2448 
2449         sd_scsi_target_lun_init();
2450 
2451         /*
2452          * Creating taskq before mod_install ensures that all callers (threads)
2453          * that enter the module after a successful mod_install encounter
2454          * a valid taskq.
2455          */
2456         sd_taskq_create();
2457 
2458         err = mod_install(&modlinkage);
2459         if (err != 0) {
2460                 /* delete taskq if install fails */
2461                 sd_taskq_delete();
2462 
2463                 mutex_destroy(&sd_detach_mutex);
2464                 mutex_destroy(&sd_log_mutex);
2465                 mutex_destroy(&sd_label_mutex);
2466 
2467                 mutex_destroy(&sd_tr.srq_resv_reclaim_mutex);
2468                 cv_destroy(&sd_tr.srq_resv_reclaim_cv);
2469                 cv_destroy(&sd_tr.srq_inprocess_cv);
2470 
2471                 sd_scsi_probe_cache_fini();
2472 
2473                 sd_scsi_target_lun_fini();
2474 
2475 #ifndef XPV_HVM_DRIVER
2476                 ddi_soft_state_fini(&sd_state);
2477 #endif /* !XPV_HVM_DRIVER */
2478                 return (err);
2479         }
2480 
2481         return (err);
2482 }
2483 
2484 
2485 /*
2486  *    Function: _fini
2487  *
2488  * Description: This is the driver _fini(9E) entry point.
2489  *
2490  * Return Code: Returns the value from mod_remove(9F)
2491  *
2492  *     Context: Called when driver module is unloaded.
2493  */
2494 
2495 int
2496 _fini(void)
2497 {
2498         int err;
2499 
2500         if ((err = mod_remove(&modlinkage)) != 0) {
2501                 return (err);
2502         }
2503 
2504         sd_taskq_delete();
2505 
2506         mutex_destroy(&sd_detach_mutex);
2507         mutex_destroy(&sd_log_mutex);
2508         mutex_destroy(&sd_label_mutex);
2509         mutex_destroy(&sd_tr.srq_resv_reclaim_mutex);
2510 
2511         sd_scsi_probe_cache_fini();
2512 
2513         sd_scsi_target_lun_fini();
2514 
2515         cv_destroy(&sd_tr.srq_resv_reclaim_cv);
2516         cv_destroy(&sd_tr.srq_inprocess_cv);
2517 
2518 #ifndef XPV_HVM_DRIVER
2519         ddi_soft_state_fini(&sd_state);
2520 #endif /* !XPV_HVM_DRIVER */
2521 
2522         return (err);
2523 }
2524 
2525 
2526 /*
2527  *    Function: _info
2528  *
2529  * Description: This is the driver _info(9E) entry point.
2530  *
2531  *   Arguments: modinfop - pointer to the driver modinfo structure
2532  *
2533  * Return Code: Returns the value from mod_info(9F).
2534  *
2535  *     Context: Kernel thread context
2536  */
2537 
2538 int
2539 _info(struct modinfo *modinfop)
2540 {
2541         return (mod_info(&modlinkage, modinfop));
2542 }
2543 
2544 
2545 /*
2546  * The following routines implement the driver message logging facility.
2547  * They provide component- and level- based debug output filtering.
2548  * Output may also be restricted to messages for a single instance by
2549  * specifying a soft state pointer in sd_debug_un. If sd_debug_un is set
2550  * to NULL, then messages for all instances are printed.
2551  *
2552  * These routines have been cloned from each other due to the language
2553  * constraints of macros and variable argument list processing.
2554  */
2555 
2556 
2557 /*
2558  *    Function: sd_log_err
2559  *
2560  * Description: This routine is called by the SD_ERROR macro for debug
2561  *              logging of error conditions.
2562  *
2563  *   Arguments: comp - driver component being logged
2564  *              dev  - pointer to driver info structure
2565  *              fmt  - error string and format to be logged
2566  */
2567 
2568 static void
2569 sd_log_err(uint_t comp, struct sd_lun *un, const char *fmt, ...)
2570 {
2571         va_list         ap;
2572         dev_info_t      *dev;
2573 
2574         ASSERT(un != NULL);
2575         dev = SD_DEVINFO(un);
2576         ASSERT(dev != NULL);
2577 
2578         /*
2579          * Filter messages based on the global component and level masks.
2580          * Also print if un matches the value of sd_debug_un, or if
2581          * sd_debug_un is set to NULL.
2582          */
2583         if ((sd_component_mask & comp) && (sd_level_mask & SD_LOGMASK_ERROR) &&
2584             ((sd_debug_un == NULL) || (sd_debug_un == un))) {
2585                 mutex_enter(&sd_log_mutex);
2586                 va_start(ap, fmt);
2587                 (void) vsprintf(sd_log_buf, fmt, ap);
2588                 va_end(ap);
2589                 scsi_log(dev, sd_label, CE_CONT, "%s", sd_log_buf);
2590                 mutex_exit(&sd_log_mutex);
2591         }
2592 #ifdef SD_FAULT_INJECTION
2593         _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::sd_injection_mask));
2594         if (un->sd_injection_mask & comp) {
2595                 mutex_enter(&sd_log_mutex);
2596                 va_start(ap, fmt);
2597                 (void) vsprintf(sd_log_buf, fmt, ap);
2598                 va_end(ap);
2599                 sd_injection_log(sd_log_buf, un);
2600                 mutex_exit(&sd_log_mutex);
2601         }
2602 #endif
2603 }
2604 
2605 
2606 /*
2607  *    Function: sd_log_info
2608  *
2609  * Description: This routine is called by the SD_INFO macro for debug
2610  *              logging of general purpose informational conditions.
2611  *
2612  *   Arguments: comp - driver component being logged
2613  *              dev  - pointer to driver info structure
2614  *              fmt  - info string and format to be logged
2615  */
2616 
2617 static void
2618 sd_log_info(uint_t component, struct sd_lun *un, const char *fmt, ...)
2619 {
2620         va_list         ap;
2621         dev_info_t      *dev;
2622 
2623         ASSERT(un != NULL);
2624         dev = SD_DEVINFO(un);
2625         ASSERT(dev != NULL);
2626 
2627         /*
2628          * Filter messages based on the global component and level masks.
2629          * Also print if un matches the value of sd_debug_un, or if
2630          * sd_debug_un is set to NULL.
2631          */
2632         if ((sd_component_mask & component) &&
2633             (sd_level_mask & SD_LOGMASK_INFO) &&
2634             ((sd_debug_un == NULL) || (sd_debug_un == un))) {
2635                 mutex_enter(&sd_log_mutex);
2636                 va_start(ap, fmt);
2637                 (void) vsprintf(sd_log_buf, fmt, ap);
2638                 va_end(ap);
2639                 scsi_log(dev, sd_label, CE_CONT, "%s", sd_log_buf);
2640                 mutex_exit(&sd_log_mutex);
2641         }
2642 #ifdef SD_FAULT_INJECTION
2643         _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::sd_injection_mask));
2644         if (un->sd_injection_mask & component) {
2645                 mutex_enter(&sd_log_mutex);
2646                 va_start(ap, fmt);
2647                 (void) vsprintf(sd_log_buf, fmt, ap);
2648                 va_end(ap);
2649                 sd_injection_log(sd_log_buf, un);
2650                 mutex_exit(&sd_log_mutex);
2651         }
2652 #endif
2653 }
2654 
2655 
2656 /*
2657  *    Function: sd_log_trace
2658  *
2659  * Description: This routine is called by the SD_TRACE macro for debug
2660  *              logging of trace conditions (i.e. function entry/exit).
2661  *
2662  *   Arguments: comp - driver component being logged
2663  *              dev  - pointer to driver info structure
2664  *              fmt  - trace string and format to be logged
2665  */
2666 
2667 static void
2668 sd_log_trace(uint_t component, struct sd_lun *un, const char *fmt, ...)
2669 {
2670         va_list         ap;
2671         dev_info_t      *dev;
2672 
2673         ASSERT(un != NULL);
2674         dev = SD_DEVINFO(un);
2675         ASSERT(dev != NULL);
2676 
2677         /*
2678          * Filter messages based on the global component and level masks.
2679          * Also print if un matches the value of sd_debug_un, or if
2680          * sd_debug_un is set to NULL.
2681          */
2682         if ((sd_component_mask & component) &&
2683             (sd_level_mask & SD_LOGMASK_TRACE) &&
2684             ((sd_debug_un == NULL) || (sd_debug_un == un))) {
2685                 mutex_enter(&sd_log_mutex);
2686                 va_start(ap, fmt);
2687                 (void) vsprintf(sd_log_buf, fmt, ap);
2688                 va_end(ap);
2689                 scsi_log(dev, sd_label, CE_CONT, "%s", sd_log_buf);
2690                 mutex_exit(&sd_log_mutex);
2691         }
2692 #ifdef SD_FAULT_INJECTION
2693         _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::sd_injection_mask));
2694         if (un->sd_injection_mask & component) {
2695                 mutex_enter(&sd_log_mutex);
2696                 va_start(ap, fmt);
2697                 (void) vsprintf(sd_log_buf, fmt, ap);
2698                 va_end(ap);
2699                 sd_injection_log(sd_log_buf, un);
2700                 mutex_exit(&sd_log_mutex);
2701         }
2702 #endif
2703 }
2704 
2705 
2706 /*
2707  *    Function: sdprobe
2708  *
2709  * Description: This is the driver probe(9e) entry point function.
2710  *
2711  *   Arguments: devi - opaque device info handle
2712  *
2713  * Return Code: DDI_PROBE_SUCCESS: If the probe was successful.
2714  *              DDI_PROBE_FAILURE: If the probe failed.
2715  *              DDI_PROBE_PARTIAL: If the instance is not present now,
2716  *                                 but may be present in the future.
2717  */
2718 
2719 static int
2720 sdprobe(dev_info_t *devi)
2721 {
2722         struct scsi_device      *devp;
2723         int                     rval;
2724 #ifndef XPV_HVM_DRIVER
2725         int                     instance = ddi_get_instance(devi);
2726 #endif /* !XPV_HVM_DRIVER */
2727 
2728         /*
2729          * if it wasn't for pln, sdprobe could actually be nulldev
2730          * in the "__fibre" case.
2731          */
2732         if (ddi_dev_is_sid(devi) == DDI_SUCCESS) {
2733                 return (DDI_PROBE_DONTCARE);
2734         }
2735 
2736         devp = ddi_get_driver_private(devi);
2737 
2738         if (devp == NULL) {
2739                 /* Ooops... nexus driver is mis-configured... */
2740                 return (DDI_PROBE_FAILURE);
2741         }
2742 
2743 #ifndef XPV_HVM_DRIVER
2744         if (ddi_get_soft_state(sd_state, instance) != NULL) {
2745                 return (DDI_PROBE_PARTIAL);
2746         }
2747 #endif /* !XPV_HVM_DRIVER */
2748 
2749         /*
2750          * Call the SCSA utility probe routine to see if we actually
2751          * have a target at this SCSI nexus.
2752          */
2753         switch (sd_scsi_probe_with_cache(devp, NULL_FUNC)) {
2754         case SCSIPROBE_EXISTS:
2755                 switch (devp->sd_inq->inq_dtype) {
2756                 case DTYPE_DIRECT:
2757                         rval = DDI_PROBE_SUCCESS;
2758                         break;
2759                 case DTYPE_RODIRECT:
2760                         /* CDs etc. Can be removable media */
2761                         rval = DDI_PROBE_SUCCESS;
2762                         break;
2763                 case DTYPE_OPTICAL:
2764                         /*
2765                          * Rewritable optical driver HP115AA
2766                          * Can also be removable media
2767                          */
2768 
2769                         /*
2770                          * Do not attempt to bind to  DTYPE_OPTICAL if
2771                          * pre solaris 9 sparc sd behavior is required
2772                          *
2773                          * If first time through and sd_dtype_optical_bind
2774                          * has not been set in /etc/system check properties
2775                          */
2776 
2777                         if (sd_dtype_optical_bind  < 0) {
2778                                 sd_dtype_optical_bind = ddi_prop_get_int
2779                                     (DDI_DEV_T_ANY, devi, 0,
2780                                     "optical-device-bind", 1);
2781                         }
2782 
2783                         if (sd_dtype_optical_bind == 0) {
2784                                 rval = DDI_PROBE_FAILURE;
2785                         } else {
2786                                 rval = DDI_PROBE_SUCCESS;
2787                         }
2788                         break;
2789 
2790                 case DTYPE_NOTPRESENT:
2791                 default:
2792                         rval = DDI_PROBE_FAILURE;
2793                         break;
2794                 }
2795                 break;
2796         default:
2797                 rval = DDI_PROBE_PARTIAL;
2798                 break;
2799         }
2800 
2801         /*
2802          * This routine checks for resource allocation prior to freeing,
2803          * so it will take care of the "smart probing" case where a
2804          * scsi_probe() may or may not have been issued and will *not*
2805          * free previously-freed resources.
2806          */
2807         scsi_unprobe(devp);
2808         return (rval);
2809 }
2810 
2811 
2812 /*
2813  *    Function: sdinfo
2814  *
2815  * Description: This is the driver getinfo(9e) entry point function.
2816  *              Given the device number, return the devinfo pointer from
2817  *              the scsi_device structure or the instance number
2818  *              associated with the dev_t.
2819  *
2820  *   Arguments: dip     - pointer to device info structure
2821  *              infocmd - command argument (DDI_INFO_DEVT2DEVINFO,
2822  *                        DDI_INFO_DEVT2INSTANCE)
2823  *              arg     - driver dev_t
2824  *              resultp - user buffer for request response
2825  *
2826  * Return Code: DDI_SUCCESS
2827  *              DDI_FAILURE
2828  */
2829 /* ARGSUSED */
2830 static int
2831 sdinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
2832 {
2833         struct sd_lun   *un;
2834         dev_t           dev;
2835         int             instance;
2836         int             error;
2837 
2838         switch (infocmd) {
2839         case DDI_INFO_DEVT2DEVINFO:
2840                 dev = (dev_t)arg;
2841                 instance = SDUNIT(dev);
2842                 if ((un = ddi_get_soft_state(sd_state, instance)) == NULL) {
2843                         return (DDI_FAILURE);
2844                 }
2845                 *result = (void *) SD_DEVINFO(un);
2846                 error = DDI_SUCCESS;
2847                 break;
2848         case DDI_INFO_DEVT2INSTANCE:
2849                 dev = (dev_t)arg;
2850                 instance = SDUNIT(dev);
2851                 *result = (void *)(uintptr_t)instance;
2852                 error = DDI_SUCCESS;
2853                 break;
2854         default:
2855                 error = DDI_FAILURE;
2856         }
2857         return (error);
2858 }
2859 
2860 /*
2861  *    Function: sd_prop_op
2862  *
2863  * Description: This is the driver prop_op(9e) entry point function.
2864  *              Return the number of blocks for the partition in question
2865  *              or forward the request to the property facilities.
2866  *
2867  *   Arguments: dev       - device number
2868  *              dip       - pointer to device info structure
2869  *              prop_op   - property operator
2870  *              mod_flags - DDI_PROP_DONTPASS, don't pass to parent
2871  *              name      - pointer to property name
2872  *              valuep    - pointer or address of the user buffer
2873  *              lengthp   - property length
2874  *
2875  * Return Code: DDI_PROP_SUCCESS
2876  *              DDI_PROP_NOT_FOUND
2877  *              DDI_PROP_UNDEFINED
2878  *              DDI_PROP_NO_MEMORY
2879  *              DDI_PROP_BUF_TOO_SMALL
2880  */
2881 
2882 static int
2883 sd_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
2884         char *name, caddr_t valuep, int *lengthp)
2885 {
2886         struct sd_lun   *un;
2887 
2888         if ((un = ddi_get_soft_state(sd_state, ddi_get_instance(dip))) == NULL)
2889                 return (ddi_prop_op(dev, dip, prop_op, mod_flags,
2890                     name, valuep, lengthp));
2891 
2892         return (cmlb_prop_op(un->un_cmlbhandle,
2893             dev, dip, prop_op, mod_flags, name, valuep, lengthp,
2894             SDPART(dev), (void *)SD_PATH_DIRECT));
2895 }
2896 
2897 /*
2898  * The following functions are for smart probing:
2899  * sd_scsi_probe_cache_init()
2900  * sd_scsi_probe_cache_fini()
2901  * sd_scsi_clear_probe_cache()
2902  * sd_scsi_probe_with_cache()
2903  */
2904 
2905 /*
2906  *    Function: sd_scsi_probe_cache_init
2907  *
2908  * Description: Initializes the probe response cache mutex and head pointer.
2909  *
2910  *     Context: Kernel thread context
2911  */
2912 
2913 static void
2914 sd_scsi_probe_cache_init(void)
2915 {
2916         mutex_init(&sd_scsi_probe_cache_mutex, NULL, MUTEX_DRIVER, NULL);
2917         sd_scsi_probe_cache_head = NULL;
2918 }
2919 
2920 
2921 /*
2922  *    Function: sd_scsi_probe_cache_fini
2923  *
2924  * Description: Frees all resources associated with the probe response cache.
2925  *
2926  *     Context: Kernel thread context
2927  */
2928 
2929 static void
2930 sd_scsi_probe_cache_fini(void)
2931 {
2932         struct sd_scsi_probe_cache *cp;
2933         struct sd_scsi_probe_cache *ncp;
2934 
2935         /* Clean up our smart probing linked list */
2936         for (cp = sd_scsi_probe_cache_head; cp != NULL; cp = ncp) {
2937                 ncp = cp->next;
2938                 kmem_free(cp, sizeof (struct sd_scsi_probe_cache));
2939         }
2940         sd_scsi_probe_cache_head = NULL;
2941         mutex_destroy(&sd_scsi_probe_cache_mutex);
2942 }
2943 
2944 
2945 /*
2946  *    Function: sd_scsi_clear_probe_cache
2947  *
2948  * Description: This routine clears the probe response cache. This is
2949  *              done when open() returns ENXIO so that when deferred
2950  *              attach is attempted (possibly after a device has been
2951  *              turned on) we will retry the probe. Since we don't know
2952  *              which target we failed to open, we just clear the
2953  *              entire cache.
2954  *
2955  *     Context: Kernel thread context
2956  */
2957 
2958 static void
2959 sd_scsi_clear_probe_cache(void)
2960 {
2961         struct sd_scsi_probe_cache      *cp;
2962         int                             i;
2963 
2964         mutex_enter(&sd_scsi_probe_cache_mutex);
2965         for (cp = sd_scsi_probe_cache_head; cp != NULL; cp = cp->next) {
2966                 /*
2967                  * Reset all entries to SCSIPROBE_EXISTS.  This will
2968                  * force probing to be performed the next time
2969                  * sd_scsi_probe_with_cache is called.
2970                  */
2971                 for (i = 0; i < NTARGETS_WIDE; i++) {
2972                         cp->cache[i] = SCSIPROBE_EXISTS;
2973                 }
2974         }
2975         mutex_exit(&sd_scsi_probe_cache_mutex);
2976 }
2977 
2978 
2979 /*
2980  *    Function: sd_scsi_probe_with_cache
2981  *
2982  * Description: This routine implements support for a scsi device probe
2983  *              with cache. The driver maintains a cache of the target
2984  *              responses to scsi probes. If we get no response from a
2985  *              target during a probe inquiry, we remember that, and we
2986  *              avoid additional calls to scsi_probe on non-zero LUNs
2987  *              on the same target until the cache is cleared. By doing
2988  *              so we avoid the 1/4 sec selection timeout for nonzero
2989  *              LUNs. lun0 of a target is always probed.
2990  *
2991  *   Arguments: devp     - Pointer to a scsi_device(9S) structure
2992  *              waitfunc - indicates what the allocator routines should
2993  *                         do when resources are not available. This value
2994  *                         is passed on to scsi_probe() when that routine
2995  *                         is called.
2996  *
2997  * Return Code: SCSIPROBE_NORESP if a NORESP in probe response cache;
2998  *              otherwise the value returned by scsi_probe(9F).
2999  *
3000  *     Context: Kernel thread context
3001  */
3002 
3003 static int
3004 sd_scsi_probe_with_cache(struct scsi_device *devp, int (*waitfn)())
3005 {
3006         struct sd_scsi_probe_cache      *cp;
3007         dev_info_t      *pdip = ddi_get_parent(devp->sd_dev);
3008         int             lun, tgt;
3009 
3010         lun = ddi_prop_get_int(DDI_DEV_T_ANY, devp->sd_dev, DDI_PROP_DONTPASS,
3011             SCSI_ADDR_PROP_LUN, 0);
3012         tgt = ddi_prop_get_int(DDI_DEV_T_ANY, devp->sd_dev, DDI_PROP_DONTPASS,
3013             SCSI_ADDR_PROP_TARGET, -1);
3014 
3015         /* Make sure caching enabled and target in range */
3016         if ((tgt < 0) || (tgt >= NTARGETS_WIDE)) {
3017                 /* do it the old way (no cache) */
3018                 return (scsi_probe(devp, waitfn));
3019         }
3020 
3021         mutex_enter(&sd_scsi_probe_cache_mutex);
3022 
3023         /* Find the cache for this scsi bus instance */
3024         for (cp = sd_scsi_probe_cache_head; cp != NULL; cp = cp->next) {
3025                 if (cp->pdip == pdip) {
3026                         break;
3027                 }
3028         }
3029 
3030         /* If we can't find a cache for this pdip, create one */
3031         if (cp == NULL) {
3032                 int i;
3033 
3034                 cp = kmem_zalloc(sizeof (struct sd_scsi_probe_cache),
3035                     KM_SLEEP);
3036                 cp->pdip = pdip;
3037                 cp->next = sd_scsi_probe_cache_head;
3038                 sd_scsi_probe_cache_head = cp;
3039                 for (i = 0; i < NTARGETS_WIDE; i++) {
3040                         cp->cache[i] = SCSIPROBE_EXISTS;
3041                 }
3042         }
3043 
3044         mutex_exit(&sd_scsi_probe_cache_mutex);
3045 
3046         /* Recompute the cache for this target if LUN zero */
3047         if (lun == 0) {
3048                 cp->cache[tgt] = SCSIPROBE_EXISTS;
3049         }
3050 
3051         /* Don't probe if cache remembers a NORESP from a previous LUN. */
3052         if (cp->cache[tgt] != SCSIPROBE_EXISTS) {
3053                 return (SCSIPROBE_NORESP);
3054         }
3055 
3056         /* Do the actual probe; save & return the result */
3057         return (cp->cache[tgt] = scsi_probe(devp, waitfn));
3058 }
3059 
3060 
3061 /*
3062  *    Function: sd_scsi_target_lun_init
3063  *
3064  * Description: Initializes the attached lun chain mutex and head pointer.
3065  *
3066  *     Context: Kernel thread context
3067  */
3068 
3069 static void
3070 sd_scsi_target_lun_init(void)
3071 {
3072         mutex_init(&sd_scsi_target_lun_mutex, NULL, MUTEX_DRIVER, NULL);
3073         sd_scsi_target_lun_head = NULL;
3074 }
3075 
3076 
3077 /*
3078  *    Function: sd_scsi_target_lun_fini
3079  *
3080  * Description: Frees all resources associated with the attached lun
3081  *              chain
3082  *
3083  *     Context: Kernel thread context
3084  */
3085 
3086 static void
3087 sd_scsi_target_lun_fini(void)
3088 {
3089         struct sd_scsi_hba_tgt_lun      *cp;
3090         struct sd_scsi_hba_tgt_lun      *ncp;
3091 
3092         for (cp = sd_scsi_target_lun_head; cp != NULL; cp = ncp) {
3093                 ncp = cp->next;
3094                 kmem_free(cp, sizeof (struct sd_scsi_hba_tgt_lun));
3095         }
3096         sd_scsi_target_lun_head = NULL;
3097         mutex_destroy(&sd_scsi_target_lun_mutex);
3098 }
3099 
3100 
3101 /*
3102  *    Function: sd_scsi_get_target_lun_count
3103  *
3104  * Description: This routine will check in the attached lun chain to see
3105  *              how many luns are attached on the required SCSI controller
3106  *              and target. Currently, some capabilities like tagged queue
3107  *              are supported per target based by HBA. So all luns in a
3108  *              target have the same capabilities. Based on this assumption,
3109  *              sd should only set these capabilities once per target. This
3110  *              function is called when sd needs to decide how many luns
3111  *              already attached on a target.
3112  *
3113  *   Arguments: dip     - Pointer to the system's dev_info_t for the SCSI
3114  *                        controller device.
3115  *              target  - The target ID on the controller's SCSI bus.
3116  *
3117  * Return Code: The number of luns attached on the required target and
3118  *              controller.
3119  *              -1 if target ID is not in parallel SCSI scope or the given
3120  *              dip is not in the chain.
3121  *
3122  *     Context: Kernel thread context
3123  */
3124 
3125 static int
3126 sd_scsi_get_target_lun_count(dev_info_t *dip, int target)
3127 {
3128         struct sd_scsi_hba_tgt_lun      *cp;
3129 
3130         if ((target < 0) || (target >= NTARGETS_WIDE)) {
3131                 return (-1);
3132         }
3133 
3134         mutex_enter(&sd_scsi_target_lun_mutex);
3135 
3136         for (cp = sd_scsi_target_lun_head; cp != NULL; cp = cp->next) {
3137                 if (cp->pdip == dip) {
3138                         break;
3139                 }
3140         }
3141 
3142         mutex_exit(&sd_scsi_target_lun_mutex);
3143 
3144         if (cp == NULL) {
3145                 return (-1);
3146         }
3147 
3148         return (cp->nlun[target]);
3149 }
3150 
3151 
3152 /*
3153  *    Function: sd_scsi_update_lun_on_target
3154  *
3155  * Description: This routine is used to update the attached lun chain when a
3156  *              lun is attached or detached on a target.
3157  *
3158  *   Arguments: dip     - Pointer to the system's dev_info_t for the SCSI
3159  *                        controller device.
3160  *              target  - The target ID on the controller's SCSI bus.
3161  *              flag    - Indicate the lun is attached or detached.
3162  *
3163  *     Context: Kernel thread context
3164  */
3165 
3166 static void
3167 sd_scsi_update_lun_on_target(dev_info_t *dip, int target, int flag)
3168 {
3169         struct sd_scsi_hba_tgt_lun      *cp;
3170 
3171         mutex_enter(&sd_scsi_target_lun_mutex);
3172 
3173         for (cp = sd_scsi_target_lun_head; cp != NULL; cp = cp->next) {
3174                 if (cp->pdip == dip) {
3175                         break;
3176                 }
3177         }
3178 
3179         if ((cp == NULL) && (flag == SD_SCSI_LUN_ATTACH)) {
3180                 cp = kmem_zalloc(sizeof (struct sd_scsi_hba_tgt_lun),
3181                     KM_SLEEP);
3182                 cp->pdip = dip;
3183                 cp->next = sd_scsi_target_lun_head;
3184                 sd_scsi_target_lun_head = cp;
3185         }
3186 
3187         mutex_exit(&sd_scsi_target_lun_mutex);
3188 
3189         if (cp != NULL) {
3190                 if (flag == SD_SCSI_LUN_ATTACH) {
3191                         cp->nlun[target] ++;
3192                 } else {
3193                         cp->nlun[target] --;
3194                 }
3195         }
3196 }
3197 
3198 
3199 /*
3200  *    Function: sd_spin_up_unit
3201  *
3202  * Description: Issues the following commands to spin-up the device:
3203  *              START STOP UNIT, and INQUIRY.
3204  *
3205  *   Arguments: ssc   - ssc contains pointer to driver soft state (unit)
3206  *                      structure for this target.
3207  *
3208  * Return Code: 0 - success
3209  *              EIO - failure
3210  *              EACCES - reservation conflict
3211  *
3212  *     Context: Kernel thread context
3213  */
3214 
3215 static int
3216 sd_spin_up_unit(sd_ssc_t *ssc)
3217 {
3218         size_t  resid           = 0;
3219         int     has_conflict    = FALSE;
3220         uchar_t *bufaddr;
3221         int     status;
3222         struct sd_lun   *un;
3223 
3224         ASSERT(ssc != NULL);
3225         un = ssc->ssc_un;
3226         ASSERT(un != NULL);
3227 
3228         /*
3229          * Send a throwaway START UNIT command.
3230          *
3231          * If we fail on this, we don't care presently what precisely
3232          * is wrong.  EMC's arrays will also fail this with a check
3233          * condition (0x2/0x4/0x3) if the device is "inactive," but
3234          * we don't want to fail the attach because it may become
3235          * "active" later.
3236          * We don't know if power condition is supported or not at
3237          * this stage, use START STOP bit.
3238          */
3239         status = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
3240             SD_TARGET_START, SD_PATH_DIRECT);
3241 
3242         if (status != 0) {
3243                 if (status == EACCES)
3244                         has_conflict = TRUE;
3245                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3246         }
3247 
3248         /*
3249          * Send another INQUIRY command to the target. This is necessary for
3250          * non-removable media direct access devices because their INQUIRY data
3251          * may not be fully qualified until they are spun up (perhaps via the
3252          * START command above).  Note: This seems to be needed for some
3253          * legacy devices only.) The INQUIRY command should succeed even if a
3254          * Reservation Conflict is present.
3255          */
3256         bufaddr = kmem_zalloc(SUN_INQSIZE, KM_SLEEP);
3257 
3258         if (sd_send_scsi_INQUIRY(ssc, bufaddr, SUN_INQSIZE, 0, 0, &resid)
3259             != 0) {
3260                 kmem_free(bufaddr, SUN_INQSIZE);
3261                 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
3262                 return (EIO);
3263         }
3264 
3265         /*
3266          * If we got enough INQUIRY data, copy it over the old INQUIRY data.
3267          * Note that this routine does not return a failure here even if the
3268          * INQUIRY command did not return any data.  This is a legacy behavior.
3269          */
3270         if ((SUN_INQSIZE - resid) >= SUN_MIN_INQLEN) {
3271                 bcopy(bufaddr, SD_INQUIRY(un), SUN_INQSIZE);
3272         }
3273 
3274         kmem_free(bufaddr, SUN_INQSIZE);
3275 
3276         /* If we hit a reservation conflict above, tell the caller. */
3277         if (has_conflict == TRUE) {
3278                 return (EACCES);
3279         }
3280 
3281         return (0);
3282 }
3283 
3284 #ifdef _LP64
3285 /*
3286  *    Function: sd_enable_descr_sense
3287  *
3288  * Description: This routine attempts to select descriptor sense format
3289  *              using the Control mode page.  Devices that support 64 bit
3290  *              LBAs (for >2TB luns) should also implement descriptor
3291  *              sense data so we will call this function whenever we see
3292  *              a lun larger than 2TB.  If for some reason the device
3293  *              supports 64 bit LBAs but doesn't support descriptor sense
3294  *              presumably the mode select will fail.  Everything will
3295  *              continue to work normally except that we will not get
3296  *              complete sense data for commands that fail with an LBA
3297  *              larger than 32 bits.
3298  *
3299  *   Arguments: ssc   - ssc contains pointer to driver soft state (unit)
3300  *                      structure for this target.
3301  *
3302  *     Context: Kernel thread context only
3303  */
3304 
3305 static void
3306 sd_enable_descr_sense(sd_ssc_t *ssc)
3307 {
3308         uchar_t                 *header;
3309         struct mode_control_scsi3 *ctrl_bufp;
3310         size_t                  buflen;
3311         size_t                  bd_len;
3312         int                     status;
3313         struct sd_lun           *un;
3314 
3315         ASSERT(ssc != NULL);
3316         un = ssc->ssc_un;
3317         ASSERT(un != NULL);
3318 
3319         /*
3320          * Read MODE SENSE page 0xA, Control Mode Page
3321          */
3322         buflen = MODE_HEADER_LENGTH + MODE_BLK_DESC_LENGTH +
3323             sizeof (struct mode_control_scsi3);
3324         header = kmem_zalloc(buflen, KM_SLEEP);
3325 
3326         status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, header, buflen,
3327             MODEPAGE_CTRL_MODE, SD_PATH_DIRECT);
3328 
3329         if (status != 0) {
3330                 SD_ERROR(SD_LOG_COMMON, un,
3331                     "sd_enable_descr_sense: mode sense ctrl page failed\n");
3332                 goto eds_exit;
3333         }
3334 
3335         /*
3336          * Determine size of Block Descriptors in order to locate
3337          * the mode page data. ATAPI devices return 0, SCSI devices
3338          * should return MODE_BLK_DESC_LENGTH.
3339          */
3340         bd_len  = ((struct mode_header *)header)->bdesc_length;
3341 
3342         /* Clear the mode data length field for MODE SELECT */
3343         ((struct mode_header *)header)->length = 0;
3344 
3345         ctrl_bufp = (struct mode_control_scsi3 *)
3346             (header + MODE_HEADER_LENGTH + bd_len);
3347 
3348         /*
3349          * If the page length is smaller than the expected value,
3350          * the target device doesn't support D_SENSE. Bail out here.
3351          */
3352         if (ctrl_bufp->mode_page.length <
3353             sizeof (struct mode_control_scsi3) - 2) {
3354                 SD_ERROR(SD_LOG_COMMON, un,
3355                     "sd_enable_descr_sense: enable D_SENSE failed\n");
3356                 goto eds_exit;
3357         }
3358 
3359         /*
3360          * Clear PS bit for MODE SELECT
3361          */
3362         ctrl_bufp->mode_page.ps = 0;
3363 
3364         /*
3365          * Set D_SENSE to enable descriptor sense format.
3366          */
3367         ctrl_bufp->d_sense = 1;
3368 
3369         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3370 
3371         /*
3372          * Use MODE SELECT to commit the change to the D_SENSE bit
3373          */
3374         status = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, header,
3375             buflen, SD_DONTSAVE_PAGE, SD_PATH_DIRECT);
3376 
3377         if (status != 0) {
3378                 SD_INFO(SD_LOG_COMMON, un,
3379                     "sd_enable_descr_sense: mode select ctrl page failed\n");
3380         } else {
3381                 kmem_free(header, buflen);
3382                 return;
3383         }
3384 
3385 eds_exit:
3386         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3387         kmem_free(header, buflen);
3388 }
3389 
3390 /*
3391  *    Function: sd_reenable_dsense_task
3392  *
3393  * Description: Re-enable descriptor sense after device or bus reset
3394  *
3395  *     Context: Executes in a taskq() thread context
3396  */
3397 static void
3398 sd_reenable_dsense_task(void *arg)
3399 {
3400         struct  sd_lun  *un = arg;
3401         sd_ssc_t        *ssc;
3402 
3403         ASSERT(un != NULL);
3404 
3405         ssc = sd_ssc_init(un);
3406         sd_enable_descr_sense(ssc);
3407         sd_ssc_fini(ssc);
3408 }
3409 #endif /* _LP64 */
3410 
3411 /*
3412  *    Function: sd_set_mmc_caps
3413  *
3414  * Description: This routine determines if the device is MMC compliant and if
3415  *              the device supports CDDA via a mode sense of the CDVD
3416  *              capabilities mode page. Also checks if the device is a
3417  *              dvdram writable device.
3418  *
3419  *   Arguments: ssc   - ssc contains pointer to driver soft state (unit)
3420  *                      structure for this target.
3421  *
3422  *     Context: Kernel thread context only
3423  */
3424 
3425 static void
3426 sd_set_mmc_caps(sd_ssc_t *ssc)
3427 {
3428         struct mode_header_grp2         *sense_mhp;
3429         uchar_t                         *sense_page;
3430         caddr_t                         buf;
3431         int                             bd_len;
3432         int                             status;
3433         struct uscsi_cmd                com;
3434         int                             rtn;
3435         uchar_t                         *out_data_rw, *out_data_hd;
3436         uchar_t                         *rqbuf_rw, *rqbuf_hd;
3437         uchar_t                         *out_data_gesn;
3438         int                             gesn_len;
3439         struct sd_lun                   *un;
3440 
3441         ASSERT(ssc != NULL);
3442         un = ssc->ssc_un;
3443         ASSERT(un != NULL);
3444 
3445         /*
3446          * The flags which will be set in this function are - mmc compliant,
3447          * dvdram writable device, cdda support. Initialize them to FALSE
3448          * and if a capability is detected - it will be set to TRUE.
3449          */
3450         un->un_f_mmc_cap = FALSE;
3451         un->un_f_dvdram_writable_device = FALSE;
3452         un->un_f_cfg_cdda = FALSE;
3453 
3454         buf = kmem_zalloc(BUFLEN_MODE_CDROM_CAP, KM_SLEEP);
3455         status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, (uchar_t *)buf,
3456             BUFLEN_MODE_CDROM_CAP, MODEPAGE_CDROM_CAP, SD_PATH_DIRECT);
3457 
3458         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3459 
3460         if (status != 0) {
3461                 /* command failed; just return */
3462                 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3463                 return;
3464         }
3465         /*
3466          * If the mode sense request for the CDROM CAPABILITIES
3467          * page (0x2A) succeeds the device is assumed to be MMC.
3468          */
3469         un->un_f_mmc_cap = TRUE;
3470 
3471         /* See if GET STATUS EVENT NOTIFICATION is supported */
3472         if (un->un_f_mmc_gesn_polling) {
3473                 gesn_len = SD_GESN_HEADER_LEN + SD_GESN_MEDIA_DATA_LEN;
3474                 out_data_gesn = kmem_zalloc(gesn_len, KM_SLEEP);
3475 
3476                 rtn = sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION(ssc,
3477                     out_data_gesn, gesn_len, 1 << SD_GESN_MEDIA_CLASS);
3478 
3479                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3480 
3481                 if ((rtn != 0) || !sd_gesn_media_data_valid(out_data_gesn)) {
3482                         un->un_f_mmc_gesn_polling = FALSE;
3483                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
3484                             "sd_set_mmc_caps: gesn not supported "
3485                             "%d %x %x %x %x\n", rtn,
3486                             out_data_gesn[0], out_data_gesn[1],
3487                             out_data_gesn[2], out_data_gesn[3]);
3488                 }
3489 
3490                 kmem_free(out_data_gesn, gesn_len);
3491         }
3492 
3493         /* Get to the page data */
3494         sense_mhp = (struct mode_header_grp2 *)buf;
3495         bd_len = (sense_mhp->bdesc_length_hi << 8) |
3496             sense_mhp->bdesc_length_lo;
3497         if (bd_len > MODE_BLK_DESC_LENGTH) {
3498                 /*
3499                  * We did not get back the expected block descriptor
3500                  * length so we cannot determine if the device supports
3501                  * CDDA. However, we still indicate the device is MMC
3502                  * according to the successful response to the page
3503                  * 0x2A mode sense request.
3504                  */
3505                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
3506                     "sd_set_mmc_caps: Mode Sense returned "
3507                     "invalid block descriptor length\n");
3508                 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3509                 return;
3510         }
3511 
3512         /* See if read CDDA is supported */
3513         sense_page = (uchar_t *)(buf + MODE_HEADER_LENGTH_GRP2 +
3514             bd_len);
3515         un->un_f_cfg_cdda = (sense_page[5] & 0x01) ? TRUE : FALSE;
3516 
3517         /* See if writing DVD RAM is supported. */
3518         un->un_f_dvdram_writable_device = (sense_page[3] & 0x20) ? TRUE : FALSE;
3519         if (un->un_f_dvdram_writable_device == TRUE) {
3520                 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3521                 return;
3522         }
3523 
3524         /*
3525          * If the device presents DVD or CD capabilities in the mode
3526          * page, we can return here since a RRD will not have
3527          * these capabilities.
3528          */
3529         if ((sense_page[2] & 0x3f) || (sense_page[3] & 0x3f)) {
3530                 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3531                 return;
3532         }
3533         kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3534 
3535         /*
3536          * If un->un_f_dvdram_writable_device is still FALSE,
3537          * check for a Removable Rigid Disk (RRD).  A RRD
3538          * device is identified by the features RANDOM_WRITABLE and
3539          * HARDWARE_DEFECT_MANAGEMENT.
3540          */
3541         out_data_rw = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP);
3542         rqbuf_rw = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
3543 
3544         rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_rw,
3545             SENSE_LENGTH, out_data_rw, SD_CURRENT_FEATURE_LEN,
3546             RANDOM_WRITABLE, SD_PATH_STANDARD);
3547 
3548         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3549 
3550         if (rtn != 0) {
3551                 kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN);
3552                 kmem_free(rqbuf_rw, SENSE_LENGTH);
3553                 return;
3554         }
3555 
3556         out_data_hd = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP);
3557         rqbuf_hd = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
3558 
3559         rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_hd,
3560             SENSE_LENGTH, out_data_hd, SD_CURRENT_FEATURE_LEN,
3561             HARDWARE_DEFECT_MANAGEMENT, SD_PATH_STANDARD);
3562 
3563         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3564 
3565         if (rtn == 0) {
3566                 /*
3567                  * We have good information, check for random writable
3568                  * and hardware defect features.
3569                  */
3570                 if ((out_data_rw[9] & RANDOM_WRITABLE) &&
3571                     (out_data_hd[9] & HARDWARE_DEFECT_MANAGEMENT)) {
3572                         un->un_f_dvdram_writable_device = TRUE;
3573                 }
3574         }
3575 
3576         kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN);
3577         kmem_free(rqbuf_rw, SENSE_LENGTH);
3578         kmem_free(out_data_hd, SD_CURRENT_FEATURE_LEN);
3579         kmem_free(rqbuf_hd, SENSE_LENGTH);
3580 }
3581 
3582 /*
3583  *    Function: sd_check_for_writable_cd
3584  *
3585  * Description: This routine determines if the media in the device is
3586  *              writable or not. It uses the get configuration command (0x46)
3587  *              to determine if the media is writable
3588  *
3589  *   Arguments: un - driver soft state (unit) structure
3590  *              path_flag - SD_PATH_DIRECT to use the USCSI "direct"
3591  *                           chain and the normal command waitq, or
3592  *                           SD_PATH_DIRECT_PRIORITY to use the USCSI
3593  *                           "direct" chain and bypass the normal command
3594  *                           waitq.
3595  *
3596  *     Context: Never called at interrupt context.
3597  */
3598 
3599 static void
3600 sd_check_for_writable_cd(sd_ssc_t *ssc, int path_flag)
3601 {
3602         struct uscsi_cmd                com;
3603         uchar_t                         *out_data;
3604         uchar_t                         *rqbuf;
3605         int                             rtn;
3606         uchar_t                         *out_data_rw, *out_data_hd;
3607         uchar_t                         *rqbuf_rw, *rqbuf_hd;
3608         struct mode_header_grp2         *sense_mhp;
3609         uchar_t                         *sense_page;
3610         caddr_t                         buf;
3611         int                             bd_len;
3612         int                             status;
3613         struct sd_lun                   *un;
3614 
3615         ASSERT(ssc != NULL);
3616         un = ssc->ssc_un;
3617         ASSERT(un != NULL);
3618         ASSERT(mutex_owned(SD_MUTEX(un)));
3619 
3620         /*
3621          * Initialize the writable media to false, if configuration info.
3622          * tells us otherwise then only we will set it.
3623          */
3624         un->un_f_mmc_writable_media = FALSE;
3625         mutex_exit(SD_MUTEX(un));
3626 
3627         out_data = kmem_zalloc(SD_PROFILE_HEADER_LEN, KM_SLEEP);
3628         rqbuf = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
3629 
3630         rtn = sd_send_scsi_GET_CONFIGURATION(ssc, &com, rqbuf, SENSE_LENGTH,
3631             out_data, SD_PROFILE_HEADER_LEN, path_flag);
3632 
3633         if (rtn != 0)
3634                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3635 
3636         mutex_enter(SD_MUTEX(un));
3637         if (rtn == 0) {
3638                 /*
3639                  * We have good information, check for writable DVD.
3640                  */
3641                 if ((out_data[6] == 0) && (out_data[7] == 0x12)) {
3642                         un->un_f_mmc_writable_media = TRUE;
3643                         kmem_free(out_data, SD_PROFILE_HEADER_LEN);
3644                         kmem_free(rqbuf, SENSE_LENGTH);
3645                         return;
3646                 }
3647         }
3648 
3649         kmem_free(out_data, SD_PROFILE_HEADER_LEN);
3650         kmem_free(rqbuf, SENSE_LENGTH);
3651 
3652         /*
3653          * Determine if this is a RRD type device.
3654          */
3655         mutex_exit(SD_MUTEX(un));
3656         buf = kmem_zalloc(BUFLEN_MODE_CDROM_CAP, KM_SLEEP);
3657         status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, (uchar_t *)buf,
3658             BUFLEN_MODE_CDROM_CAP, MODEPAGE_CDROM_CAP, path_flag);
3659 
3660         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3661 
3662         mutex_enter(SD_MUTEX(un));
3663         if (status != 0) {
3664                 /* command failed; just return */
3665                 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3666                 return;
3667         }
3668 
3669         /* Get to the page data */
3670         sense_mhp = (struct mode_header_grp2 *)buf;
3671         bd_len = (sense_mhp->bdesc_length_hi << 8) | sense_mhp->bdesc_length_lo;
3672         if (bd_len > MODE_BLK_DESC_LENGTH) {
3673                 /*
3674                  * We did not get back the expected block descriptor length so
3675                  * we cannot check the mode page.
3676                  */
3677                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
3678                     "sd_check_for_writable_cd: Mode Sense returned "
3679                     "invalid block descriptor length\n");
3680                 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3681                 return;
3682         }
3683 
3684         /*
3685          * If the device presents DVD or CD capabilities in the mode
3686          * page, we can return here since a RRD device will not have
3687          * these capabilities.
3688          */
3689         sense_page = (uchar_t *)(buf + MODE_HEADER_LENGTH_GRP2 + bd_len);
3690         if ((sense_page[2] & 0x3f) || (sense_page[3] & 0x3f)) {
3691                 kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3692                 return;
3693         }
3694         kmem_free(buf, BUFLEN_MODE_CDROM_CAP);
3695 
3696         /*
3697          * If un->un_f_mmc_writable_media is still FALSE,
3698          * check for RRD type media.  A RRD device is identified
3699          * by the features RANDOM_WRITABLE and HARDWARE_DEFECT_MANAGEMENT.
3700          */
3701         mutex_exit(SD_MUTEX(un));
3702         out_data_rw = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP);
3703         rqbuf_rw = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
3704 
3705         rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_rw,
3706             SENSE_LENGTH, out_data_rw, SD_CURRENT_FEATURE_LEN,
3707             RANDOM_WRITABLE, path_flag);
3708 
3709         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3710         if (rtn != 0) {
3711                 kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN);
3712                 kmem_free(rqbuf_rw, SENSE_LENGTH);
3713                 mutex_enter(SD_MUTEX(un));
3714                 return;
3715         }
3716 
3717         out_data_hd = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP);
3718         rqbuf_hd = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
3719 
3720         rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_hd,
3721             SENSE_LENGTH, out_data_hd, SD_CURRENT_FEATURE_LEN,
3722             HARDWARE_DEFECT_MANAGEMENT, path_flag);
3723 
3724         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
3725         mutex_enter(SD_MUTEX(un));
3726         if (rtn == 0) {
3727                 /*
3728                  * We have good information, check for random writable
3729                  * and hardware defect features as current.
3730                  */
3731                 if ((out_data_rw[9] & RANDOM_WRITABLE) &&
3732                     (out_data_rw[10] & 0x1) &&
3733                     (out_data_hd[9] & HARDWARE_DEFECT_MANAGEMENT) &&
3734                     (out_data_hd[10] & 0x1)) {
3735                         un->un_f_mmc_writable_media = TRUE;
3736                 }
3737         }
3738 
3739         kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN);
3740         kmem_free(rqbuf_rw, SENSE_LENGTH);
3741         kmem_free(out_data_hd, SD_CURRENT_FEATURE_LEN);
3742         kmem_free(rqbuf_hd, SENSE_LENGTH);
3743 }
3744 
3745 /*
3746  *    Function: sd_read_unit_properties
3747  *
3748  * Description: The following implements a property lookup mechanism.
3749  *              Properties for particular disks (keyed on vendor, model
3750  *              and rev numbers) are sought in the sd.conf file via
3751  *              sd_process_sdconf_file(), and if not found there, are
3752  *              looked for in a list hardcoded in this driver via
3753  *              sd_process_sdconf_table() Once located the properties
3754  *              are used to update the driver unit structure.
3755  *
3756  *   Arguments: un - driver soft state (unit) structure
3757  */
3758 
3759 static void
3760 sd_read_unit_properties(struct sd_lun *un)
3761 {
3762         /*
3763          * sd_process_sdconf_file returns SD_FAILURE if it cannot find
3764          * the "sd-config-list" property (from the sd.conf file) or if
3765          * there was not a match for the inquiry vid/pid. If this event
3766          * occurs the static driver configuration table is searched for
3767          * a match.
3768          */
3769         ASSERT(un != NULL);
3770         if (sd_process_sdconf_file(un) == SD_FAILURE) {
3771                 sd_process_sdconf_table(un);
3772         }
3773 
3774         /* check for LSI device */
3775         sd_is_lsi(un);
3776 
3777 
3778 }
3779 
3780 
3781 /*
3782  *    Function: sd_process_sdconf_file
3783  *
3784  * Description: Use ddi_prop_lookup(9F) to obtain the properties from the
3785  *              driver's config file (ie, sd.conf) and update the driver
3786  *              soft state structure accordingly.
3787  *
3788  *   Arguments: un - driver soft state (unit) structure
3789  *
3790  * Return Code: SD_SUCCESS - The properties were successfully set according
3791  *                           to the driver configuration file.
3792  *              SD_FAILURE - The driver config list was not obtained or
3793  *                           there was no vid/pid match. This indicates that
3794  *                           the static config table should be used.
3795  *
3796  * The config file has a property, "sd-config-list". Currently we support
3797  * two kinds of formats. For both formats, the value of this property
3798  * is a list of duplets:
3799  *
3800  *  sd-config-list=
3801  *      <duplet>,
3802  *      [,<duplet>]*;
3803  *
3804  * For the improved format, where
3805  *
3806  *     <duplet>:= "<vid+pid>","<tunable-list>"
3807  *
3808  * and
3809  *
3810  *     <tunable-list>:=   <tunable> [, <tunable> ]*;
3811  *     <tunable> =        <name> : <value>
3812  *
3813  * The <vid+pid> is the string that is returned by the target device on a
3814  * SCSI inquiry command, the <tunable-list> contains one or more tunables
3815  * to apply to all target devices with the specified <vid+pid>.
3816  *
3817  * Each <tunable> is a "<name> : <value>" pair.
3818  *
3819  * For the old format, the structure of each duplet is as follows:
3820  *
3821  *  <duplet>:= "<vid+pid>","<data-property-name_list>"
3822  *
3823  * The first entry of the duplet is the device ID string (the concatenated
3824  * vid & pid; not to be confused with a device_id).  This is defined in
3825  * the same way as in the sd_disk_table.
3826  *
3827  * The second part of the duplet is a string that identifies a
3828  * data-property-name-list. The data-property-name-list is defined as
3829  * follows:
3830  *
3831  *  <data-property-name-list>:=<data-property-name> [<data-property-name>]
3832  *
3833  * The syntax of <data-property-name> depends on the <version> field.
3834  *
3835  * If version = SD_CONF_VERSION_1 we have the following syntax:
3836  *
3837  *      <data-property-name>:=<version>,<flags>,<prop0>,<prop1>,.....<propN>
3838  *
3839  * where the prop0 value will be used to set prop0 if bit0 set in the
3840  * flags, prop1 if bit1 set, etc. and N = SD_CONF_MAX_ITEMS -1
3841  *
3842  */
3843 
3844 static int
3845 sd_process_sdconf_file(struct sd_lun *un)
3846 {
3847         char    **config_list = NULL;
3848         uint_t  nelements;
3849         char    *vidptr;
3850         int     vidlen;
3851         char    *dnlist_ptr;
3852         char    *dataname_ptr;
3853         char    *dataname_lasts;
3854         int     *data_list = NULL;
3855         uint_t  data_list_len;
3856         int     rval = SD_FAILURE;
3857         int     i;
3858 
3859         ASSERT(un != NULL);
3860 
3861         /* Obtain the configuration list associated with the .conf file */
3862         if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, SD_DEVINFO(un),
3863             DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, sd_config_list,
3864             &config_list, &nelements) != DDI_PROP_SUCCESS) {
3865                 return (SD_FAILURE);
3866         }
3867 
3868         /*
3869          * Compare vids in each duplet to the inquiry vid - if a match is
3870          * made, get the data value and update the soft state structure
3871          * accordingly.
3872          *
3873          * Each duplet should show as a pair of strings, return SD_FAILURE
3874          * otherwise.
3875          */
3876         if (nelements & 1) {
3877                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
3878                     "sd-config-list should show as pairs of strings.\n");
3879                 if (config_list)
3880                         ddi_prop_free(config_list);
3881                 return (SD_FAILURE);
3882         }
3883 
3884         for (i = 0; i < nelements; i += 2) {
3885                 /*
3886                  * Note: The assumption here is that each vid entry is on
3887                  * a unique line from its associated duplet.
3888                  */
3889                 vidptr = config_list[i];
3890                 vidlen = (int)strlen(vidptr);
3891                 if ((vidlen == 0) ||
3892                     (sd_sdconf_id_match(un, vidptr, vidlen) != SD_SUCCESS)) {
3893                         continue;
3894                 }
3895 
3896                 /*
3897                  * dnlist contains 1 or more blank separated
3898                  * data-property-name entries
3899                  */
3900                 dnlist_ptr = config_list[i + 1];
3901 
3902                 if (strchr(dnlist_ptr, ':') != NULL) {
3903                         /*
3904                          * Decode the improved format sd-config-list.
3905                          */
3906                         sd_nvpair_str_decode(un, dnlist_ptr);
3907                 } else {
3908                         /*
3909                          * The old format sd-config-list, loop through all
3910                          * data-property-name entries in the
3911                          * data-property-name-list
3912                          * setting the properties for each.
3913                          */
3914                         for (dataname_ptr = sd_strtok_r(dnlist_ptr, " \t",
3915                             &dataname_lasts); dataname_ptr != NULL;
3916                             dataname_ptr = sd_strtok_r(NULL, " \t",
3917                             &dataname_lasts)) {
3918                                 int version;
3919 
3920                                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
3921                                     "sd_process_sdconf_file: disk:%s, "
3922                                     "data:%s\n", vidptr, dataname_ptr);
3923 
3924                                 /* Get the data list */
3925                                 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY,
3926                                     SD_DEVINFO(un), 0, dataname_ptr, &data_list,
3927                                     &data_list_len) != DDI_PROP_SUCCESS) {
3928                                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
3929                                             "sd_process_sdconf_file: data "
3930                                             "property (%s) has no value\n",
3931                                             dataname_ptr);
3932                                         continue;
3933                                 }
3934 
3935                                 version = data_list[0];
3936 
3937                                 if (version == SD_CONF_VERSION_1) {
3938                                         sd_tunables values;
3939 
3940                                         /* Set the properties */
3941                                         if (sd_chk_vers1_data(un, data_list[1],
3942                                             &data_list[2], data_list_len,
3943                                             dataname_ptr) == SD_SUCCESS) {
3944                                                 sd_get_tunables_from_conf(un,
3945                                                     data_list[1], &data_list[2],
3946                                                     &values);
3947                                                 sd_set_vers1_properties(un,
3948                                                     data_list[1], &values);
3949                                                 rval = SD_SUCCESS;
3950                                         } else {
3951                                                 rval = SD_FAILURE;
3952                                         }
3953                                 } else {
3954                                         scsi_log(SD_DEVINFO(un), sd_label,
3955                                             CE_WARN, "data property %s version "
3956                                             "0x%x is invalid.",
3957                                             dataname_ptr, version);
3958                                         rval = SD_FAILURE;
3959                                 }
3960                                 if (data_list)
3961                                         ddi_prop_free(data_list);
3962                         }
3963                 }
3964         }
3965 
3966         /* free up the memory allocated by ddi_prop_lookup_string_array(). */
3967         if (config_list) {
3968                 ddi_prop_free(config_list);
3969         }
3970 
3971         return (rval);
3972 }
3973 
3974 /*
3975  *    Function: sd_nvpair_str_decode()
3976  *
3977  * Description: Parse the improved format sd-config-list to get
3978  *    each entry of tunable, which includes a name-value pair.
3979  *    Then call sd_set_properties() to set the property.
3980  *
3981  *   Arguments: un - driver soft state (unit) structure
3982  *    nvpair_str - the tunable list
3983  */
3984 static void
3985 sd_nvpair_str_decode(struct sd_lun *un, char *nvpair_str)
3986 {
3987         char    *nv, *name, *value, *token;
3988         char    *nv_lasts, *v_lasts, *x_lasts;
3989 
3990         for (nv = sd_strtok_r(nvpair_str, ",", &nv_lasts); nv != NULL;
3991             nv = sd_strtok_r(NULL, ",", &nv_lasts)) {
3992                 token = sd_strtok_r(nv, ":", &v_lasts);
3993                 name  = sd_strtok_r(token, " \t", &x_lasts);
3994                 token = sd_strtok_r(NULL, ":", &v_lasts);
3995                 value = sd_strtok_r(token, " \t", &x_lasts);
3996                 if (name == NULL || value == NULL) {
3997                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
3998                             "sd_nvpair_str_decode: "
3999                             "name or value is not valid!\n");
4000                 } else {
4001                         sd_set_properties(un, name, value);
4002                 }
4003         }
4004 }
4005 
4006 /*
4007  *    Function: sd_strtok_r()
4008  *
4009  * Description: This function uses strpbrk and strspn to break
4010  *    string into tokens on sequentially subsequent calls. Return
4011  *    NULL when no non-separator characters remain. The first
4012  *    argument is NULL for subsequent calls.
4013  */
4014 static char *
4015 sd_strtok_r(char *string, const char *sepset, char **lasts)
4016 {
4017         char    *q, *r;
4018 
4019         /* First or subsequent call */
4020         if (string == NULL)
4021                 string = *lasts;
4022 
4023         if (string == NULL)
4024                 return (NULL);
4025 
4026         /* Skip leading separators */
4027         q = string + strspn(string, sepset);
4028 
4029         if (*q == '\0')
4030                 return (NULL);
4031 
4032         if ((r = strpbrk(q, sepset)) == NULL)
4033                 *lasts = NULL;
4034         else {
4035                 *r = '\0';
4036                 *lasts = r + 1;
4037         }
4038         return (q);
4039 }
4040 
4041 /*
4042  *    Function: sd_set_properties()
4043  *
4044  * Description: Set device properties based on the improved
4045  *    format sd-config-list.
4046  *
4047  *   Arguments: un - driver soft state (unit) structure
4048  *    name  - supported tunable name
4049  *    value - tunable value
4050  */
4051 static void
4052 sd_set_properties(struct sd_lun *un, char *name, char *value)
4053 {
4054         char    *endptr = NULL;
4055         long    val = 0;
4056 
4057         if (strcasecmp(name, "cache-nonvolatile") == 0) {
4058                 if (strcasecmp(value, "true") == 0) {
4059                         un->un_f_suppress_cache_flush = TRUE;
4060                 } else if (strcasecmp(value, "false") == 0) {
4061                         un->un_f_suppress_cache_flush = FALSE;
4062                 } else {
4063                         goto value_invalid;
4064                 }
4065                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4066                     "suppress_cache_flush flag set to %d\n",
4067                     un->un_f_suppress_cache_flush);
4068                 return;
4069         }
4070 
4071         if (strcasecmp(name, "controller-type") == 0) {
4072                 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4073                         un->un_ctype = val;
4074                 } else {
4075                         goto value_invalid;
4076                 }
4077                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4078                     "ctype set to %d\n", un->un_ctype);
4079                 return;
4080         }
4081 
4082         if (strcasecmp(name, "delay-busy") == 0) {
4083                 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4084                         un->un_busy_timeout = drv_usectohz(val / 1000);
4085                 } else {
4086                         goto value_invalid;
4087                 }
4088                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4089                     "busy_timeout set to %d\n", un->un_busy_timeout);
4090                 return;
4091         }
4092 
4093         if (strcasecmp(name, "disksort") == 0) {
4094                 if (strcasecmp(value, "true") == 0) {
4095                         un->un_f_disksort_disabled = FALSE;
4096                 } else if (strcasecmp(value, "false") == 0) {
4097                         un->un_f_disksort_disabled = TRUE;
4098                 } else {
4099                         goto value_invalid;
4100                 }
4101                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4102                     "disksort disabled flag set to %d\n",
4103                     un->un_f_disksort_disabled);
4104                 return;
4105         }
4106 
4107         if (strcasecmp(name, "power-condition") == 0) {
4108                 if (strcasecmp(value, "true") == 0) {
4109                         un->un_f_power_condition_disabled = FALSE;
4110                 } else if (strcasecmp(value, "false") == 0) {
4111                         un->un_f_power_condition_disabled = TRUE;
4112                 } else {
4113                         goto value_invalid;
4114                 }
4115                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4116                     "power condition disabled flag set to %d\n",
4117                     un->un_f_power_condition_disabled);
4118                 return;
4119         }
4120 
4121         if (strcasecmp(name, "timeout-releasereservation") == 0) {
4122                 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4123                         un->un_reserve_release_time = val;
4124                 } else {
4125                         goto value_invalid;
4126                 }
4127                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4128                     "reservation release timeout set to %d\n",
4129                     un->un_reserve_release_time);
4130                 return;
4131         }
4132 
4133         if (strcasecmp(name, "reset-lun") == 0) {
4134                 if (strcasecmp(value, "true") == 0) {
4135                         un->un_f_lun_reset_enabled = TRUE;
4136                 } else if (strcasecmp(value, "false") == 0) {
4137                         un->un_f_lun_reset_enabled = FALSE;
4138                 } else {
4139                         goto value_invalid;
4140                 }
4141                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4142                     "lun reset enabled flag set to %d\n",
4143                     un->un_f_lun_reset_enabled);
4144                 return;
4145         }
4146 
4147         if (strcasecmp(name, "retries-busy") == 0) {
4148                 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4149                         un->un_busy_retry_count = val;
4150                 } else {
4151                         goto value_invalid;
4152                 }
4153                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4154                     "busy retry count set to %d\n", un->un_busy_retry_count);
4155                 return;
4156         }
4157 
4158         if (strcasecmp(name, "retries-timeout") == 0) {
4159                 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4160                         un->un_retry_count = val;
4161                 } else {
4162                         goto value_invalid;
4163                 }
4164                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4165                     "timeout retry count set to %d\n", un->un_retry_count);
4166                 return;
4167         }
4168 
4169         if (strcasecmp(name, "retries-notready") == 0) {
4170                 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4171                         un->un_notready_retry_count = val;
4172                 } else {
4173                         goto value_invalid;
4174                 }
4175                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4176                     "notready retry count set to %d\n",
4177                     un->un_notready_retry_count);
4178                 return;
4179         }
4180 
4181         if (strcasecmp(name, "retries-reset") == 0) {
4182                 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4183                         un->un_reset_retry_count = val;
4184                 } else {
4185                         goto value_invalid;
4186                 }
4187                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4188                     "reset retry count set to %d\n",
4189                     un->un_reset_retry_count);
4190                 return;
4191         }
4192 
4193         if (strcasecmp(name, "throttle-max") == 0) {
4194                 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4195                         un->un_saved_throttle = un->un_throttle = val;
4196                 } else {
4197                         goto value_invalid;
4198                 }
4199                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4200                     "throttle set to %d\n", un->un_throttle);
4201         }
4202 
4203         if (strcasecmp(name, "throttle-min") == 0) {
4204                 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4205                         un->un_min_throttle = val;
4206                 } else {
4207                         goto value_invalid;
4208                 }
4209                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4210                     "min throttle set to %d\n", un->un_min_throttle);
4211         }
4212 
4213         if (strcasecmp(name, "rmw-type") == 0) {
4214                 if (ddi_strtol(value, &endptr, 0, &val) == 0) {
4215                         un->un_f_rmw_type = val;
4216                 } else {
4217                         goto value_invalid;
4218                 }
4219                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4220                     "RMW type set to %d\n", un->un_f_rmw_type);
4221         }
4222 
4223         if (strcasecmp(name, "physical-block-size") == 0) {
4224                 if (ddi_strtol(value, &endptr, 0, &val) == 0 &&
4225                     ISP2(val) && val >= un->un_tgt_blocksize &&
4226                     val >= un->un_sys_blocksize) {
4227                         un->un_phy_blocksize = val;
4228                 } else {
4229                         goto value_invalid;
4230                 }
4231                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4232                     "physical block size set to %d\n", un->un_phy_blocksize);
4233         }
4234 
4235         /*
4236          * Validate the throttle values.
4237          * If any of the numbers are invalid, set everything to defaults.
4238          */
4239         if ((un->un_throttle < SD_LOWEST_VALID_THROTTLE) ||
4240             (un->un_min_throttle < SD_LOWEST_VALID_THROTTLE) ||
4241             (un->un_min_throttle > un->un_throttle)) {
4242                 un->un_saved_throttle = un->un_throttle = sd_max_throttle;
4243                 un->un_min_throttle = sd_min_throttle;
4244         }
4245 
4246         if (strcasecmp(name, "mmc-gesn-polling") == 0) {
4247                 if (strcasecmp(value, "true") == 0) {
4248                         un->un_f_mmc_gesn_polling = TRUE;
4249                 } else if (strcasecmp(value, "false") == 0) {
4250                         un->un_f_mmc_gesn_polling = FALSE;
4251                 } else {
4252                         goto value_invalid;
4253                 }
4254                 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4255                     "mmc-gesn-polling set to %d\n",
4256                     un->un_f_mmc_gesn_polling);
4257         }
4258 
4259         return;
4260 
4261 value_invalid:
4262         SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: "
4263             "value of prop %s is invalid\n", name);
4264 }
4265 
4266 /*
4267  *    Function: sd_get_tunables_from_conf()
4268  *
4269  *
4270  *    This function reads the data list from the sd.conf file and pulls
4271  *    the values that can have numeric values as arguments and places
4272  *    the values in the appropriate sd_tunables member.
4273  *    Since the order of the data list members varies across platforms
4274  *    This function reads them from the data list in a platform specific
4275  *    order and places them into the correct sd_tunable member that is
4276  *    consistent across all platforms.
4277  */
4278 static void
4279 sd_get_tunables_from_conf(struct sd_lun *un, int flags, int *data_list,
4280     sd_tunables *values)
4281 {
4282         int i;
4283         int mask;
4284 
4285         bzero(values, sizeof (sd_tunables));
4286 
4287         for (i = 0; i < SD_CONF_MAX_ITEMS; i++) {
4288 
4289                 mask = 1 << i;
4290                 if (mask > flags) {
4291                         break;
4292                 }
4293 
4294                 switch (mask & flags) {
4295                 case 0: /* This mask bit not set in flags */
4296                         continue;
4297                 case SD_CONF_BSET_THROTTLE:
4298                         values->sdt_throttle = data_list[i];
4299                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4300                             "sd_get_tunables_from_conf: throttle = %d\n",
4301                             values->sdt_throttle);
4302                         break;
4303                 case SD_CONF_BSET_CTYPE:
4304                         values->sdt_ctype = data_list[i];
4305                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4306                             "sd_get_tunables_from_conf: ctype = %d\n",
4307                             values->sdt_ctype);
4308                         break;
4309                 case SD_CONF_BSET_NRR_COUNT:
4310                         values->sdt_not_rdy_retries = data_list[i];
4311                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4312                             "sd_get_tunables_from_conf: not_rdy_retries = %d\n",
4313                             values->sdt_not_rdy_retries);
4314                         break;
4315                 case SD_CONF_BSET_BSY_RETRY_COUNT:
4316                         values->sdt_busy_retries = data_list[i];
4317                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4318                             "sd_get_tunables_from_conf: busy_retries = %d\n",
4319                             values->sdt_busy_retries);
4320                         break;
4321                 case SD_CONF_BSET_RST_RETRIES:
4322                         values->sdt_reset_retries = data_list[i];
4323                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4324                             "sd_get_tunables_from_conf: reset_retries = %d\n",
4325                             values->sdt_reset_retries);
4326                         break;
4327                 case SD_CONF_BSET_RSV_REL_TIME:
4328                         values->sdt_reserv_rel_time = data_list[i];
4329                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4330                             "sd_get_tunables_from_conf: reserv_rel_time = %d\n",
4331                             values->sdt_reserv_rel_time);
4332                         break;
4333                 case SD_CONF_BSET_MIN_THROTTLE:
4334                         values->sdt_min_throttle = data_list[i];
4335                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4336                             "sd_get_tunables_from_conf: min_throttle = %d\n",
4337                             values->sdt_min_throttle);
4338                         break;
4339                 case SD_CONF_BSET_DISKSORT_DISABLED:
4340                         values->sdt_disk_sort_dis = data_list[i];
4341                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4342                             "sd_get_tunables_from_conf: disk_sort_dis = %d\n",
4343                             values->sdt_disk_sort_dis);
4344                         break;
4345                 case SD_CONF_BSET_LUN_RESET_ENABLED:
4346                         values->sdt_lun_reset_enable = data_list[i];
4347                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4348                             "sd_get_tunables_from_conf: lun_reset_enable = %d"
4349                             "\n", values->sdt_lun_reset_enable);
4350                         break;
4351                 case SD_CONF_BSET_CACHE_IS_NV:
4352                         values->sdt_suppress_cache_flush = data_list[i];
4353                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4354                             "sd_get_tunables_from_conf: \
4355                             suppress_cache_flush = %d"
4356                             "\n", values->sdt_suppress_cache_flush);
4357                         break;
4358                 case SD_CONF_BSET_PC_DISABLED:
4359                         values->sdt_disk_sort_dis = data_list[i];
4360                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4361                             "sd_get_tunables_from_conf: power_condition_dis = "
4362                             "%d\n", values->sdt_power_condition_dis);
4363                         break;
4364                 }
4365         }
4366 }
4367 
4368 /*
4369  *    Function: sd_process_sdconf_table
4370  *
4371  * Description: Search the static configuration table for a match on the
4372  *              inquiry vid/pid and update the driver soft state structure
4373  *              according to the table property values for the device.
4374  *
4375  *              The form of a configuration table entry is:
4376  *                <vid+pid>,<flags>,<property-data>
4377  *                "SEAGATE ST42400N",1,0x40000,
4378  *                0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1;
4379  *
4380  *   Arguments: un - driver soft state (unit) structure
4381  */
4382 
4383 static void
4384 sd_process_sdconf_table(struct sd_lun *un)
4385 {
4386         char    *id = NULL;
4387         int     table_index;
4388         int     idlen;
4389 
4390         ASSERT(un != NULL);
4391         for (table_index = 0; table_index < sd_disk_table_size;
4392             table_index++) {
4393                 id = sd_disk_table[table_index].device_id;
4394                 idlen = strlen(id);
4395                 if (idlen == 0) {
4396                         continue;
4397                 }
4398 
4399                 /*
4400                  * The static configuration table currently does not
4401                  * implement version 10 properties. Additionally,
4402                  * multiple data-property-name entries are not
4403                  * implemented in the static configuration table.
4404                  */
4405                 if (sd_sdconf_id_match(un, id, idlen) == SD_SUCCESS) {
4406                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4407                             "sd_process_sdconf_table: disk %s\n", id);
4408                         sd_set_vers1_properties(un,
4409                             sd_disk_table[table_index].flags,
4410                             sd_disk_table[table_index].properties);
4411                         break;
4412                 }
4413         }
4414 }
4415 
4416 
4417 /*
4418  *    Function: sd_sdconf_id_match
4419  *
4420  * Description: This local function implements a case sensitive vid/pid
4421  *              comparison as well as the boundary cases of wild card and
4422  *              multiple blanks.
4423  *
4424  *              Note: An implicit assumption made here is that the scsi
4425  *              inquiry structure will always keep the vid, pid and
4426  *              revision strings in consecutive sequence, so they can be
4427  *              read as a single string. If this assumption is not the
4428  *              case, a separate string, to be used for the check, needs
4429  *              to be built with these strings concatenated.
4430  *
4431  *   Arguments: un - driver soft state (unit) structure
4432  *              id - table or config file vid/pid
4433  *              idlen  - length of the vid/pid (bytes)
4434  *
4435  * Return Code: SD_SUCCESS - Indicates a match with the inquiry vid/pid
4436  *              SD_FAILURE - Indicates no match with the inquiry vid/pid
4437  */
4438 
4439 static int
4440 sd_sdconf_id_match(struct sd_lun *un, char *id, int idlen)
4441 {
4442         struct scsi_inquiry     *sd_inq;
4443         int                     rval = SD_SUCCESS;
4444 
4445         ASSERT(un != NULL);
4446         sd_inq = un->un_sd->sd_inq;
4447         ASSERT(id != NULL);
4448 
4449         /*
4450          * We use the inq_vid as a pointer to a buffer containing the
4451          * vid and pid and use the entire vid/pid length of the table
4452          * entry for the comparison. This works because the inq_pid
4453          * data member follows inq_vid in the scsi_inquiry structure.
4454          */
4455         if (strncasecmp(sd_inq->inq_vid, id, idlen) != 0) {
4456                 /*
4457                  * The user id string is compared to the inquiry vid/pid
4458                  * using a case insensitive comparison and ignoring
4459                  * multiple spaces.
4460                  */
4461                 rval = sd_blank_cmp(un, id, idlen);
4462                 if (rval != SD_SUCCESS) {
4463                         /*
4464                          * User id strings that start and end with a "*"
4465                          * are a special case. These do not have a
4466                          * specific vendor, and the product string can
4467                          * appear anywhere in the 16 byte PID portion of
4468                          * the inquiry data. This is a simple strstr()
4469                          * type search for the user id in the inquiry data.
4470                          */
4471                         if ((id[0] == '*') && (id[idlen - 1] == '*')) {
4472                                 char    *pidptr = &id[1];
4473                                 int     i;
4474                                 int     j;
4475                                 int     pidstrlen = idlen - 2;
4476                                 j = sizeof (SD_INQUIRY(un)->inq_pid) -
4477                                     pidstrlen;
4478 
4479                                 if (j < 0) {
4480                                         return (SD_FAILURE);
4481                                 }
4482                                 for (i = 0; i < j; i++) {
4483                                         if (bcmp(&SD_INQUIRY(un)->inq_pid[i],
4484                                             pidptr, pidstrlen) == 0) {
4485                                                 rval = SD_SUCCESS;
4486                                                 break;
4487                                         }
4488                                 }
4489                         }
4490                 }
4491         }
4492         return (rval);
4493 }
4494 
4495 
4496 /*
4497  *    Function: sd_blank_cmp
4498  *
4499  * Description: If the id string starts and ends with a space, treat
4500  *              multiple consecutive spaces as equivalent to a single
4501  *              space. For example, this causes a sd_disk_table entry
4502  *              of " NEC CDROM " to match a device's id string of
4503  *              "NEC       CDROM".
4504  *
4505  *              Note: The success exit condition for this routine is if
4506  *              the pointer to the table entry is '\0' and the cnt of
4507  *              the inquiry length is zero. This will happen if the inquiry
4508  *              string returned by the device is padded with spaces to be
4509  *              exactly 24 bytes in length (8 byte vid + 16 byte pid). The
4510  *              SCSI spec states that the inquiry string is to be padded with
4511  *              spaces.
4512  *
4513  *   Arguments: un - driver soft state (unit) structure
4514  *              id - table or config file vid/pid
4515  *              idlen  - length of the vid/pid (bytes)
4516  *
4517  * Return Code: SD_SUCCESS - Indicates a match with the inquiry vid/pid
4518  *              SD_FAILURE - Indicates no match with the inquiry vid/pid
4519  */
4520 
4521 static int
4522 sd_blank_cmp(struct sd_lun *un, char *id, int idlen)
4523 {
4524         char            *p1;
4525         char            *p2;
4526         int             cnt;
4527         cnt = sizeof (SD_INQUIRY(un)->inq_vid) +
4528             sizeof (SD_INQUIRY(un)->inq_pid);
4529 
4530         ASSERT(un != NULL);
4531         p2 = un->un_sd->sd_inq->inq_vid;
4532         ASSERT(id != NULL);
4533         p1 = id;
4534 
4535         if ((id[0] == ' ') && (id[idlen - 1] == ' ')) {
4536                 /*
4537                  * Note: string p1 is terminated by a NUL but string p2
4538                  * isn't.  The end of p2 is determined by cnt.
4539                  */
4540                 for (;;) {
4541                         /* skip over any extra blanks in both strings */
4542                         while ((*p1 != '\0') && (*p1 == ' ')) {
4543                                 p1++;
4544                         }
4545                         while ((cnt != 0) && (*p2 == ' ')) {
4546                                 p2++;
4547                                 cnt--;
4548                         }
4549 
4550                         /* compare the two strings */
4551                         if ((cnt == 0) ||
4552                             (SD_TOUPPER(*p1) != SD_TOUPPER(*p2))) {
4553                                 break;
4554                         }
4555                         while ((cnt > 0) &&
4556                             (SD_TOUPPER(*p1) == SD_TOUPPER(*p2))) {
4557                                 p1++;
4558                                 p2++;
4559                                 cnt--;
4560                         }
4561                 }
4562         }
4563 
4564         /* return SD_SUCCESS if both strings match */
4565         return (((*p1 == '\0') && (cnt == 0)) ? SD_SUCCESS : SD_FAILURE);
4566 }
4567 
4568 
4569 /*
4570  *    Function: sd_chk_vers1_data
4571  *
4572  * Description: Verify the version 1 device properties provided by the
4573  *              user via the configuration file
4574  *
4575  *   Arguments: un           - driver soft state (unit) structure
4576  *              flags        - integer mask indicating properties to be set
4577  *              prop_list    - integer list of property values
4578  *              list_len     - number of the elements
4579  *
4580  * Return Code: SD_SUCCESS - Indicates the user provided data is valid
4581  *              SD_FAILURE - Indicates the user provided data is invalid
4582  */
4583 
4584 static int
4585 sd_chk_vers1_data(struct sd_lun *un, int flags, int *prop_list,
4586     int list_len, char *dataname_ptr)
4587 {
4588         int i;
4589         int mask = 1;
4590         int index = 0;
4591 
4592         ASSERT(un != NULL);
4593 
4594         /* Check for a NULL property name and list */
4595         if (dataname_ptr == NULL) {
4596                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4597                     "sd_chk_vers1_data: NULL data property name.");
4598                 return (SD_FAILURE);
4599         }
4600         if (prop_list == NULL) {
4601                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4602                     "sd_chk_vers1_data: %s NULL data property list.",
4603                     dataname_ptr);
4604                 return (SD_FAILURE);
4605         }
4606 
4607         /* Display a warning if undefined bits are set in the flags */
4608         if (flags & ~SD_CONF_BIT_MASK) {
4609                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4610                     "sd_chk_vers1_data: invalid bits 0x%x in data list %s. "
4611                     "Properties not set.",
4612                     (flags & ~SD_CONF_BIT_MASK), dataname_ptr);
4613                 return (SD_FAILURE);
4614         }
4615 
4616         /*
4617          * Verify the length of the list by identifying the highest bit set
4618          * in the flags and validating that the property list has a length
4619          * up to the index of this bit.
4620          */
4621         for (i = 0; i < SD_CONF_MAX_ITEMS; i++) {
4622                 if (flags & mask) {
4623                         index++;
4624                 }
4625                 mask = 1 << i;
4626         }
4627         if (list_len < (index + 2)) {
4628                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4629                     "sd_chk_vers1_data: "
4630                     "Data property list %s size is incorrect. "
4631                     "Properties not set.", dataname_ptr);
4632                 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT, "Size expected: "
4633                     "version + 1 flagword + %d properties", SD_CONF_MAX_ITEMS);
4634                 return (SD_FAILURE);
4635         }
4636         return (SD_SUCCESS);
4637 }
4638 
4639 
4640 /*
4641  *    Function: sd_set_vers1_properties
4642  *
4643  * Description: Set version 1 device properties based on a property list
4644  *              retrieved from the driver configuration file or static
4645  *              configuration table. Version 1 properties have the format:
4646  *
4647  *      <data-property-name>:=<version>,<flags>,<prop0>,<prop1>,.....<propN>
4648  *
4649  *              where the prop0 value will be used to set prop0 if bit0
4650  *              is set in the flags
4651  *
4652  *   Arguments: un           - driver soft state (unit) structure
4653  *              flags        - integer mask indicating properties to be set
4654  *              prop_list    - integer list of property values
4655  */
4656 
4657 static void
4658 sd_set_vers1_properties(struct sd_lun *un, int flags, sd_tunables *prop_list)
4659 {
4660         ASSERT(un != NULL);
4661 
4662         /*
4663          * Set the flag to indicate cache is to be disabled. An attempt
4664          * to disable the cache via sd_cache_control() will be made
4665          * later during attach once the basic initialization is complete.
4666          */
4667         if (flags & SD_CONF_BSET_NOCACHE) {
4668                 un->un_f_opt_disable_cache = TRUE;
4669                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4670                     "sd_set_vers1_properties: caching disabled flag set\n");
4671         }
4672 
4673         /* CD-specific configuration parameters */
4674         if (flags & SD_CONF_BSET_PLAYMSF_BCD) {
4675                 un->un_f_cfg_playmsf_bcd = TRUE;
4676                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4677                     "sd_set_vers1_properties: playmsf_bcd set\n");
4678         }
4679         if (flags & SD_CONF_BSET_READSUB_BCD) {
4680                 un->un_f_cfg_readsub_bcd = TRUE;
4681                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4682                     "sd_set_vers1_properties: readsub_bcd set\n");
4683         }
4684         if (flags & SD_CONF_BSET_READ_TOC_TRK_BCD) {
4685                 un->un_f_cfg_read_toc_trk_bcd = TRUE;
4686                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4687                     "sd_set_vers1_properties: read_toc_trk_bcd set\n");
4688         }
4689         if (flags & SD_CONF_BSET_READ_TOC_ADDR_BCD) {
4690                 un->un_f_cfg_read_toc_addr_bcd = TRUE;
4691                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4692                     "sd_set_vers1_properties: read_toc_addr_bcd set\n");
4693         }
4694         if (flags & SD_CONF_BSET_NO_READ_HEADER) {
4695                 un->un_f_cfg_no_read_header = TRUE;
4696                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4697                     "sd_set_vers1_properties: no_read_header set\n");
4698         }
4699         if (flags & SD_CONF_BSET_READ_CD_XD4) {
4700                 un->un_f_cfg_read_cd_xd4 = TRUE;
4701                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4702                     "sd_set_vers1_properties: read_cd_xd4 set\n");
4703         }
4704 
4705         /* Support for devices which do not have valid/unique serial numbers */
4706         if (flags & SD_CONF_BSET_FAB_DEVID) {
4707                 un->un_f_opt_fab_devid = TRUE;
4708                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4709                     "sd_set_vers1_properties: fab_devid bit set\n");
4710         }
4711 
4712         /* Support for user throttle configuration */
4713         if (flags & SD_CONF_BSET_THROTTLE) {
4714                 ASSERT(prop_list != NULL);
4715                 un->un_saved_throttle = un->un_throttle =
4716                     prop_list->sdt_throttle;
4717                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4718                     "sd_set_vers1_properties: throttle set to %d\n",
4719                     prop_list->sdt_throttle);
4720         }
4721 
4722         /* Set the per disk retry count according to the conf file or table. */
4723         if (flags & SD_CONF_BSET_NRR_COUNT) {
4724                 ASSERT(prop_list != NULL);
4725                 if (prop_list->sdt_not_rdy_retries) {
4726                         un->un_notready_retry_count =
4727                             prop_list->sdt_not_rdy_retries;
4728                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4729                             "sd_set_vers1_properties: not ready retry count"
4730                             " set to %d\n", un->un_notready_retry_count);
4731                 }
4732         }
4733 
4734         /* The controller type is reported for generic disk driver ioctls */
4735         if (flags & SD_CONF_BSET_CTYPE) {
4736                 ASSERT(prop_list != NULL);
4737                 switch (prop_list->sdt_ctype) {
4738                 case CTYPE_CDROM:
4739                         un->un_ctype = prop_list->sdt_ctype;
4740                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4741                             "sd_set_vers1_properties: ctype set to "
4742                             "CTYPE_CDROM\n");
4743                         break;
4744                 case CTYPE_CCS:
4745                         un->un_ctype = prop_list->sdt_ctype;
4746                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4747                             "sd_set_vers1_properties: ctype set to "
4748                             "CTYPE_CCS\n");
4749                         break;
4750                 case CTYPE_ROD:         /* RW optical */
4751                         un->un_ctype = prop_list->sdt_ctype;
4752                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
4753                             "sd_set_vers1_properties: ctype set to "
4754                             "CTYPE_ROD\n");
4755                         break;
4756                 default:
4757                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
4758                             "sd_set_vers1_properties: Could not set "
4759                             "invalid ctype value (%d)",
4760                             prop_list->sdt_ctype);
4761                 }
4762         }
4763 
4764         /* Purple failover timeout */
4765         if (flags & SD_CONF_BSET_BSY_RETRY_COUNT) {
4766                 ASSERT(prop_list != NULL);
4767                 un->un_busy_retry_count =
4768                     prop_list->sdt_busy_retries;
4769                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4770                     "sd_set_vers1_properties: "
4771                     "busy retry count set to %d\n",
4772                     un->un_busy_retry_count);
4773         }
4774 
4775         /* Purple reset retry count */
4776         if (flags & SD_CONF_BSET_RST_RETRIES) {
4777                 ASSERT(prop_list != NULL);
4778                 un->un_reset_retry_count =
4779                     prop_list->sdt_reset_retries;
4780                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4781                     "sd_set_vers1_properties: "
4782                     "reset retry count set to %d\n",
4783                     un->un_reset_retry_count);
4784         }
4785 
4786         /* Purple reservation release timeout */
4787         if (flags & SD_CONF_BSET_RSV_REL_TIME) {
4788                 ASSERT(prop_list != NULL);
4789                 un->un_reserve_release_time =
4790                     prop_list->sdt_reserv_rel_time;
4791                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4792                     "sd_set_vers1_properties: "
4793                     "reservation release timeout set to %d\n",
4794                     un->un_reserve_release_time);
4795         }
4796 
4797         /*
4798          * Driver flag telling the driver to verify that no commands are pending
4799          * for a device before issuing a Test Unit Ready. This is a workaround
4800          * for a firmware bug in some Seagate eliteI drives.
4801          */
4802         if (flags & SD_CONF_BSET_TUR_CHECK) {
4803                 un->un_f_cfg_tur_check = TRUE;
4804                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4805                     "sd_set_vers1_properties: tur queue check set\n");
4806         }
4807 
4808         if (flags & SD_CONF_BSET_MIN_THROTTLE) {
4809                 un->un_min_throttle = prop_list->sdt_min_throttle;
4810                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4811                     "sd_set_vers1_properties: min throttle set to %d\n",
4812                     un->un_min_throttle);
4813         }
4814 
4815         if (flags & SD_CONF_BSET_DISKSORT_DISABLED) {
4816                 un->un_f_disksort_disabled =
4817                     (prop_list->sdt_disk_sort_dis != 0) ?
4818                     TRUE : FALSE;
4819                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4820                     "sd_set_vers1_properties: disksort disabled "
4821                     "flag set to %d\n",
4822                     prop_list->sdt_disk_sort_dis);
4823         }
4824 
4825         if (flags & SD_CONF_BSET_LUN_RESET_ENABLED) {
4826                 un->un_f_lun_reset_enabled =
4827                     (prop_list->sdt_lun_reset_enable != 0) ?
4828                     TRUE : FALSE;
4829                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4830                     "sd_set_vers1_properties: lun reset enabled "
4831                     "flag set to %d\n",
4832                     prop_list->sdt_lun_reset_enable);
4833         }
4834 
4835         if (flags & SD_CONF_BSET_CACHE_IS_NV) {
4836                 un->un_f_suppress_cache_flush =
4837                     (prop_list->sdt_suppress_cache_flush != 0) ?
4838                     TRUE : FALSE;
4839                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4840                     "sd_set_vers1_properties: suppress_cache_flush "
4841                     "flag set to %d\n",
4842                     prop_list->sdt_suppress_cache_flush);
4843         }
4844 
4845         if (flags & SD_CONF_BSET_PC_DISABLED) {
4846                 un->un_f_power_condition_disabled =
4847                     (prop_list->sdt_power_condition_dis != 0) ?
4848                     TRUE : FALSE;
4849                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
4850                     "sd_set_vers1_properties: power_condition_disabled "
4851                     "flag set to %d\n",
4852                     prop_list->sdt_power_condition_dis);
4853         }
4854 
4855         /*
4856          * Validate the throttle values.
4857          * If any of the numbers are invalid, set everything to defaults.
4858          */
4859         if ((un->un_throttle < SD_LOWEST_VALID_THROTTLE) ||
4860             (un->un_min_throttle < SD_LOWEST_VALID_THROTTLE) ||
4861             (un->un_min_throttle > un->un_throttle)) {
4862                 un->un_saved_throttle = un->un_throttle = sd_max_throttle;
4863                 un->un_min_throttle = sd_min_throttle;
4864         }
4865 }
4866 
4867 /*
4868  *   Function: sd_is_lsi()
4869  *
4870  *   Description: Check for lsi devices, step through the static device
4871  *      table to match vid/pid.
4872  *
4873  *   Args: un - ptr to sd_lun
4874  *
4875  *   Notes:  When creating new LSI property, need to add the new LSI property
4876  *              to this function.
4877  */
4878 static void
4879 sd_is_lsi(struct sd_lun *un)
4880 {
4881         char    *id = NULL;
4882         int     table_index;
4883         int     idlen;
4884         void    *prop;
4885 
4886         ASSERT(un != NULL);
4887         for (table_index = 0; table_index < sd_disk_table_size;
4888             table_index++) {
4889                 id = sd_disk_table[table_index].device_id;
4890                 idlen = strlen(id);
4891                 if (idlen == 0) {
4892                         continue;
4893                 }
4894 
4895                 if (sd_sdconf_id_match(un, id, idlen) == SD_SUCCESS) {
4896                         prop = sd_disk_table[table_index].properties;
4897                         if (prop == &lsi_properties ||
4898                             prop == &lsi_oem_properties ||
4899                             prop == &lsi_properties_scsi ||
4900                             prop == &symbios_properties) {
4901                                 un->un_f_cfg_is_lsi = TRUE;
4902                         }
4903                         break;
4904                 }
4905         }
4906 }
4907 
4908 /*
4909  *    Function: sd_get_physical_geometry
4910  *
4911  * Description: Retrieve the MODE SENSE page 3 (Format Device Page) and
4912  *              MODE SENSE page 4 (Rigid Disk Drive Geometry Page) from the
4913  *              target, and use this information to initialize the physical
4914  *              geometry cache specified by pgeom_p.
4915  *
4916  *              MODE SENSE is an optional command, so failure in this case
4917  *              does not necessarily denote an error. We want to use the
4918  *              MODE SENSE commands to derive the physical geometry of the
4919  *              device, but if either command fails, the logical geometry is
4920  *              used as the fallback for disk label geometry in cmlb.
4921  *
4922  *              This requires that un->un_blockcount and un->un_tgt_blocksize
4923  *              have already been initialized for the current target and
4924  *              that the current values be passed as args so that we don't
4925  *              end up ever trying to use -1 as a valid value. This could
4926  *              happen if either value is reset while we're not holding
4927  *              the mutex.
4928  *
4929  *   Arguments: un - driver soft state (unit) structure
4930  *              path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
4931  *                      the normal command waitq, or SD_PATH_DIRECT_PRIORITY
4932  *                      to use the USCSI "direct" chain and bypass the normal
4933  *                      command waitq.
4934  *
4935  *     Context: Kernel thread only (can sleep).
4936  */
4937 
4938 static int
4939 sd_get_physical_geometry(struct sd_lun *un, cmlb_geom_t *pgeom_p,
4940         diskaddr_t capacity, int lbasize, int path_flag)
4941 {
4942         struct  mode_format     *page3p;
4943         struct  mode_geometry   *page4p;
4944         struct  mode_header     *headerp;
4945         int     sector_size;
4946         int     nsect;
4947         int     nhead;
4948         int     ncyl;
4949         int     intrlv;
4950         int     spc;
4951         diskaddr_t      modesense_capacity;
4952         int     rpm;
4953         int     bd_len;
4954         int     mode_header_length;
4955         uchar_t *p3bufp;
4956         uchar_t *p4bufp;
4957         int     cdbsize;
4958         int     ret = EIO;
4959         sd_ssc_t *ssc;
4960         int     status;
4961 
4962         ASSERT(un != NULL);
4963 
4964         if (lbasize == 0) {
4965                 if (ISCD(un)) {
4966                         lbasize = 2048;
4967                 } else {
4968                         lbasize = un->un_sys_blocksize;
4969                 }
4970         }
4971         pgeom_p->g_secsize = (unsigned short)lbasize;
4972 
4973         /*
4974          * If the unit is a cd/dvd drive MODE SENSE page three
4975          * and MODE SENSE page four are reserved (see SBC spec
4976          * and MMC spec). To prevent soft errors just return
4977          * using the default LBA size.
4978          */
4979         if (ISCD(un))
4980                 return (ret);
4981 
4982         cdbsize = (un->un_f_cfg_is_atapi == TRUE) ? CDB_GROUP2 : CDB_GROUP0;
4983 
4984         /*
4985          * Retrieve MODE SENSE page 3 - Format Device Page
4986          */
4987         p3bufp = kmem_zalloc(SD_MODE_SENSE_PAGE3_LENGTH, KM_SLEEP);
4988         ssc = sd_ssc_init(un);
4989         status = sd_send_scsi_MODE_SENSE(ssc, cdbsize, p3bufp,
4990             SD_MODE_SENSE_PAGE3_LENGTH, SD_MODE_SENSE_PAGE3_CODE, path_flag);
4991         if (status != 0) {
4992                 SD_ERROR(SD_LOG_COMMON, un,
4993                     "sd_get_physical_geometry: mode sense page 3 failed\n");
4994                 goto page3_exit;
4995         }
4996 
4997         /*
4998          * Determine size of Block Descriptors in order to locate the mode
4999          * page data.  ATAPI devices return 0, SCSI devices should return
5000          * MODE_BLK_DESC_LENGTH.
5001          */
5002         headerp = (struct mode_header *)p3bufp;
5003         if (un->un_f_cfg_is_atapi == TRUE) {
5004                 struct mode_header_grp2 *mhp =
5005                     (struct mode_header_grp2 *)headerp;
5006                 mode_header_length = MODE_HEADER_LENGTH_GRP2;
5007                 bd_len = (mhp->bdesc_length_hi << 8) | mhp->bdesc_length_lo;
5008         } else {
5009                 mode_header_length = MODE_HEADER_LENGTH;
5010                 bd_len = ((struct mode_header *)headerp)->bdesc_length;
5011         }
5012 
5013         if (bd_len > MODE_BLK_DESC_LENGTH) {
5014                 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
5015                     "sd_get_physical_geometry: received unexpected bd_len "
5016                     "of %d, page3\n", bd_len);
5017                 status = EIO;
5018                 goto page3_exit;
5019         }
5020 
5021         page3p = (struct mode_format *)
5022             ((caddr_t)headerp + mode_header_length + bd_len);
5023 
5024         if (page3p->mode_page.code != SD_MODE_SENSE_PAGE3_CODE) {
5025                 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
5026                     "sd_get_physical_geometry: mode sense pg3 code mismatch "
5027                     "%d\n", page3p->mode_page.code);
5028                 status = EIO;
5029                 goto page3_exit;
5030         }
5031 
5032         /*
5033          * Use this physical geometry data only if BOTH MODE SENSE commands
5034          * complete successfully; otherwise, revert to the logical geometry.
5035          * So, we need to save everything in temporary variables.
5036          */
5037         sector_size = BE_16(page3p->data_bytes_sect);
5038 
5039         /*
5040          * 1243403: The NEC D38x7 drives do not support MODE SENSE sector size
5041          */
5042         if (sector_size == 0) {
5043                 sector_size = un->un_sys_blocksize;
5044         } else {
5045                 sector_size &= ~(un->un_sys_blocksize - 1);
5046         }
5047 
5048         nsect  = BE_16(page3p->sect_track);
5049         intrlv = BE_16(page3p->interleave);
5050 
5051         SD_INFO(SD_LOG_COMMON, un,
5052             "sd_get_physical_geometry: Format Parameters (page 3)\n");
5053         SD_INFO(SD_LOG_COMMON, un,
5054             "   mode page: %d; nsect: %d; sector size: %d;\n",
5055             page3p->mode_page.code, nsect, sector_size);
5056         SD_INFO(SD_LOG_COMMON, un,
5057             "   interleave: %d; track skew: %d; cylinder skew: %d;\n", intrlv,
5058             BE_16(page3p->track_skew),
5059             BE_16(page3p->cylinder_skew));
5060 
5061         sd_ssc_assessment(ssc, SD_FMT_STANDARD);
5062 
5063         /*
5064          * Retrieve MODE SENSE page 4 - Rigid Disk Drive Geometry Page
5065          */
5066         p4bufp = kmem_zalloc(SD_MODE_SENSE_PAGE4_LENGTH, KM_SLEEP);
5067         status = sd_send_scsi_MODE_SENSE(ssc, cdbsize, p4bufp,
5068             SD_MODE_SENSE_PAGE4_LENGTH, SD_MODE_SENSE_PAGE4_CODE, path_flag);
5069         if (status != 0) {
5070                 SD_ERROR(SD_LOG_COMMON, un,
5071                     "sd_get_physical_geometry: mode sense page 4 failed\n");
5072                 goto page4_exit;
5073         }
5074 
5075         /*
5076          * Determine size of Block Descriptors in order to locate the mode
5077          * page data.  ATAPI devices return 0, SCSI devices should return
5078          * MODE_BLK_DESC_LENGTH.
5079          */
5080         headerp = (struct mode_header *)p4bufp;
5081         if (un->un_f_cfg_is_atapi == TRUE) {
5082                 struct mode_header_grp2 *mhp =
5083                     (struct mode_header_grp2 *)headerp;
5084                 bd_len = (mhp->bdesc_length_hi << 8) | mhp->bdesc_length_lo;
5085         } else {
5086                 bd_len = ((struct mode_header *)headerp)->bdesc_length;
5087         }
5088 
5089         if (bd_len > MODE_BLK_DESC_LENGTH) {
5090                 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
5091                     "sd_get_physical_geometry: received unexpected bd_len of "
5092                     "%d, page4\n", bd_len);
5093                 status = EIO;
5094                 goto page4_exit;
5095         }
5096 
5097         page4p = (struct mode_geometry *)
5098             ((caddr_t)headerp + mode_header_length + bd_len);
5099 
5100         if (page4p->mode_page.code != SD_MODE_SENSE_PAGE4_CODE) {
5101                 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
5102                     "sd_get_physical_geometry: mode sense pg4 code mismatch "
5103                     "%d\n", page4p->mode_page.code);
5104                 status = EIO;
5105                 goto page4_exit;
5106         }
5107 
5108         /*
5109          * Stash the data now, after we know that both commands completed.
5110          */
5111 
5112 
5113         nhead = (int)page4p->heads;  /* uchar, so no conversion needed */
5114         spc   = nhead * nsect;
5115         ncyl  = (page4p->cyl_ub << 16) + (page4p->cyl_mb << 8) + page4p->cyl_lb;
5116         rpm   = BE_16(page4p->rpm);
5117 
5118         modesense_capacity = spc * ncyl;
5119 
5120         SD_INFO(SD_LOG_COMMON, un,
5121             "sd_get_physical_geometry: Geometry Parameters (page 4)\n");
5122         SD_INFO(SD_LOG_COMMON, un,
5123             "   cylinders: %d; heads: %d; rpm: %d;\n", ncyl, nhead, rpm);
5124         SD_INFO(SD_LOG_COMMON, un,
5125             "   computed capacity(h*s*c): %d;\n", modesense_capacity);
5126         SD_INFO(SD_LOG_COMMON, un, "   pgeom_p: %p; read cap: %d\n",
5127             (void *)pgeom_p, capacity);
5128 
5129         /*
5130          * Compensate if the drive's geometry is not rectangular, i.e.,
5131          * the product of C * H * S returned by MODE SENSE >= that returned
5132          * by read capacity. This is an idiosyncrasy of the original x86
5133          * disk subsystem.
5134          */
5135         if (modesense_capacity >= capacity) {
5136                 SD_INFO(SD_LOG_COMMON, un,
5137                     "sd_get_physical_geometry: adjusting acyl; "
5138                     "old: %d; new: %d\n", pgeom_p->g_acyl,
5139                     (modesense_capacity - capacity + spc - 1) / spc);
5140                 if (sector_size != 0) {
5141                         /* 1243403: NEC D38x7 drives don't support sec size */
5142                         pgeom_p->g_secsize = (unsigned short)sector_size;
5143                 }
5144                 pgeom_p->g_nsect    = (unsigned short)nsect;
5145                 pgeom_p->g_nhead    = (unsigned short)nhead;
5146                 pgeom_p->g_capacity = capacity;
5147                 pgeom_p->g_acyl          =
5148                     (modesense_capacity - pgeom_p->g_capacity + spc - 1) / spc;
5149                 pgeom_p->g_ncyl          = ncyl - pgeom_p->g_acyl;
5150         }
5151 
5152         pgeom_p->g_rpm    = (unsigned short)rpm;
5153         pgeom_p->g_intrlv = (unsigned short)intrlv;
5154         ret = 0;
5155 
5156         SD_INFO(SD_LOG_COMMON, un,
5157             "sd_get_physical_geometry: mode sense geometry:\n");
5158         SD_INFO(SD_LOG_COMMON, un,
5159             "   nsect: %d; sector size: %d; interlv: %d\n",
5160             nsect, sector_size, intrlv);
5161         SD_INFO(SD_LOG_COMMON, un,
5162             "   nhead: %d; ncyl: %d; rpm: %d; capacity(ms): %d\n",
5163             nhead, ncyl, rpm, modesense_capacity);
5164         SD_INFO(SD_LOG_COMMON, un,
5165             "sd_get_physical_geometry: (cached)\n");
5166         SD_INFO(SD_LOG_COMMON, un,
5167             "   ncyl: %ld; acyl: %d; nhead: %d; nsect: %d\n",
5168             pgeom_p->g_ncyl,  pgeom_p->g_acyl,
5169             pgeom_p->g_nhead, pgeom_p->g_nsect);
5170         SD_INFO(SD_LOG_COMMON, un,
5171             "   lbasize: %d; capacity: %ld; intrlv: %d; rpm: %d\n",
5172             pgeom_p->g_secsize, pgeom_p->g_capacity,
5173             pgeom_p->g_intrlv, pgeom_p->g_rpm);
5174         sd_ssc_assessment(ssc, SD_FMT_STANDARD);
5175 
5176 page4_exit:
5177         kmem_free(p4bufp, SD_MODE_SENSE_PAGE4_LENGTH);
5178 
5179 page3_exit:
5180         kmem_free(p3bufp, SD_MODE_SENSE_PAGE3_LENGTH);
5181 
5182         if (status != 0) {
5183                 if (status == EIO) {
5184                         /*
5185                          * Some disks do not support mode sense(6), we
5186                          * should ignore this kind of error(sense key is
5187                          * 0x5 - illegal request).
5188                          */
5189                         uint8_t *sensep;
5190                         int senlen;
5191 
5192                         sensep = (uint8_t *)ssc->ssc_uscsi_cmd->uscsi_rqbuf;
5193                         senlen = (int)(ssc->ssc_uscsi_cmd->uscsi_rqlen -
5194                             ssc->ssc_uscsi_cmd->uscsi_rqresid);
5195 
5196                         if (senlen > 0 &&
5197                             scsi_sense_key(sensep) == KEY_ILLEGAL_REQUEST) {
5198                                 sd_ssc_assessment(ssc,
5199                                     SD_FMT_IGNORE_COMPROMISE);
5200                         } else {
5201                                 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
5202                         }
5203                 } else {
5204                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5205                 }
5206         }
5207         sd_ssc_fini(ssc);
5208         return (ret);
5209 }
5210 
5211 /*
5212  *    Function: sd_get_virtual_geometry
5213  *
5214  * Description: Ask the controller to tell us about the target device.
5215  *
5216  *   Arguments: un - pointer to softstate
5217  *              capacity - disk capacity in #blocks
5218  *              lbasize - disk block size in bytes
5219  *
5220  *     Context: Kernel thread only
5221  */
5222 
5223 static int
5224 sd_get_virtual_geometry(struct sd_lun *un, cmlb_geom_t *lgeom_p,
5225     diskaddr_t capacity, int lbasize)
5226 {
5227         uint_t  geombuf;
5228         int     spc;
5229 
5230         ASSERT(un != NULL);
5231 
5232         /* Set sector size, and total number of sectors */
5233         (void) scsi_ifsetcap(SD_ADDRESS(un), "sector-size",   lbasize,  1);
5234         (void) scsi_ifsetcap(SD_ADDRESS(un), "total-sectors", capacity, 1);
5235 
5236         /* Let the HBA tell us its geometry */
5237         geombuf = (uint_t)scsi_ifgetcap(SD_ADDRESS(un), "geometry", 1);
5238 
5239         /* A value of -1 indicates an undefined "geometry" property */
5240         if (geombuf == (-1)) {
5241                 return (EINVAL);
5242         }
5243 
5244         /* Initialize the logical geometry cache. */
5245         lgeom_p->g_nhead   = (geombuf >> 16) & 0xffff;
5246         lgeom_p->g_nsect   = geombuf & 0xffff;
5247         lgeom_p->g_secsize = un->un_sys_blocksize;
5248 
5249         spc = lgeom_p->g_nhead * lgeom_p->g_nsect;
5250 
5251         /*
5252          * Note: The driver originally converted the capacity value from
5253          * target blocks to system blocks. However, the capacity value passed
5254          * to this routine is already in terms of system blocks (this scaling
5255          * is done when the READ CAPACITY command is issued and processed).
5256          * This 'error' may have gone undetected because the usage of g_ncyl
5257          * (which is based upon g_capacity) is very limited within the driver
5258          */
5259         lgeom_p->g_capacity = capacity;
5260 
5261         /*
5262          * Set ncyl to zero if the hba returned a zero nhead or nsect value. The
5263          * hba may return zero values if the device has been removed.
5264          */
5265         if (spc == 0) {
5266                 lgeom_p->g_ncyl = 0;
5267         } else {
5268                 lgeom_p->g_ncyl = lgeom_p->g_capacity / spc;
5269         }
5270         lgeom_p->g_acyl = 0;
5271 
5272         SD_INFO(SD_LOG_COMMON, un, "sd_get_virtual_geometry: (cached)\n");
5273         return (0);
5274 
5275 }
5276 /*
5277  *    Function: sd_update_block_info
5278  *
5279  * Description: Calculate a byte count to sector count bitshift value
5280  *              from sector size.
5281  *
5282  *   Arguments: un: unit struct.
5283  *              lbasize: new target sector size
5284  *              capacity: new target capacity, ie. block count
5285  *
5286  *     Context: Kernel thread context
5287  */
5288 
5289 static void
5290 sd_update_block_info(struct sd_lun *un, uint32_t lbasize, uint64_t capacity)
5291 {
5292         if (lbasize != 0) {
5293                 un->un_tgt_blocksize = lbasize;
5294                 un->un_f_tgt_blocksize_is_valid = TRUE;
5295                 if (!un->un_f_has_removable_media) {
5296                         un->un_sys_blocksize = lbasize;
5297                 }
5298         }
5299 
5300         if (capacity != 0) {
5301                 un->un_blockcount            = capacity;
5302                 un->un_f_blockcount_is_valid = TRUE;
5303 
5304                 /*
5305                  * The capacity has changed so update the errstats.
5306                  */
5307                 if (un->un_errstats != NULL) {
5308                         struct sd_errstats *stp;
5309 
5310                         capacity *= un->un_sys_blocksize;
5311                         stp = (struct sd_errstats *)un->un_errstats->ks_data;
5312                         if (stp->sd_capacity.value.ui64 < capacity)
5313                                 stp->sd_capacity.value.ui64 = capacity;
5314                 }
5315         }
5316 }
5317 
5318 
5319 /*
5320  *    Function: sd_register_devid
5321  *
5322  * Description: This routine will obtain the device id information from the
5323  *              target, obtain the serial number, and register the device
5324  *              id with the ddi framework.
5325  *
5326  *   Arguments: devi - the system's dev_info_t for the device.
5327  *              un - driver soft state (unit) structure
5328  *              reservation_flag - indicates if a reservation conflict
5329  *              occurred during attach
5330  *
5331  *     Context: Kernel Thread
5332  */
5333 static void
5334 sd_register_devid(sd_ssc_t *ssc, dev_info_t *devi, int reservation_flag)
5335 {
5336         int             rval            = 0;
5337         uchar_t         *inq80          = NULL;
5338         size_t          inq80_len       = MAX_INQUIRY_SIZE;
5339         size_t          inq80_resid     = 0;
5340         uchar_t         *inq83          = NULL;
5341         size_t          inq83_len       = MAX_INQUIRY_SIZE;
5342         size_t          inq83_resid     = 0;
5343         int             dlen, len;
5344         char            *sn;
5345         struct sd_lun   *un;
5346 
5347         ASSERT(ssc != NULL);
5348         un = ssc->ssc_un;
5349         ASSERT(un != NULL);
5350         ASSERT(mutex_owned(SD_MUTEX(un)));
5351         ASSERT((SD_DEVINFO(un)) == devi);
5352 
5353 
5354         /*
5355          * We check the availability of the World Wide Name (0x83) and Unit
5356          * Serial Number (0x80) pages in sd_check_vpd_page_support(), and using
5357          * un_vpd_page_mask from them, we decide which way to get the WWN.  If
5358          * 0x83 is available, that is the best choice.  Our next choice is
5359          * 0x80.  If neither are available, we munge the devid from the device
5360          * vid/pid/serial # for Sun qualified disks, or use the ddi framework
5361          * to fabricate a devid for non-Sun qualified disks.
5362          */
5363         if (sd_check_vpd_page_support(ssc) == 0) {
5364                 /* collect page 80 data if available */
5365                 if (un->un_vpd_page_mask & SD_VPD_UNIT_SERIAL_PG) {
5366 
5367                         mutex_exit(SD_MUTEX(un));
5368                         inq80 = kmem_zalloc(inq80_len, KM_SLEEP);
5369 
5370                         rval = sd_send_scsi_INQUIRY(ssc, inq80, inq80_len,
5371                             0x01, 0x80, &inq80_resid);
5372 
5373                         if (rval != 0) {
5374                                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5375                                 kmem_free(inq80, inq80_len);
5376                                 inq80 = NULL;
5377                                 inq80_len = 0;
5378                         } else if (ddi_prop_exists(
5379                             DDI_DEV_T_NONE, SD_DEVINFO(un),
5380                             DDI_PROP_NOTPROM | DDI_PROP_DONTPASS,
5381                             INQUIRY_SERIAL_NO) == 0) {
5382                                 /*
5383                                  * If we don't already have a serial number
5384                                  * property, do quick verify of data returned
5385                                  * and define property.
5386                                  */
5387                                 dlen = inq80_len - inq80_resid;
5388                                 len = (size_t)inq80[3];
5389                                 if ((dlen >= 4) && ((len + 4) <= dlen)) {
5390                                         /*
5391                                          * Ensure sn termination, skip leading
5392                                          * blanks, and create property
5393                                          * 'inquiry-serial-no'.
5394                                          */
5395                                         sn = (char *)&inq80[4];
5396                                         sn[len] = 0;
5397                                         while (*sn && (*sn == ' '))
5398                                                 sn++;
5399                                         if (*sn) {
5400                                                 (void) ddi_prop_update_string(
5401                                                     DDI_DEV_T_NONE,
5402                                                     SD_DEVINFO(un),
5403                                                     INQUIRY_SERIAL_NO, sn);
5404                                         }
5405                                 }
5406                         }
5407                         mutex_enter(SD_MUTEX(un));
5408                 }
5409 
5410                 /* collect page 83 data if available */
5411                 if (un->un_vpd_page_mask & SD_VPD_DEVID_WWN_PG) {
5412                         mutex_exit(SD_MUTEX(un));
5413                         inq83 = kmem_zalloc(inq83_len, KM_SLEEP);
5414 
5415                         rval = sd_send_scsi_INQUIRY(ssc, inq83, inq83_len,
5416                             0x01, 0x83, &inq83_resid);
5417 
5418                         if (rval != 0) {
5419                                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5420                                 kmem_free(inq83, inq83_len);
5421                                 inq83 = NULL;
5422                                 inq83_len = 0;
5423                         }
5424                         mutex_enter(SD_MUTEX(un));
5425                 }
5426         }
5427 
5428         /*
5429          * If transport has already registered a devid for this target
5430          * then that takes precedence over the driver's determination
5431          * of the devid.
5432          *
5433          * NOTE: The reason this check is done here instead of at the beginning
5434          * of the function is to allow the code above to create the
5435          * 'inquiry-serial-no' property.
5436          */
5437         if (ddi_devid_get(SD_DEVINFO(un), &un->un_devid) == DDI_SUCCESS) {
5438                 ASSERT(un->un_devid);
5439                 un->un_f_devid_transport_defined = TRUE;
5440                 goto cleanup; /* use devid registered by the transport */
5441         }
5442 
5443         /*
5444          * This is the case of antiquated Sun disk drives that have the
5445          * FAB_DEVID property set in the disk_table.  These drives
5446          * manage the devid's by storing them in last 2 available sectors
5447          * on the drive and have them fabricated by the ddi layer by calling
5448          * ddi_devid_init and passing the DEVID_FAB flag.
5449          */
5450         if (un->un_f_opt_fab_devid == TRUE) {
5451                 /*
5452                  * Depending on EINVAL isn't reliable, since a reserved disk
5453                  * may result in invalid geometry, so check to make sure a
5454                  * reservation conflict did not occur during attach.
5455                  */
5456                 if ((sd_get_devid(ssc) == EINVAL) &&
5457                     (reservation_flag != SD_TARGET_IS_RESERVED)) {
5458                         /*
5459                          * The devid is invalid AND there is no reservation
5460                          * conflict.  Fabricate a new devid.
5461                          */
5462                         (void) sd_create_devid(ssc);
5463                 }
5464 
5465                 /* Register the devid if it exists */
5466                 if (un->un_devid != NULL) {
5467                         (void) ddi_devid_register(SD_DEVINFO(un),
5468                             un->un_devid);
5469                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
5470                             "sd_register_devid: Devid Fabricated\n");
5471                 }
5472                 goto cleanup;
5473         }
5474 
5475         /* encode best devid possible based on data available */
5476         if (ddi_devid_scsi_encode(DEVID_SCSI_ENCODE_VERSION_LATEST,
5477             (char *)ddi_driver_name(SD_DEVINFO(un)),
5478             (uchar_t *)SD_INQUIRY(un), sizeof (*SD_INQUIRY(un)),
5479             inq80, inq80_len - inq80_resid, inq83, inq83_len -
5480             inq83_resid, &un->un_devid) == DDI_SUCCESS) {
5481 
5482                 /* devid successfully encoded, register devid */
5483                 (void) ddi_devid_register(SD_DEVINFO(un), un->un_devid);
5484 
5485         } else {
5486                 /*
5487                  * Unable to encode a devid based on data available.
5488                  * This is not a Sun qualified disk.  Older Sun disk
5489                  * drives that have the SD_FAB_DEVID property
5490                  * set in the disk_table and non Sun qualified
5491                  * disks are treated in the same manner.  These
5492                  * drives manage the devid's by storing them in
5493                  * last 2 available sectors on the drive and
5494                  * have them fabricated by the ddi layer by
5495                  * calling ddi_devid_init and passing the
5496                  * DEVID_FAB flag.
5497                  * Create a fabricate devid only if there's no
5498                  * fabricate devid existed.
5499                  */
5500                 if (sd_get_devid(ssc) == EINVAL) {
5501                         (void) sd_create_devid(ssc);
5502                 }
5503                 un->un_f_opt_fab_devid = TRUE;
5504 
5505                 /* Register the devid if it exists */
5506                 if (un->un_devid != NULL) {
5507                         (void) ddi_devid_register(SD_DEVINFO(un),
5508                             un->un_devid);
5509                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
5510                             "sd_register_devid: devid fabricated using "
5511                             "ddi framework\n");
5512                 }
5513         }
5514 
5515 cleanup:
5516         /* clean up resources */
5517         if (inq80 != NULL) {
5518                 kmem_free(inq80, inq80_len);
5519         }
5520         if (inq83 != NULL) {
5521                 kmem_free(inq83, inq83_len);
5522         }
5523 }
5524 
5525 
5526 
5527 /*
5528  *    Function: sd_get_devid
5529  *
5530  * Description: This routine will return 0 if a valid device id has been
5531  *              obtained from the target and stored in the soft state. If a
5532  *              valid device id has not been previously read and stored, a
5533  *              read attempt will be made.
5534  *
5535  *   Arguments: un - driver soft state (unit) structure
5536  *
5537  * Return Code: 0 if we successfully get the device id
5538  *
5539  *     Context: Kernel Thread
5540  */
5541 
5542 static int
5543 sd_get_devid(sd_ssc_t *ssc)
5544 {
5545         struct dk_devid         *dkdevid;
5546         ddi_devid_t             tmpid;
5547         uint_t                  *ip;
5548         size_t                  sz;
5549         diskaddr_t              blk;
5550         int                     status;
5551         int                     chksum;
5552         int                     i;
5553         size_t                  buffer_size;
5554         struct sd_lun           *un;
5555 
5556         ASSERT(ssc != NULL);
5557         un = ssc->ssc_un;
5558         ASSERT(un != NULL);
5559         ASSERT(mutex_owned(SD_MUTEX(un)));
5560 
5561         SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_get_devid: entry: un: 0x%p\n",
5562             un);
5563 
5564         if (un->un_devid != NULL) {
5565                 return (0);
5566         }
5567 
5568         mutex_exit(SD_MUTEX(un));
5569         if (cmlb_get_devid_block(un->un_cmlbhandle, &blk,
5570             (void *)SD_PATH_DIRECT) != 0) {
5571                 mutex_enter(SD_MUTEX(un));
5572                 return (EINVAL);
5573         }
5574 
5575         /*
5576          * Read and verify device id, stored in the reserved cylinders at the
5577          * end of the disk. Backup label is on the odd sectors of the last
5578          * track of the last cylinder. Device id will be on track of the next
5579          * to last cylinder.
5580          */
5581         mutex_enter(SD_MUTEX(un));
5582         buffer_size = SD_REQBYTES2TGTBYTES(un, sizeof (struct dk_devid));
5583         mutex_exit(SD_MUTEX(un));
5584         dkdevid = kmem_alloc(buffer_size, KM_SLEEP);
5585         status = sd_send_scsi_READ(ssc, dkdevid, buffer_size, blk,
5586             SD_PATH_DIRECT);
5587 
5588         if (status != 0) {
5589                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5590                 goto error;
5591         }
5592 
5593         /* Validate the revision */
5594         if ((dkdevid->dkd_rev_hi != DK_DEVID_REV_MSB) ||
5595             (dkdevid->dkd_rev_lo != DK_DEVID_REV_LSB)) {
5596                 status = EINVAL;
5597                 goto error;
5598         }
5599 
5600         /* Calculate the checksum */
5601         chksum = 0;
5602         ip = (uint_t *)dkdevid;
5603         for (i = 0; i < ((DEV_BSIZE - sizeof (int)) / sizeof (int));
5604             i++) {
5605                 chksum ^= ip[i];
5606         }
5607 
5608         /* Compare the checksums */
5609         if (DKD_GETCHKSUM(dkdevid) != chksum) {
5610                 status = EINVAL;
5611                 goto error;
5612         }
5613 
5614         /* Validate the device id */
5615         if (ddi_devid_valid((ddi_devid_t)&dkdevid->dkd_devid) != DDI_SUCCESS) {
5616                 status = EINVAL;
5617                 goto error;
5618         }
5619 
5620         /*
5621          * Store the device id in the driver soft state
5622          */
5623         sz = ddi_devid_sizeof((ddi_devid_t)&dkdevid->dkd_devid);
5624         tmpid = kmem_alloc(sz, KM_SLEEP);
5625 
5626         mutex_enter(SD_MUTEX(un));
5627 
5628         un->un_devid = tmpid;
5629         bcopy(&dkdevid->dkd_devid, un->un_devid, sz);
5630 
5631         kmem_free(dkdevid, buffer_size);
5632 
5633         SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_get_devid: exit: un:0x%p\n", un);
5634 
5635         return (status);
5636 error:
5637         mutex_enter(SD_MUTEX(un));
5638         kmem_free(dkdevid, buffer_size);
5639         return (status);
5640 }
5641 
5642 
5643 /*
5644  *    Function: sd_create_devid
5645  *
5646  * Description: This routine will fabricate the device id and write it
5647  *              to the disk.
5648  *
5649  *   Arguments: un - driver soft state (unit) structure
5650  *
5651  * Return Code: value of the fabricated device id
5652  *
5653  *     Context: Kernel Thread
5654  */
5655 
5656 static ddi_devid_t
5657 sd_create_devid(sd_ssc_t *ssc)
5658 {
5659         struct sd_lun   *un;
5660 
5661         ASSERT(ssc != NULL);
5662         un = ssc->ssc_un;
5663         ASSERT(un != NULL);
5664 
5665         /* Fabricate the devid */
5666         if (ddi_devid_init(SD_DEVINFO(un), DEVID_FAB, 0, NULL, &un->un_devid)
5667             == DDI_FAILURE) {
5668                 return (NULL);
5669         }
5670 
5671         /* Write the devid to disk */
5672         if (sd_write_deviceid(ssc) != 0) {
5673                 ddi_devid_free(un->un_devid);
5674                 un->un_devid = NULL;
5675         }
5676 
5677         return (un->un_devid);
5678 }
5679 
5680 
5681 /*
5682  *    Function: sd_write_deviceid
5683  *
5684  * Description: This routine will write the device id to the disk
5685  *              reserved sector.
5686  *
5687  *   Arguments: un - driver soft state (unit) structure
5688  *
5689  * Return Code: EINVAL
5690  *              value returned by sd_send_scsi_cmd
5691  *
5692  *     Context: Kernel Thread
5693  */
5694 
5695 static int
5696 sd_write_deviceid(sd_ssc_t *ssc)
5697 {
5698         struct dk_devid         *dkdevid;
5699         uchar_t                 *buf;
5700         diskaddr_t              blk;
5701         uint_t                  *ip, chksum;
5702         int                     status;
5703         int                     i;
5704         struct sd_lun           *un;
5705 
5706         ASSERT(ssc != NULL);
5707         un = ssc->ssc_un;
5708         ASSERT(un != NULL);
5709         ASSERT(mutex_owned(SD_MUTEX(un)));
5710 
5711         mutex_exit(SD_MUTEX(un));
5712         if (cmlb_get_devid_block(un->un_cmlbhandle, &blk,
5713             (void *)SD_PATH_DIRECT) != 0) {
5714                 mutex_enter(SD_MUTEX(un));
5715                 return (-1);
5716         }
5717 
5718 
5719         /* Allocate the buffer */
5720         buf = kmem_zalloc(un->un_sys_blocksize, KM_SLEEP);
5721         dkdevid = (struct dk_devid *)buf;
5722 
5723         /* Fill in the revision */
5724         dkdevid->dkd_rev_hi = DK_DEVID_REV_MSB;
5725         dkdevid->dkd_rev_lo = DK_DEVID_REV_LSB;
5726 
5727         /* Copy in the device id */
5728         mutex_enter(SD_MUTEX(un));
5729         bcopy(un->un_devid, &dkdevid->dkd_devid,
5730             ddi_devid_sizeof(un->un_devid));
5731         mutex_exit(SD_MUTEX(un));
5732 
5733         /* Calculate the checksum */
5734         chksum = 0;
5735         ip = (uint_t *)dkdevid;
5736         for (i = 0; i < ((DEV_BSIZE - sizeof (int)) / sizeof (int));
5737             i++) {
5738                 chksum ^= ip[i];
5739         }
5740 
5741         /* Fill-in checksum */
5742         DKD_FORMCHKSUM(chksum, dkdevid);
5743 
5744         /* Write the reserved sector */
5745         status = sd_send_scsi_WRITE(ssc, buf, un->un_sys_blocksize, blk,
5746             SD_PATH_DIRECT);
5747         if (status != 0)
5748                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5749 
5750         kmem_free(buf, un->un_sys_blocksize);
5751 
5752         mutex_enter(SD_MUTEX(un));
5753         return (status);
5754 }
5755 
5756 
5757 /*
5758  *    Function: sd_check_vpd_page_support
5759  *
5760  * Description: This routine sends an inquiry command with the EVPD bit set and
5761  *              a page code of 0x00 to the device. It is used to determine which
5762  *              vital product pages are available to find the devid. We are
5763  *              looking for pages 0x83 0x80 or 0xB1.  If we return a negative 1,
5764  *              the device does not support that command.
5765  *
5766  *   Arguments: un  - driver soft state (unit) structure
5767  *
5768  * Return Code: 0 - success
5769  *              1 - check condition
5770  *
5771  *     Context: This routine can sleep.
5772  */
5773 
5774 static int
5775 sd_check_vpd_page_support(sd_ssc_t *ssc)
5776 {
5777         uchar_t *page_list      = NULL;
5778         uchar_t page_length     = 0xff; /* Use max possible length */
5779         uchar_t evpd            = 0x01; /* Set the EVPD bit */
5780         uchar_t page_code       = 0x00; /* Supported VPD Pages */
5781         int     rval            = 0;
5782         int     counter;
5783         struct sd_lun           *un;
5784 
5785         ASSERT(ssc != NULL);
5786         un = ssc->ssc_un;
5787         ASSERT(un != NULL);
5788         ASSERT(mutex_owned(SD_MUTEX(un)));
5789 
5790         mutex_exit(SD_MUTEX(un));
5791 
5792         /*
5793          * We'll set the page length to the maximum to save figuring it out
5794          * with an additional call.
5795          */
5796         page_list =  kmem_zalloc(page_length, KM_SLEEP);
5797 
5798         rval = sd_send_scsi_INQUIRY(ssc, page_list, page_length, evpd,
5799             page_code, NULL);
5800 
5801         if (rval != 0)
5802                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5803 
5804         mutex_enter(SD_MUTEX(un));
5805 
5806         /*
5807          * Now we must validate that the device accepted the command, as some
5808          * drives do not support it.  If the drive does support it, we will
5809          * return 0, and the supported pages will be in un_vpd_page_mask.  If
5810          * not, we return -1.
5811          */
5812         if ((rval == 0) && (page_list[VPD_MODE_PAGE] == 0x00)) {
5813                 /* Loop to find one of the 2 pages we need */
5814                 counter = 4;  /* Supported pages start at byte 4, with 0x00 */
5815 
5816                 /*
5817                  * Pages are returned in ascending order, and 0x83 is what we
5818                  * are hoping for.
5819                  */
5820                 while ((page_list[counter] <= 0xB1) &&
5821                     (counter <= (page_list[VPD_PAGE_LENGTH] +
5822                     VPD_HEAD_OFFSET))) {
5823                         /*
5824                          * Add 3 because page_list[3] is the number of
5825                          * pages minus 3
5826                          */
5827 
5828                         switch (page_list[counter]) {
5829                         case 0x00:
5830                                 un->un_vpd_page_mask |= SD_VPD_SUPPORTED_PG;
5831                                 break;
5832                         case 0x80:
5833                                 un->un_vpd_page_mask |= SD_VPD_UNIT_SERIAL_PG;
5834                                 break;
5835                         case 0x81:
5836                                 un->un_vpd_page_mask |= SD_VPD_OPERATING_PG;
5837                                 break;
5838                         case 0x82:
5839                                 un->un_vpd_page_mask |= SD_VPD_ASCII_OP_PG;
5840                                 break;
5841                         case 0x83:
5842                                 un->un_vpd_page_mask |= SD_VPD_DEVID_WWN_PG;
5843                                 break;
5844                         case 0x86:
5845                                 un->un_vpd_page_mask |= SD_VPD_EXTENDED_DATA_PG;
5846                                 break;
5847                         case 0xB1:
5848                                 un->un_vpd_page_mask |= SD_VPD_DEV_CHARACTER_PG;
5849                                 break;
5850                         }
5851                         counter++;
5852                 }
5853 
5854         } else {
5855                 rval = -1;
5856 
5857                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
5858                     "sd_check_vpd_page_support: This drive does not implement "
5859                     "VPD pages.\n");
5860         }
5861 
5862         kmem_free(page_list, page_length);
5863 
5864         return (rval);
5865 }
5866 
5867 
5868 /*
5869  *    Function: sd_setup_pm
5870  *
5871  * Description: Initialize Power Management on the device
5872  *
5873  *     Context: Kernel Thread
5874  */
5875 
5876 static void
5877 sd_setup_pm(sd_ssc_t *ssc, dev_info_t *devi)
5878 {
5879         uint_t          log_page_size;
5880         uchar_t         *log_page_data;
5881         int             rval = 0;
5882         struct sd_lun   *un;
5883 
5884         ASSERT(ssc != NULL);
5885         un = ssc->ssc_un;
5886         ASSERT(un != NULL);
5887 
5888         /*
5889          * Since we are called from attach, holding a mutex for
5890          * un is unnecessary. Because some of the routines called
5891          * from here require SD_MUTEX to not be held, assert this
5892          * right up front.
5893          */
5894         ASSERT(!mutex_owned(SD_MUTEX(un)));
5895         /*
5896          * Since the sd device does not have the 'reg' property,
5897          * cpr will not call its DDI_SUSPEND/DDI_RESUME entries.
5898          * The following code is to tell cpr that this device
5899          * DOES need to be suspended and resumed.
5900          */
5901         (void) ddi_prop_update_string(DDI_DEV_T_NONE, devi,
5902             "pm-hardware-state", "needs-suspend-resume");
5903 
5904         /*
5905          * This complies with the new power management framework
5906          * for certain desktop machines. Create the pm_components
5907          * property as a string array property.
5908          * If un_f_pm_supported is TRUE, that means the disk
5909          * attached HBA has set the "pm-capable" property and
5910          * the value of this property is bigger than 0.
5911          */
5912         if (un->un_f_pm_supported) {
5913                 /*
5914                  * not all devices have a motor, try it first.
5915                  * some devices may return ILLEGAL REQUEST, some
5916                  * will hang
5917                  * The following START_STOP_UNIT is used to check if target
5918                  * device has a motor.
5919                  */
5920                 un->un_f_start_stop_supported = TRUE;
5921 
5922                 if (un->un_f_power_condition_supported) {
5923                         rval = sd_send_scsi_START_STOP_UNIT(ssc,
5924                             SD_POWER_CONDITION, SD_TARGET_ACTIVE,
5925                             SD_PATH_DIRECT);
5926                         if (rval != 0) {
5927                                 un->un_f_power_condition_supported = FALSE;
5928                         }
5929                 }
5930                 if (!un->un_f_power_condition_supported) {
5931                         rval = sd_send_scsi_START_STOP_UNIT(ssc,
5932                             SD_START_STOP, SD_TARGET_START, SD_PATH_DIRECT);
5933                 }
5934                 if (rval != 0) {
5935                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
5936                         un->un_f_start_stop_supported = FALSE;
5937                 }
5938 
5939                 /*
5940                  * create pm properties anyways otherwise the parent can't
5941                  * go to sleep
5942                  */
5943                 un->un_f_pm_is_enabled = TRUE;
5944                 (void) sd_create_pm_components(devi, un);
5945 
5946                 /*
5947                  * If it claims that log sense is supported, check it out.
5948                  */
5949                 if (un->un_f_log_sense_supported) {
5950                         rval = sd_log_page_supported(ssc,
5951                             START_STOP_CYCLE_PAGE);
5952                         if (rval == 1) {
5953                                 /* Page found, use it. */
5954                                 un->un_start_stop_cycle_page =
5955                                     START_STOP_CYCLE_PAGE;
5956                         } else {
5957                                 /*
5958                                  * Page not found or log sense is not
5959                                  * supported.
5960                                  * Notice we do not check the old style
5961                                  * START_STOP_CYCLE_VU_PAGE because this
5962                                  * code path does not apply to old disks.
5963                                  */
5964                                 un->un_f_log_sense_supported = FALSE;
5965                                 un->un_f_pm_log_sense_smart = FALSE;
5966                         }
5967                 }
5968 
5969                 return;
5970         }
5971 
5972         /*
5973          * For the disk whose attached HBA has not set the "pm-capable"
5974          * property, check if it supports the power management.
5975          */
5976         if (!un->un_f_log_sense_supported) {
5977                 un->un_power_level = SD_SPINDLE_ON;
5978                 un->un_f_pm_is_enabled = FALSE;
5979                 return;
5980         }
5981 
5982         rval = sd_log_page_supported(ssc, START_STOP_CYCLE_PAGE);
5983 
5984 #ifdef  SDDEBUG
5985         if (sd_force_pm_supported) {
5986                 /* Force a successful result */
5987                 rval = 1;
5988         }
5989 #endif
5990 
5991         /*
5992          * If the start-stop cycle counter log page is not supported
5993          * or if the pm-capable property is set to be false (0),
5994          * then we should not create the pm_components property.
5995          */
5996         if (rval == -1) {
5997                 /*
5998                  * Error.
5999                  * Reading log sense failed, most likely this is
6000                  * an older drive that does not support log sense.
6001                  * If this fails auto-pm is not supported.
6002                  */
6003                 un->un_power_level = SD_SPINDLE_ON;
6004                 un->un_f_pm_is_enabled = FALSE;
6005 
6006         } else if (rval == 0) {
6007                 /*
6008                  * Page not found.
6009                  * The start stop cycle counter is implemented as page
6010                  * START_STOP_CYCLE_PAGE_VU_PAGE (0x31) in older disks. For
6011                  * newer disks it is implemented as START_STOP_CYCLE_PAGE (0xE).
6012                  */
6013                 if (sd_log_page_supported(ssc, START_STOP_CYCLE_VU_PAGE) == 1) {
6014                         /*
6015                          * Page found, use this one.
6016                          */
6017                         un->un_start_stop_cycle_page = START_STOP_CYCLE_VU_PAGE;
6018                         un->un_f_pm_is_enabled = TRUE;
6019                 } else {
6020                         /*
6021                          * Error or page not found.
6022                          * auto-pm is not supported for this device.
6023                          */
6024                         un->un_power_level = SD_SPINDLE_ON;
6025                         un->un_f_pm_is_enabled = FALSE;
6026                 }
6027         } else {
6028                 /*
6029                  * Page found, use it.
6030                  */
6031                 un->un_start_stop_cycle_page = START_STOP_CYCLE_PAGE;
6032                 un->un_f_pm_is_enabled = TRUE;
6033         }
6034 
6035 
6036         if (un->un_f_pm_is_enabled == TRUE) {
6037                 log_page_size = START_STOP_CYCLE_COUNTER_PAGE_SIZE;
6038                 log_page_data = kmem_zalloc(log_page_size, KM_SLEEP);
6039 
6040                 rval = sd_send_scsi_LOG_SENSE(ssc, log_page_data,
6041                     log_page_size, un->un_start_stop_cycle_page,
6042                     0x01, 0, SD_PATH_DIRECT);
6043 
6044                 if (rval != 0) {
6045                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
6046                 }
6047 
6048 #ifdef  SDDEBUG
6049                 if (sd_force_pm_supported) {
6050                         /* Force a successful result */
6051                         rval = 0;
6052                 }
6053 #endif
6054 
6055                 /*
6056                  * If the Log sense for Page( Start/stop cycle counter page)
6057                  * succeeds, then power management is supported and we can
6058                  * enable auto-pm.
6059                  */
6060                 if (rval == 0)  {
6061                         (void) sd_create_pm_components(devi, un);
6062                 } else {
6063                         un->un_power_level = SD_SPINDLE_ON;
6064                         un->un_f_pm_is_enabled = FALSE;
6065                 }
6066 
6067                 kmem_free(log_page_data, log_page_size);
6068         }
6069 }
6070 
6071 
6072 /*
6073  *    Function: sd_create_pm_components
6074  *
6075  * Description: Initialize PM property.
6076  *
6077  *     Context: Kernel thread context
6078  */
6079 
6080 static void
6081 sd_create_pm_components(dev_info_t *devi, struct sd_lun *un)
6082 {
6083         ASSERT(!mutex_owned(SD_MUTEX(un)));
6084 
6085         if (un->un_f_power_condition_supported) {
6086                 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, devi,
6087                     "pm-components", sd_pwr_pc.pm_comp, 5)
6088                     != DDI_PROP_SUCCESS) {
6089                         un->un_power_level = SD_SPINDLE_ACTIVE;
6090                         un->un_f_pm_is_enabled = FALSE;
6091                         return;
6092                 }
6093         } else {
6094                 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, devi,
6095                     "pm-components", sd_pwr_ss.pm_comp, 3)
6096                     != DDI_PROP_SUCCESS) {
6097                         un->un_power_level = SD_SPINDLE_ON;
6098                         un->un_f_pm_is_enabled = FALSE;
6099                         return;
6100                 }
6101         }
6102         /*
6103          * When components are initially created they are idle,
6104          * power up any non-removables.
6105          * Note: the return value of pm_raise_power can't be used
6106          * for determining if PM should be enabled for this device.
6107          * Even if you check the return values and remove this
6108          * property created above, the PM framework will not honor the
6109          * change after the first call to pm_raise_power. Hence,
6110          * removal of that property does not help if pm_raise_power
6111          * fails. In the case of removable media, the start/stop
6112          * will fail if the media is not present.
6113          */
6114         if (un->un_f_attach_spinup && (pm_raise_power(SD_DEVINFO(un), 0,
6115             SD_PM_STATE_ACTIVE(un)) == DDI_SUCCESS)) {
6116                 mutex_enter(SD_MUTEX(un));
6117                 un->un_power_level = SD_PM_STATE_ACTIVE(un);
6118                 mutex_enter(&un->un_pm_mutex);
6119                 /* Set to on and not busy. */
6120                 un->un_pm_count = 0;
6121         } else {
6122                 mutex_enter(SD_MUTEX(un));
6123                 un->un_power_level = SD_PM_STATE_STOPPED(un);
6124                 mutex_enter(&un->un_pm_mutex);
6125                 /* Set to off. */
6126                 un->un_pm_count = -1;
6127         }
6128         mutex_exit(&un->un_pm_mutex);
6129         mutex_exit(SD_MUTEX(un));
6130 }
6131 
6132 
6133 /*
6134  *    Function: sd_ddi_suspend
6135  *
6136  * Description: Performs system power-down operations. This includes
6137  *              setting the drive state to indicate its suspended so
6138  *              that no new commands will be accepted. Also, wait for
6139  *              all commands that are in transport or queued to a timer
6140  *              for retry to complete. All timeout threads are cancelled.
6141  *
6142  * Return Code: DDI_FAILURE or DDI_SUCCESS
6143  *
6144  *     Context: Kernel thread context
6145  */
6146 
6147 static int
6148 sd_ddi_suspend(dev_info_t *devi)
6149 {
6150         struct  sd_lun  *un;
6151         clock_t         wait_cmds_complete;
6152 
6153         un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
6154         if (un == NULL) {
6155                 return (DDI_FAILURE);
6156         }
6157 
6158         SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: entry\n");
6159 
6160         mutex_enter(SD_MUTEX(un));
6161 
6162         /* Return success if the device is already suspended. */
6163         if (un->un_state == SD_STATE_SUSPENDED) {
6164                 mutex_exit(SD_MUTEX(un));
6165                 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: "
6166                     "device already suspended, exiting\n");
6167                 return (DDI_SUCCESS);
6168         }
6169 
6170         /* Return failure if the device is being used by HA */
6171         if (un->un_resvd_status &
6172             (SD_RESERVE | SD_WANT_RESERVE | SD_LOST_RESERVE)) {
6173                 mutex_exit(SD_MUTEX(un));
6174                 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: "
6175                     "device in use by HA, exiting\n");
6176                 return (DDI_FAILURE);
6177         }
6178 
6179         /*
6180          * Return failure if the device is in a resource wait
6181          * or power changing state.
6182          */
6183         if ((un->un_state == SD_STATE_RWAIT) ||
6184             (un->un_state == SD_STATE_PM_CHANGING)) {
6185                 mutex_exit(SD_MUTEX(un));
6186                 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: "
6187                     "device in resource wait state, exiting\n");
6188                 return (DDI_FAILURE);
6189         }
6190 
6191 
6192         un->un_save_state = un->un_last_state;
6193         New_state(un, SD_STATE_SUSPENDED);
6194 
6195         /*
6196          * Wait for all commands that are in transport or queued to a timer
6197          * for retry to complete.
6198          *
6199          * While waiting, no new commands will be accepted or sent because of
6200          * the new state we set above.
6201          *
6202          * Wait till current operation has completed. If we are in the resource
6203          * wait state (with an intr outstanding) then we need to wait till the
6204          * intr completes and starts the next cmd. We want to wait for
6205          * SD_WAIT_CMDS_COMPLETE seconds before failing the DDI_SUSPEND.
6206          */
6207         wait_cmds_complete = ddi_get_lbolt() +
6208             (sd_wait_cmds_complete * drv_usectohz(1000000));
6209 
6210         while (un->un_ncmds_in_transport != 0) {
6211                 /*
6212                  * Fail if commands do not finish in the specified time.
6213                  */
6214                 if (cv_timedwait(&un->un_disk_busy_cv, SD_MUTEX(un),
6215                     wait_cmds_complete) == -1) {
6216                         /*
6217                          * Undo the state changes made above. Everything
6218                          * must go back to it's original value.
6219                          */
6220                         Restore_state(un);
6221                         un->un_last_state = un->un_save_state;
6222                         /* Wake up any threads that might be waiting. */
6223                         cv_broadcast(&un->un_suspend_cv);
6224                         mutex_exit(SD_MUTEX(un));
6225                         SD_ERROR(SD_LOG_IO_PM, un,
6226                             "sd_ddi_suspend: failed due to outstanding cmds\n");
6227                         SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: exiting\n");
6228                         return (DDI_FAILURE);
6229                 }
6230         }
6231 
6232         /*
6233          * Cancel SCSI watch thread and timeouts, if any are active
6234          */
6235 
6236         if (SD_OK_TO_SUSPEND_SCSI_WATCHER(un)) {
6237                 opaque_t temp_token = un->un_swr_token;
6238                 mutex_exit(SD_MUTEX(un));
6239                 scsi_watch_suspend(temp_token);
6240                 mutex_enter(SD_MUTEX(un));
6241         }
6242 
6243         if (un->un_reset_throttle_timeid != NULL) {
6244                 timeout_id_t temp_id = un->un_reset_throttle_timeid;
6245                 un->un_reset_throttle_timeid = NULL;
6246                 mutex_exit(SD_MUTEX(un));
6247                 (void) untimeout(temp_id);
6248                 mutex_enter(SD_MUTEX(un));
6249         }
6250 
6251         if (un->un_dcvb_timeid != NULL) {
6252                 timeout_id_t temp_id = un->un_dcvb_timeid;
6253                 un->un_dcvb_timeid = NULL;
6254                 mutex_exit(SD_MUTEX(un));
6255                 (void) untimeout(temp_id);
6256                 mutex_enter(SD_MUTEX(un));
6257         }
6258 
6259         mutex_enter(&un->un_pm_mutex);
6260         if (un->un_pm_timeid != NULL) {
6261                 timeout_id_t temp_id = un->un_pm_timeid;
6262                 un->un_pm_timeid = NULL;
6263                 mutex_exit(&un->un_pm_mutex);
6264                 mutex_exit(SD_MUTEX(un));
6265                 (void) untimeout(temp_id);
6266                 mutex_enter(SD_MUTEX(un));
6267         } else {
6268                 mutex_exit(&un->un_pm_mutex);
6269         }
6270 
6271         if (un->un_rmw_msg_timeid != NULL) {
6272                 timeout_id_t temp_id = un->un_rmw_msg_timeid;
6273                 un->un_rmw_msg_timeid = NULL;
6274                 mutex_exit(SD_MUTEX(un));
6275                 (void) untimeout(temp_id);
6276                 mutex_enter(SD_MUTEX(un));
6277         }
6278 
6279         if (un->un_retry_timeid != NULL) {
6280                 timeout_id_t temp_id = un->un_retry_timeid;
6281                 un->un_retry_timeid = NULL;
6282                 mutex_exit(SD_MUTEX(un));
6283                 (void) untimeout(temp_id);
6284                 mutex_enter(SD_MUTEX(un));
6285 
6286                 if (un->un_retry_bp != NULL) {
6287                         un->un_retry_bp->av_forw = un->un_waitq_headp;
6288                         un->un_waitq_headp = un->un_retry_bp;
6289                         if (un->un_waitq_tailp == NULL) {
6290                                 un->un_waitq_tailp = un->un_retry_bp;
6291                         }
6292                         un->un_retry_bp = NULL;
6293                         un->un_retry_statp = NULL;
6294                 }
6295         }
6296 
6297         if (un->un_direct_priority_timeid != NULL) {
6298                 timeout_id_t temp_id = un->un_direct_priority_timeid;
6299                 un->un_direct_priority_timeid = NULL;
6300                 mutex_exit(SD_MUTEX(un));
6301                 (void) untimeout(temp_id);
6302                 mutex_enter(SD_MUTEX(un));
6303         }
6304 
6305         if (un->un_f_is_fibre == TRUE) {
6306                 /*
6307                  * Remove callbacks for insert and remove events
6308                  */
6309                 if (un->un_insert_event != NULL) {
6310                         mutex_exit(SD_MUTEX(un));
6311                         (void) ddi_remove_event_handler(un->un_insert_cb_id);
6312                         mutex_enter(SD_MUTEX(un));
6313                         un->un_insert_event = NULL;
6314                 }
6315 
6316                 if (un->un_remove_event != NULL) {
6317                         mutex_exit(SD_MUTEX(un));
6318                         (void) ddi_remove_event_handler(un->un_remove_cb_id);
6319                         mutex_enter(SD_MUTEX(un));
6320                         un->un_remove_event = NULL;
6321                 }
6322         }
6323 
6324         mutex_exit(SD_MUTEX(un));
6325 
6326         SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: exit\n");
6327 
6328         return (DDI_SUCCESS);
6329 }
6330 
6331 
6332 /*
6333  *    Function: sd_ddi_resume
6334  *
6335  * Description: Performs system power-up operations..
6336  *
6337  * Return Code: DDI_SUCCESS
6338  *              DDI_FAILURE
6339  *
6340  *     Context: Kernel thread context
6341  */
6342 
6343 static int
6344 sd_ddi_resume(dev_info_t *devi)
6345 {
6346         struct  sd_lun  *un;
6347 
6348         un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
6349         if (un == NULL) {
6350                 return (DDI_FAILURE);
6351         }
6352 
6353         SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_resume: entry\n");
6354 
6355         mutex_enter(SD_MUTEX(un));
6356         Restore_state(un);
6357 
6358         /*
6359          * Restore the state which was saved to give the
6360          * the right state in un_last_state
6361          */
6362         un->un_last_state = un->un_save_state;
6363         /*
6364          * Note: throttle comes back at full.
6365          * Also note: this MUST be done before calling pm_raise_power
6366          * otherwise the system can get hung in biowait. The scenario where
6367          * this'll happen is under cpr suspend. Writing of the system
6368          * state goes through sddump, which writes 0 to un_throttle. If
6369          * writing the system state then fails, example if the partition is
6370          * too small, then cpr attempts a resume. If throttle isn't restored
6371          * from the saved value until after calling pm_raise_power then
6372          * cmds sent in sdpower are not transported and sd_send_scsi_cmd hangs
6373          * in biowait.
6374          */
6375         un->un_throttle = un->un_saved_throttle;
6376 
6377         /*
6378          * The chance of failure is very rare as the only command done in power
6379          * entry point is START command when you transition from 0->1 or
6380          * unknown->1. Put it to SPINDLE ON state irrespective of the state at
6381          * which suspend was done. Ignore the return value as the resume should
6382          * not be failed. In the case of removable media the media need not be
6383          * inserted and hence there is a chance that raise power will fail with
6384          * media not present.
6385          */
6386         if (un->un_f_attach_spinup) {
6387                 mutex_exit(SD_MUTEX(un));
6388                 (void) pm_raise_power(SD_DEVINFO(un), 0,
6389                     SD_PM_STATE_ACTIVE(un));
6390                 mutex_enter(SD_MUTEX(un));
6391         }
6392 
6393         /*
6394          * Don't broadcast to the suspend cv and therefore possibly
6395          * start I/O until after power has been restored.
6396          */
6397         cv_broadcast(&un->un_suspend_cv);
6398         cv_broadcast(&un->un_state_cv);
6399 
6400         /* restart thread */
6401         if (SD_OK_TO_RESUME_SCSI_WATCHER(un)) {
6402                 scsi_watch_resume(un->un_swr_token);
6403         }
6404 
6405 #if (defined(__fibre))
6406         if (un->un_f_is_fibre == TRUE) {
6407                 /*
6408                  * Add callbacks for insert and remove events
6409                  */
6410                 if (strcmp(un->un_node_type, DDI_NT_BLOCK_CHAN)) {
6411                         sd_init_event_callbacks(un);
6412                 }
6413         }
6414 #endif
6415 
6416         /*
6417          * Transport any pending commands to the target.
6418          *
6419          * If this is a low-activity device commands in queue will have to wait
6420          * until new commands come in, which may take awhile. Also, we
6421          * specifically don't check un_ncmds_in_transport because we know that
6422          * there really are no commands in progress after the unit was
6423          * suspended and we could have reached the throttle level, been
6424          * suspended, and have no new commands coming in for awhile. Highly
6425          * unlikely, but so is the low-activity disk scenario.
6426          */
6427         ddi_xbuf_dispatch(un->un_xbuf_attr);
6428 
6429         sd_start_cmds(un, NULL);
6430         mutex_exit(SD_MUTEX(un));
6431 
6432         SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_resume: exit\n");
6433 
6434         return (DDI_SUCCESS);
6435 }
6436 
6437 
6438 /*
6439  *    Function: sd_pm_state_change
6440  *
6441  * Description: Change the driver power state.
6442  *              Someone else is required to actually change the driver
6443  *              power level.
6444  *
6445  *   Arguments: un - driver soft state (unit) structure
6446  *              level - the power level that is changed to
6447  *              flag - to decide how to change the power state
6448  *
6449  * Return Code: DDI_SUCCESS
6450  *
6451  *     Context: Kernel thread context
6452  */
6453 static int
6454 sd_pm_state_change(struct sd_lun *un, int level, int flag)
6455 {
6456         ASSERT(un != NULL);
6457         SD_TRACE(SD_LOG_POWER, un, "sd_pm_state_change: entry\n");
6458 
6459         ASSERT(!mutex_owned(SD_MUTEX(un)));
6460         mutex_enter(SD_MUTEX(un));
6461 
6462         if (flag == SD_PM_STATE_ROLLBACK || SD_PM_IS_IO_CAPABLE(un, level)) {
6463                 un->un_power_level = level;
6464                 ASSERT(!mutex_owned(&un->un_pm_mutex));
6465                 mutex_enter(&un->un_pm_mutex);
6466                 if (SD_DEVICE_IS_IN_LOW_POWER(un)) {
6467                         un->un_pm_count++;
6468                         ASSERT(un->un_pm_count == 0);
6469                 }
6470                 mutex_exit(&un->un_pm_mutex);
6471         } else {
6472                 /*
6473                  * Exit if power management is not enabled for this device,
6474                  * or if the device is being used by HA.
6475                  */
6476                 if ((un->un_f_pm_is_enabled == FALSE) || (un->un_resvd_status &
6477                     (SD_RESERVE | SD_WANT_RESERVE | SD_LOST_RESERVE))) {
6478                         mutex_exit(SD_MUTEX(un));
6479                         SD_TRACE(SD_LOG_POWER, un,
6480                             "sd_pm_state_change: exiting\n");
6481                         return (DDI_FAILURE);
6482                 }
6483 
6484                 SD_INFO(SD_LOG_POWER, un, "sd_pm_state_change: "
6485                     "un_ncmds_in_driver=%ld\n", un->un_ncmds_in_driver);
6486 
6487                 /*
6488                  * See if the device is not busy, ie.:
6489                  *    - we have no commands in the driver for this device
6490                  *    - not waiting for resources
6491                  */
6492                 if ((un->un_ncmds_in_driver == 0) &&
6493                     (un->un_state != SD_STATE_RWAIT)) {
6494                         /*
6495                          * The device is not busy, so it is OK to go to low
6496                          * power state. Indicate low power, but rely on someone
6497                          * else to actually change it.
6498                          */
6499                         mutex_enter(&un->un_pm_mutex);
6500                         un->un_pm_count = -1;
6501                         mutex_exit(&un->un_pm_mutex);
6502                         un->un_power_level = level;
6503                 }
6504         }
6505 
6506         mutex_exit(SD_MUTEX(un));
6507 
6508         SD_TRACE(SD_LOG_POWER, un, "sd_pm_state_change: exit\n");
6509 
6510         return (DDI_SUCCESS);
6511 }
6512 
6513 
6514 /*
6515  *    Function: sd_pm_idletimeout_handler
6516  *
6517  * Description: A timer routine that's active only while a device is busy.
6518  *              The purpose is to extend slightly the pm framework's busy
6519  *              view of the device to prevent busy/idle thrashing for
6520  *              back-to-back commands. Do this by comparing the current time
6521  *              to the time at which the last command completed and when the
6522  *              difference is greater than sd_pm_idletime, call
6523  *              pm_idle_component. In addition to indicating idle to the pm
6524  *              framework, update the chain type to again use the internal pm
6525  *              layers of the driver.
6526  *
6527  *   Arguments: arg - driver soft state (unit) structure
6528  *
6529  *     Context: Executes in a timeout(9F) thread context
6530  */
6531 
6532 static void
6533 sd_pm_idletimeout_handler(void *arg)
6534 {
6535         struct sd_lun *un = arg;
6536 
6537         time_t  now;
6538 
6539         mutex_enter(&sd_detach_mutex);
6540         if (un->un_detach_count != 0) {
6541                 /* Abort if the instance is detaching */
6542                 mutex_exit(&sd_detach_mutex);
6543                 return;
6544         }
6545         mutex_exit(&sd_detach_mutex);
6546 
6547         now = ddi_get_time();
6548         /*
6549          * Grab both mutexes, in the proper order, since we're accessing
6550          * both PM and softstate variables.
6551          */
6552         mutex_enter(SD_MUTEX(un));
6553         mutex_enter(&un->un_pm_mutex);
6554         if (((now - un->un_pm_idle_time) > sd_pm_idletime) &&
6555             (un->un_ncmds_in_driver == 0) && (un->un_pm_count == 0)) {
6556                 /*
6557                  * Update the chain types.
6558                  * This takes affect on the next new command received.
6559                  */
6560                 if (un->un_f_non_devbsize_supported) {
6561                         un->un_buf_chain_type = SD_CHAIN_INFO_RMMEDIA;
6562                 } else {
6563                         un->un_buf_chain_type = SD_CHAIN_INFO_DISK;
6564                 }
6565                 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD;
6566 
6567                 SD_TRACE(SD_LOG_IO_PM, un,
6568                     "sd_pm_idletimeout_handler: idling device\n");
6569                 (void) pm_idle_component(SD_DEVINFO(un), 0);
6570                 un->un_pm_idle_timeid = NULL;
6571         } else {
6572                 un->un_pm_idle_timeid =
6573                     timeout(sd_pm_idletimeout_handler, un,
6574                     (drv_usectohz((clock_t)300000))); /* 300 ms. */
6575         }
6576         mutex_exit(&un->un_pm_mutex);
6577         mutex_exit(SD_MUTEX(un));
6578 }
6579 
6580 
6581 /*
6582  *    Function: sd_pm_timeout_handler
6583  *
6584  * Description: Callback to tell framework we are idle.
6585  *
6586  *     Context: timeout(9f) thread context.
6587  */
6588 
6589 static void
6590 sd_pm_timeout_handler(void *arg)
6591 {
6592         struct sd_lun *un = arg;
6593 
6594         (void) pm_idle_component(SD_DEVINFO(un), 0);
6595         mutex_enter(&un->un_pm_mutex);
6596         un->un_pm_timeid = NULL;
6597         mutex_exit(&un->un_pm_mutex);
6598 }
6599 
6600 
6601 /*
6602  *    Function: sdpower
6603  *
6604  * Description: PM entry point.
6605  *
6606  * Return Code: DDI_SUCCESS
6607  *              DDI_FAILURE
6608  *
6609  *     Context: Kernel thread context
6610  */
6611 
6612 static int
6613 sdpower(dev_info_t *devi, int component, int level)
6614 {
6615         struct sd_lun   *un;
6616         int             instance;
6617         int             rval = DDI_SUCCESS;
6618         uint_t          i, log_page_size, maxcycles, ncycles;
6619         uchar_t         *log_page_data;
6620         int             log_sense_page;
6621         int             medium_present;
6622         time_t          intvlp;
6623         struct pm_trans_data    sd_pm_tran_data;
6624         uchar_t         save_state;
6625         int             sval;
6626         uchar_t         state_before_pm;
6627         int             got_semaphore_here;
6628         sd_ssc_t        *ssc;
6629         int     last_power_level;
6630 
6631         instance = ddi_get_instance(devi);
6632 
6633         if (((un = ddi_get_soft_state(sd_state, instance)) == NULL) ||
6634             !SD_PM_IS_LEVEL_VALID(un, level) || component != 0) {
6635                 return (DDI_FAILURE);
6636         }
6637 
6638         ssc = sd_ssc_init(un);
6639 
6640         SD_TRACE(SD_LOG_IO_PM, un, "sdpower: entry, level = %d\n", level);
6641 
6642         /*
6643          * Must synchronize power down with close.
6644          * Attempt to decrement/acquire the open/close semaphore,
6645          * but do NOT wait on it. If it's not greater than zero,
6646          * ie. it can't be decremented without waiting, then
6647          * someone else, either open or close, already has it
6648          * and the try returns 0. Use that knowledge here to determine
6649          * if it's OK to change the device power level.
6650          * Also, only increment it on exit if it was decremented, ie. gotten,
6651          * here.
6652          */
6653         got_semaphore_here = sema_tryp(&un->un_semoclose);
6654 
6655         mutex_enter(SD_MUTEX(un));
6656 
6657         SD_INFO(SD_LOG_POWER, un, "sdpower: un_ncmds_in_driver = %ld\n",
6658             un->un_ncmds_in_driver);
6659 
6660         /*
6661          * If un_ncmds_in_driver is non-zero it indicates commands are
6662          * already being processed in the driver, or if the semaphore was
6663          * not gotten here it indicates an open or close is being processed.
6664          * At the same time somebody is requesting to go to a lower power
6665          * that can't perform I/O, which can't happen, therefore we need to
6666          * return failure.
6667          */
6668         if ((!SD_PM_IS_IO_CAPABLE(un, level)) &&
6669             ((un->un_ncmds_in_driver != 0) || (got_semaphore_here == 0))) {
6670                 mutex_exit(SD_MUTEX(un));
6671 
6672                 if (got_semaphore_here != 0) {
6673                         sema_v(&un->un_semoclose);
6674                 }
6675                 SD_TRACE(SD_LOG_IO_PM, un,
6676                     "sdpower: exit, device has queued cmds.\n");
6677 
6678                 goto sdpower_failed;
6679         }
6680 
6681         /*
6682          * if it is OFFLINE that means the disk is completely dead
6683          * in our case we have to put the disk in on or off by sending commands
6684          * Of course that will fail anyway so return back here.
6685          *
6686          * Power changes to a device that's OFFLINE or SUSPENDED
6687          * are not allowed.
6688          */
6689         if ((un->un_state == SD_STATE_OFFLINE) ||
6690             (un->un_state == SD_STATE_SUSPENDED)) {
6691                 mutex_exit(SD_MUTEX(un));
6692 
6693                 if (got_semaphore_here != 0) {
6694                         sema_v(&un->un_semoclose);
6695                 }
6696                 SD_TRACE(SD_LOG_IO_PM, un,
6697                     "sdpower: exit, device is off-line.\n");
6698 
6699                 goto sdpower_failed;
6700         }
6701 
6702         /*
6703          * Change the device's state to indicate it's power level
6704          * is being changed. Do this to prevent a power off in the
6705          * middle of commands, which is especially bad on devices
6706          * that are really powered off instead of just spun down.
6707          */
6708         state_before_pm = un->un_state;
6709         un->un_state = SD_STATE_PM_CHANGING;
6710 
6711         mutex_exit(SD_MUTEX(un));
6712 
6713         /*
6714          * If log sense command is not supported, bypass the
6715          * following checking, otherwise, check the log sense
6716          * information for this device.
6717          */
6718         if (SD_PM_STOP_MOTOR_NEEDED(un, level) &&
6719             un->un_f_log_sense_supported) {
6720                 /*
6721                  * Get the log sense information to understand whether the
6722                  * the powercycle counts have gone beyond the threshhold.
6723                  */
6724                 log_page_size = START_STOP_CYCLE_COUNTER_PAGE_SIZE;
6725                 log_page_data = kmem_zalloc(log_page_size, KM_SLEEP);
6726 
6727                 mutex_enter(SD_MUTEX(un));
6728                 log_sense_page = un->un_start_stop_cycle_page;
6729                 mutex_exit(SD_MUTEX(un));
6730 
6731                 rval = sd_send_scsi_LOG_SENSE(ssc, log_page_data,
6732                     log_page_size, log_sense_page, 0x01, 0, SD_PATH_DIRECT);
6733 
6734                 if (rval != 0) {
6735                         if (rval == EIO)
6736                                 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
6737                         else
6738                                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
6739                 }
6740 
6741 #ifdef  SDDEBUG
6742                 if (sd_force_pm_supported) {
6743                         /* Force a successful result */
6744                         rval = 0;
6745                 }
6746 #endif
6747                 if (rval != 0) {
6748                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
6749                             "Log Sense Failed\n");
6750 
6751                         kmem_free(log_page_data, log_page_size);
6752                         /* Cannot support power management on those drives */
6753 
6754                         if (got_semaphore_here != 0) {
6755                                 sema_v(&un->un_semoclose);
6756                         }
6757                         /*
6758                          * On exit put the state back to it's original value
6759                          * and broadcast to anyone waiting for the power
6760                          * change completion.
6761                          */
6762                         mutex_enter(SD_MUTEX(un));
6763                         un->un_state = state_before_pm;
6764                         cv_broadcast(&un->un_suspend_cv);
6765                         mutex_exit(SD_MUTEX(un));
6766                         SD_TRACE(SD_LOG_IO_PM, un,
6767                             "sdpower: exit, Log Sense Failed.\n");
6768 
6769                         goto sdpower_failed;
6770                 }
6771 
6772                 /*
6773                  * From the page data - Convert the essential information to
6774                  * pm_trans_data
6775                  */
6776                 maxcycles =
6777                     (log_page_data[0x1c] << 24) | (log_page_data[0x1d] << 16) |
6778                     (log_page_data[0x1E] << 8)  | log_page_data[0x1F];
6779 
6780                 ncycles =
6781                     (log_page_data[0x24] << 24) | (log_page_data[0x25] << 16) |
6782                     (log_page_data[0x26] << 8)  | log_page_data[0x27];
6783 
6784                 if (un->un_f_pm_log_sense_smart) {
6785                         sd_pm_tran_data.un.smart_count.allowed = maxcycles;
6786                         sd_pm_tran_data.un.smart_count.consumed = ncycles;
6787                         sd_pm_tran_data.un.smart_count.flag = 0;
6788                         sd_pm_tran_data.format = DC_SMART_FORMAT;
6789                 } else {
6790                         sd_pm_tran_data.un.scsi_cycles.lifemax = maxcycles;
6791                         sd_pm_tran_data.un.scsi_cycles.ncycles = ncycles;
6792                         for (i = 0; i < DC_SCSI_MFR_LEN; i++) {
6793                                 sd_pm_tran_data.un.scsi_cycles.svc_date[i] =
6794                                     log_page_data[8+i];
6795                         }
6796                         sd_pm_tran_data.un.scsi_cycles.flag = 0;
6797                         sd_pm_tran_data.format = DC_SCSI_FORMAT;
6798                 }
6799 
6800                 kmem_free(log_page_data, log_page_size);
6801 
6802                 /*
6803                  * Call pm_trans_check routine to get the Ok from
6804                  * the global policy
6805                  */
6806                 rval = pm_trans_check(&sd_pm_tran_data, &intvlp);
6807 #ifdef  SDDEBUG
6808                 if (sd_force_pm_supported) {
6809                         /* Force a successful result */
6810                         rval = 1;
6811                 }
6812 #endif
6813                 switch (rval) {
6814                 case 0:
6815                         /*
6816                          * Not Ok to Power cycle or error in parameters passed
6817                          * Would have given the advised time to consider power
6818                          * cycle. Based on the new intvlp parameter we are
6819                          * supposed to pretend we are busy so that pm framework
6820                          * will never call our power entry point. Because of
6821                          * that install a timeout handler and wait for the
6822                          * recommended time to elapse so that power management
6823                          * can be effective again.
6824                          *
6825                          * To effect this behavior, call pm_busy_component to
6826                          * indicate to the framework this device is busy.
6827                          * By not adjusting un_pm_count the rest of PM in
6828                          * the driver will function normally, and independent
6829                          * of this but because the framework is told the device
6830                          * is busy it won't attempt powering down until it gets
6831                          * a matching idle. The timeout handler sends this.
6832                          * Note: sd_pm_entry can't be called here to do this
6833                          * because sdpower may have been called as a result
6834                          * of a call to pm_raise_power from within sd_pm_entry.
6835                          *
6836                          * If a timeout handler is already active then
6837                          * don't install another.
6838                          */
6839                         mutex_enter(&un->un_pm_mutex);
6840                         if (un->un_pm_timeid == NULL) {
6841                                 un->un_pm_timeid =
6842                                     timeout(sd_pm_timeout_handler,
6843                                     un, intvlp * drv_usectohz(1000000));
6844                                 mutex_exit(&un->un_pm_mutex);
6845                                 (void) pm_busy_component(SD_DEVINFO(un), 0);
6846                         } else {
6847                                 mutex_exit(&un->un_pm_mutex);
6848                         }
6849                         if (got_semaphore_here != 0) {
6850                                 sema_v(&un->un_semoclose);
6851                         }
6852                         /*
6853                          * On exit put the state back to it's original value
6854                          * and broadcast to anyone waiting for the power
6855                          * change completion.
6856                          */
6857                         mutex_enter(SD_MUTEX(un));
6858                         un->un_state = state_before_pm;
6859                         cv_broadcast(&un->un_suspend_cv);
6860                         mutex_exit(SD_MUTEX(un));
6861 
6862                         SD_TRACE(SD_LOG_IO_PM, un, "sdpower: exit, "
6863                             "trans check Failed, not ok to power cycle.\n");
6864 
6865                         goto sdpower_failed;
6866                 case -1:
6867                         if (got_semaphore_here != 0) {
6868                                 sema_v(&un->un_semoclose);
6869                         }
6870                         /*
6871                          * On exit put the state back to it's original value
6872                          * and broadcast to anyone waiting for the power
6873                          * change completion.
6874                          */
6875                         mutex_enter(SD_MUTEX(un));
6876                         un->un_state = state_before_pm;
6877                         cv_broadcast(&un->un_suspend_cv);
6878                         mutex_exit(SD_MUTEX(un));
6879                         SD_TRACE(SD_LOG_IO_PM, un,
6880                             "sdpower: exit, trans check command Failed.\n");
6881 
6882                         goto sdpower_failed;
6883                 }
6884         }
6885 
6886         if (!SD_PM_IS_IO_CAPABLE(un, level)) {
6887                 /*
6888                  * Save the last state... if the STOP FAILS we need it
6889                  * for restoring
6890                  */
6891                 mutex_enter(SD_MUTEX(un));
6892                 save_state = un->un_last_state;
6893                 last_power_level = un->un_power_level;
6894                 /*
6895                  * There must not be any cmds. getting processed
6896                  * in the driver when we get here. Power to the
6897                  * device is potentially going off.
6898                  */
6899                 ASSERT(un->un_ncmds_in_driver == 0);
6900                 mutex_exit(SD_MUTEX(un));
6901 
6902                 /*
6903                  * For now PM suspend the device completely before spindle is
6904                  * turned off
6905                  */
6906                 if ((rval = sd_pm_state_change(un, level, SD_PM_STATE_CHANGE))
6907                     == DDI_FAILURE) {
6908                         if (got_semaphore_here != 0) {
6909                                 sema_v(&un->un_semoclose);
6910                         }
6911                         /*
6912                          * On exit put the state back to it's original value
6913                          * and broadcast to anyone waiting for the power
6914                          * change completion.
6915                          */
6916                         mutex_enter(SD_MUTEX(un));
6917                         un->un_state = state_before_pm;
6918                         un->un_power_level = last_power_level;
6919                         cv_broadcast(&un->un_suspend_cv);
6920                         mutex_exit(SD_MUTEX(un));
6921                         SD_TRACE(SD_LOG_IO_PM, un,
6922                             "sdpower: exit, PM suspend Failed.\n");
6923 
6924                         goto sdpower_failed;
6925                 }
6926         }
6927 
6928         /*
6929          * The transition from SPINDLE_OFF to SPINDLE_ON can happen in open,
6930          * close, or strategy. Dump no long uses this routine, it uses it's
6931          * own code so it can be done in polled mode.
6932          */
6933 
6934         medium_present = TRUE;
6935 
6936         /*
6937          * When powering up, issue a TUR in case the device is at unit
6938          * attention.  Don't do retries. Bypass the PM layer, otherwise
6939          * a deadlock on un_pm_busy_cv will occur.
6940          */
6941         if (SD_PM_IS_IO_CAPABLE(un, level)) {
6942                 sval = sd_send_scsi_TEST_UNIT_READY(ssc,
6943                     SD_DONT_RETRY_TUR | SD_BYPASS_PM);
6944                 if (sval != 0)
6945                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
6946         }
6947 
6948         if (un->un_f_power_condition_supported) {
6949                 char *pm_condition_name[] = {"STOPPED", "STANDBY",
6950                     "IDLE", "ACTIVE"};
6951                 SD_TRACE(SD_LOG_IO_PM, un,
6952                     "sdpower: sending \'%s\' power condition",
6953                     pm_condition_name[level]);
6954                 sval = sd_send_scsi_START_STOP_UNIT(ssc, SD_POWER_CONDITION,
6955                     sd_pl2pc[level], SD_PATH_DIRECT);
6956         } else {
6957                 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: sending \'%s\' unit\n",
6958                     ((level == SD_SPINDLE_ON) ? "START" : "STOP"));
6959                 sval = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
6960                     ((level == SD_SPINDLE_ON) ? SD_TARGET_START :
6961                     SD_TARGET_STOP), SD_PATH_DIRECT);
6962         }
6963         if (sval != 0) {
6964                 if (sval == EIO)
6965                         sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
6966                 else
6967                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
6968         }
6969 
6970         /* Command failed, check for media present. */
6971         if ((sval == ENXIO) && un->un_f_has_removable_media) {
6972                 medium_present = FALSE;
6973         }
6974 
6975         /*
6976          * The conditions of interest here are:
6977          *   if a spindle off with media present fails,
6978          *      then restore the state and return an error.
6979          *   else if a spindle on fails,
6980          *      then return an error (there's no state to restore).
6981          * In all other cases we setup for the new state
6982          * and return success.
6983          */
6984         if (!SD_PM_IS_IO_CAPABLE(un, level)) {
6985                 if ((medium_present == TRUE) && (sval != 0)) {
6986                         /* The stop command from above failed */
6987                         rval = DDI_FAILURE;
6988                         /*
6989                          * The stop command failed, and we have media
6990                          * present. Put the level back by calling the
6991                          * sd_pm_resume() and set the state back to
6992                          * it's previous value.
6993                          */
6994                         (void) sd_pm_state_change(un, last_power_level,
6995                             SD_PM_STATE_ROLLBACK);
6996                         mutex_enter(SD_MUTEX(un));
6997                         un->un_last_state = save_state;
6998                         mutex_exit(SD_MUTEX(un));
6999                 } else if (un->un_f_monitor_media_state) {
7000                         /*
7001                          * The stop command from above succeeded.
7002                          * Terminate watch thread in case of removable media
7003                          * devices going into low power state. This is as per
7004                          * the requirements of pm framework, otherwise commands
7005                          * will be generated for the device (through watch
7006                          * thread), even when the device is in low power state.
7007                          */
7008                         mutex_enter(SD_MUTEX(un));
7009                         un->un_f_watcht_stopped = FALSE;
7010                         if (un->un_swr_token != NULL) {
7011                                 opaque_t temp_token = un->un_swr_token;
7012                                 un->un_f_watcht_stopped = TRUE;
7013                                 un->un_swr_token = NULL;
7014                                 mutex_exit(SD_MUTEX(un));
7015                                 (void) scsi_watch_request_terminate(temp_token,
7016                                     SCSI_WATCH_TERMINATE_ALL_WAIT);
7017                         } else {
7018                                 mutex_exit(SD_MUTEX(un));
7019                         }
7020                 }
7021         } else {
7022                 /*
7023                  * The level requested is I/O capable.
7024                  * Legacy behavior: return success on a failed spinup
7025                  * if there is no media in the drive.
7026                  * Do this by looking at medium_present here.
7027                  */
7028                 if ((sval != 0) && medium_present) {
7029                         /* The start command from above failed */
7030                         rval = DDI_FAILURE;
7031                 } else {
7032                         /*
7033                          * The start command from above succeeded
7034                          * PM resume the devices now that we have
7035                          * started the disks
7036                          */
7037                         (void) sd_pm_state_change(un, level,
7038                             SD_PM_STATE_CHANGE);
7039 
7040                         /*
7041                          * Resume the watch thread since it was suspended
7042                          * when the device went into low power mode.
7043                          */
7044                         if (un->un_f_monitor_media_state) {
7045                                 mutex_enter(SD_MUTEX(un));
7046                                 if (un->un_f_watcht_stopped == TRUE) {
7047                                         opaque_t temp_token;
7048 
7049                                         un->un_f_watcht_stopped = FALSE;
7050                                         mutex_exit(SD_MUTEX(un));
7051                                         temp_token =
7052                                             sd_watch_request_submit(un);
7053                                         mutex_enter(SD_MUTEX(un));
7054                                         un->un_swr_token = temp_token;
7055                                 }
7056                                 mutex_exit(SD_MUTEX(un));
7057                         }
7058                 }
7059         }
7060 
7061         if (got_semaphore_here != 0) {
7062                 sema_v(&un->un_semoclose);
7063         }
7064         /*
7065          * On exit put the state back to it's original value
7066          * and broadcast to anyone waiting for the power
7067          * change completion.
7068          */
7069         mutex_enter(SD_MUTEX(un));
7070         un->un_state = state_before_pm;
7071         cv_broadcast(&un->un_suspend_cv);
7072         mutex_exit(SD_MUTEX(un));
7073 
7074         SD_TRACE(SD_LOG_IO_PM, un, "sdpower: exit, status = 0x%x\n", rval);
7075 
7076         sd_ssc_fini(ssc);
7077         return (rval);
7078 
7079 sdpower_failed:
7080 
7081         sd_ssc_fini(ssc);
7082         return (DDI_FAILURE);
7083 }
7084 
7085 
7086 
7087 /*
7088  *    Function: sdattach
7089  *
7090  * Description: Driver's attach(9e) entry point function.
7091  *
7092  *   Arguments: devi - opaque device info handle
7093  *              cmd  - attach  type
7094  *
7095  * Return Code: DDI_SUCCESS
7096  *              DDI_FAILURE
7097  *
7098  *     Context: Kernel thread context
7099  */
7100 
7101 static int
7102 sdattach(dev_info_t *devi, ddi_attach_cmd_t cmd)
7103 {
7104         switch (cmd) {
7105         case DDI_ATTACH:
7106                 return (sd_unit_attach(devi));
7107         case DDI_RESUME:
7108                 return (sd_ddi_resume(devi));
7109         default:
7110                 break;
7111         }
7112         return (DDI_FAILURE);
7113 }
7114 
7115 
7116 /*
7117  *    Function: sddetach
7118  *
7119  * Description: Driver's detach(9E) entry point function.
7120  *
7121  *   Arguments: devi - opaque device info handle
7122  *              cmd  - detach  type
7123  *
7124  * Return Code: DDI_SUCCESS
7125  *              DDI_FAILURE
7126  *
7127  *     Context: Kernel thread context
7128  */
7129 
7130 static int
7131 sddetach(dev_info_t *devi, ddi_detach_cmd_t cmd)
7132 {
7133         switch (cmd) {
7134         case DDI_DETACH:
7135                 return (sd_unit_detach(devi));
7136         case DDI_SUSPEND:
7137                 return (sd_ddi_suspend(devi));
7138         default:
7139                 break;
7140         }
7141         return (DDI_FAILURE);
7142 }
7143 
7144 
7145 /*
7146  *     Function: sd_sync_with_callback
7147  *
7148  *  Description: Prevents sd_unit_attach or sd_unit_detach from freeing the soft
7149  *               state while the callback routine is active.
7150  *
7151  *    Arguments: un: softstate structure for the instance
7152  *
7153  *      Context: Kernel thread context
7154  */
7155 
7156 static void
7157 sd_sync_with_callback(struct sd_lun *un)
7158 {
7159         ASSERT(un != NULL);
7160 
7161         mutex_enter(SD_MUTEX(un));
7162 
7163         ASSERT(un->un_in_callback >= 0);
7164 
7165         while (un->un_in_callback > 0) {
7166                 mutex_exit(SD_MUTEX(un));
7167                 delay(2);
7168                 mutex_enter(SD_MUTEX(un));
7169         }
7170 
7171         mutex_exit(SD_MUTEX(un));
7172 }
7173 
7174 /*
7175  *    Function: sd_unit_attach
7176  *
7177  * Description: Performs DDI_ATTACH processing for sdattach(). Allocates
7178  *              the soft state structure for the device and performs
7179  *              all necessary structure and device initializations.
7180  *
7181  *   Arguments: devi: the system's dev_info_t for the device.
7182  *
7183  * Return Code: DDI_SUCCESS if attach is successful.
7184  *              DDI_FAILURE if any part of the attach fails.
7185  *
7186  *     Context: Called at attach(9e) time for the DDI_ATTACH flag.
7187  *              Kernel thread context only.  Can sleep.
7188  */
7189 
7190 static int
7191 sd_unit_attach(dev_info_t *devi)
7192 {
7193         struct  scsi_device     *devp;
7194         struct  sd_lun          *un;
7195         char                    *variantp;
7196         char                    name_str[48];
7197         int     reservation_flag = SD_TARGET_IS_UNRESERVED;
7198         int     instance;
7199         int     rval;
7200         int     wc_enabled;
7201         int     tgt;
7202         uint64_t        capacity;
7203         uint_t          lbasize = 0;
7204         dev_info_t      *pdip = ddi_get_parent(devi);
7205         int             offbyone = 0;
7206         int             geom_label_valid = 0;
7207         sd_ssc_t        *ssc;
7208         int             status;
7209         struct sd_fm_internal   *sfip = NULL;
7210         int             max_xfer_size;
7211 
7212         /*
7213          * Retrieve the target driver's private data area. This was set
7214          * up by the HBA.
7215          */
7216         devp = ddi_get_driver_private(devi);
7217 
7218         /*
7219          * Retrieve the target ID of the device.
7220          */
7221         tgt = ddi_prop_get_int(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
7222             SCSI_ADDR_PROP_TARGET, -1);
7223 
7224         /*
7225          * Since we have no idea what state things were left in by the last
7226          * user of the device, set up some 'default' settings, ie. turn 'em
7227          * off. The scsi_ifsetcap calls force re-negotiations with the drive.
7228          * Do this before the scsi_probe, which sends an inquiry.
7229          * This is a fix for bug (4430280).
7230          * Of special importance is wide-xfer. The drive could have been left
7231          * in wide transfer mode by the last driver to communicate with it,
7232          * this includes us. If that's the case, and if the following is not
7233          * setup properly or we don't re-negotiate with the drive prior to
7234          * transferring data to/from the drive, it causes bus parity errors,
7235          * data overruns, and unexpected interrupts. This first occurred when
7236          * the fix for bug (4378686) was made.
7237          */
7238         (void) scsi_ifsetcap(&devp->sd_address, "lun-reset", 0, 1);
7239         (void) scsi_ifsetcap(&devp->sd_address, "wide-xfer", 0, 1);
7240         (void) scsi_ifsetcap(&devp->sd_address, "auto-rqsense", 0, 1);
7241 
7242         /*
7243          * Currently, scsi_ifsetcap sets tagged-qing capability for all LUNs
7244          * on a target. Setting it per lun instance actually sets the
7245          * capability of this target, which affects those luns already
7246          * attached on the same target. So during attach, we can only disable
7247          * this capability only when no other lun has been attached on this
7248          * target. By doing this, we assume a target has the same tagged-qing
7249          * capability for every lun. The condition can be removed when HBA
7250          * is changed to support per lun based tagged-qing capability.
7251          */
7252         if (sd_scsi_get_target_lun_count(pdip, tgt) < 1) {
7253                 (void) scsi_ifsetcap(&devp->sd_address, "tagged-qing", 0, 1);
7254         }
7255 
7256         /*
7257          * Use scsi_probe() to issue an INQUIRY command to the device.
7258          * This call will allocate and fill in the scsi_inquiry structure
7259          * and point the sd_inq member of the scsi_device structure to it.
7260          * If the attach succeeds, then this memory will not be de-allocated
7261          * (via scsi_unprobe()) until the instance is detached.
7262          */
7263         if (scsi_probe(devp, SLEEP_FUNC) != SCSIPROBE_EXISTS) {
7264                 goto probe_failed;
7265         }
7266 
7267         /*
7268          * Check the device type as specified in the inquiry data and
7269          * claim it if it is of a type that we support.
7270          */
7271         switch (devp->sd_inq->inq_dtype) {
7272         case DTYPE_DIRECT:
7273                 break;
7274         case DTYPE_RODIRECT:
7275                 break;
7276         case DTYPE_OPTICAL:
7277                 break;
7278         case DTYPE_NOTPRESENT:
7279         default:
7280                 /* Unsupported device type; fail the attach. */
7281                 goto probe_failed;
7282         }
7283 
7284         /*
7285          * Allocate the soft state structure for this unit.
7286          *
7287          * We rely upon this memory being set to all zeroes by
7288          * ddi_soft_state_zalloc().  We assume that any member of the
7289          * soft state structure that is not explicitly initialized by
7290          * this routine will have a value of zero.
7291          */
7292         instance = ddi_get_instance(devp->sd_dev);
7293 #ifndef XPV_HVM_DRIVER
7294         if (ddi_soft_state_zalloc(sd_state, instance) != DDI_SUCCESS) {
7295                 goto probe_failed;
7296         }
7297 #endif /* !XPV_HVM_DRIVER */
7298 
7299         /*
7300          * Retrieve a pointer to the newly-allocated soft state.
7301          *
7302          * This should NEVER fail if the ddi_soft_state_zalloc() call above
7303          * was successful, unless something has gone horribly wrong and the
7304          * ddi's soft state internals are corrupt (in which case it is
7305          * probably better to halt here than just fail the attach....)
7306          */
7307         if ((un = ddi_get_soft_state(sd_state, instance)) == NULL) {
7308                 panic("sd_unit_attach: NULL soft state on instance:0x%x",
7309                     instance);
7310                 /*NOTREACHED*/
7311         }
7312 
7313         /*
7314          * Link the back ptr of the driver soft state to the scsi_device
7315          * struct for this lun.
7316          * Save a pointer to the softstate in the driver-private area of
7317          * the scsi_device struct.
7318          * Note: We cannot call SD_INFO, SD_TRACE, SD_ERROR, or SD_DIAG until
7319          * we first set un->un_sd below.
7320          */
7321         un->un_sd = devp;
7322         devp->sd_private = (opaque_t)un;
7323 
7324         /*
7325          * The following must be after devp is stored in the soft state struct.
7326          */
7327 #ifdef SDDEBUG
7328         SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7329             "%s_unit_attach: un:0x%p instance:%d\n",
7330             ddi_driver_name(devi), un, instance);
7331 #endif
7332 
7333         /*
7334          * Set up the device type and node type (for the minor nodes).
7335          * By default we assume that the device can at least support the
7336          * Common Command Set. Call it a CD-ROM if it reports itself
7337          * as a RODIRECT device.
7338          */
7339         switch (devp->sd_inq->inq_dtype) {
7340         case DTYPE_RODIRECT:
7341                 un->un_node_type = DDI_NT_CD_CHAN;
7342                 un->un_ctype  = CTYPE_CDROM;
7343                 break;
7344         case DTYPE_OPTICAL:
7345                 un->un_node_type = DDI_NT_BLOCK_CHAN;
7346                 un->un_ctype  = CTYPE_ROD;
7347                 break;
7348         default:
7349                 un->un_node_type = DDI_NT_BLOCK_CHAN;
7350                 un->un_ctype  = CTYPE_CCS;
7351                 break;
7352         }
7353 
7354         /*
7355          * Try to read the interconnect type from the HBA.
7356          *
7357          * Note: This driver is currently compiled as two binaries, a parallel
7358          * scsi version (sd) and a fibre channel version (ssd). All functional
7359          * differences are determined at compile time. In the future a single
7360          * binary will be provided and the interconnect type will be used to
7361          * differentiate between fibre and parallel scsi behaviors. At that time
7362          * it will be necessary for all fibre channel HBAs to support this
7363          * property.
7364          *
7365          * set un_f_is_fiber to TRUE ( default fiber )
7366          */
7367         un->un_f_is_fibre = TRUE;
7368         switch (scsi_ifgetcap(SD_ADDRESS(un), "interconnect-type", -1)) {
7369         case INTERCONNECT_SSA:
7370                 un->un_interconnect_type = SD_INTERCONNECT_SSA;
7371                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7372                     "sd_unit_attach: un:0x%p SD_INTERCONNECT_SSA\n", un);
7373                 break;
7374         case INTERCONNECT_PARALLEL:
7375                 un->un_f_is_fibre = FALSE;
7376                 un->un_interconnect_type = SD_INTERCONNECT_PARALLEL;
7377                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7378                     "sd_unit_attach: un:0x%p SD_INTERCONNECT_PARALLEL\n", un);
7379                 break;
7380         case INTERCONNECT_SAS:
7381                 un->un_f_is_fibre = FALSE;
7382                 un->un_interconnect_type = SD_INTERCONNECT_SAS;
7383                 un->un_node_type = DDI_NT_BLOCK_SAS;
7384                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7385                     "sd_unit_attach: un:0x%p SD_INTERCONNECT_SAS\n", un);
7386                 break;
7387         case INTERCONNECT_SATA:
7388                 un->un_f_is_fibre = FALSE;
7389                 un->un_interconnect_type = SD_INTERCONNECT_SATA;
7390                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7391                     "sd_unit_attach: un:0x%p SD_INTERCONNECT_SATA\n", un);
7392                 break;
7393         case INTERCONNECT_FIBRE:
7394                 un->un_interconnect_type = SD_INTERCONNECT_FIBRE;
7395                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7396                     "sd_unit_attach: un:0x%p SD_INTERCONNECT_FIBRE\n", un);
7397                 break;
7398         case INTERCONNECT_FABRIC:
7399                 un->un_interconnect_type = SD_INTERCONNECT_FABRIC;
7400                 un->un_node_type = DDI_NT_BLOCK_FABRIC;
7401                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7402                     "sd_unit_attach: un:0x%p SD_INTERCONNECT_FABRIC\n", un);
7403                 break;
7404         default:
7405 #ifdef SD_DEFAULT_INTERCONNECT_TYPE
7406                 /*
7407                  * The HBA does not support the "interconnect-type" property
7408                  * (or did not provide a recognized type).
7409                  *
7410                  * Note: This will be obsoleted when a single fibre channel
7411                  * and parallel scsi driver is delivered. In the meantime the
7412                  * interconnect type will be set to the platform default.If that
7413                  * type is not parallel SCSI, it means that we should be
7414                  * assuming "ssd" semantics. However, here this also means that
7415                  * the FC HBA is not supporting the "interconnect-type" property
7416                  * like we expect it to, so log this occurrence.
7417                  */
7418                 un->un_interconnect_type = SD_DEFAULT_INTERCONNECT_TYPE;
7419                 if (!SD_IS_PARALLEL_SCSI(un)) {
7420                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
7421                             "sd_unit_attach: un:0x%p Assuming "
7422                             "INTERCONNECT_FIBRE\n", un);
7423                 } else {
7424                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
7425                             "sd_unit_attach: un:0x%p Assuming "
7426                             "INTERCONNECT_PARALLEL\n", un);
7427                         un->un_f_is_fibre = FALSE;
7428                 }
7429 #else
7430                 /*
7431                  * Note: This source will be implemented when a single fibre
7432                  * channel and parallel scsi driver is delivered. The default
7433                  * will be to assume that if a device does not support the
7434                  * "interconnect-type" property it is a parallel SCSI HBA and
7435                  * we will set the interconnect type for parallel scsi.
7436                  */
7437                 un->un_interconnect_type = SD_INTERCONNECT_PARALLEL;
7438                 un->un_f_is_fibre = FALSE;
7439 #endif
7440                 break;
7441         }
7442 
7443         if (un->un_f_is_fibre == TRUE) {
7444                 if (scsi_ifgetcap(SD_ADDRESS(un), "scsi-version", 1) ==
7445                     SCSI_VERSION_3) {
7446                         switch (un->un_interconnect_type) {
7447                         case SD_INTERCONNECT_FIBRE:
7448                         case SD_INTERCONNECT_SSA:
7449                                 un->un_node_type = DDI_NT_BLOCK_WWN;
7450                                 break;
7451                         default:
7452                                 break;
7453                         }
7454                 }
7455         }
7456 
7457         /*
7458          * Initialize the Request Sense command for the target
7459          */
7460         if (sd_alloc_rqs(devp, un) != DDI_SUCCESS) {
7461                 goto alloc_rqs_failed;
7462         }
7463 
7464         /*
7465          * Set un_retry_count with SD_RETRY_COUNT, this is ok for Sparc
7466          * with separate binary for sd and ssd.
7467          *
7468          * x86 has 1 binary, un_retry_count is set base on connection type.
7469          * The hardcoded values will go away when Sparc uses 1 binary
7470          * for sd and ssd.  This hardcoded values need to match
7471          * SD_RETRY_COUNT in sddef.h
7472          * The value used is base on interconnect type.
7473          * fibre = 3, parallel = 5
7474          */
7475 #if defined(__i386) || defined(__amd64)
7476         un->un_retry_count = un->un_f_is_fibre ? 3 : 5;
7477 #else
7478         un->un_retry_count = SD_RETRY_COUNT;
7479 #endif
7480 
7481         /*
7482          * Set the per disk retry count to the default number of retries
7483          * for disks and CDROMs. This value can be overridden by the
7484          * disk property list or an entry in sd.conf.
7485          */
7486         un->un_notready_retry_count =
7487             ISCD(un) ? CD_NOT_READY_RETRY_COUNT(un)
7488             : DISK_NOT_READY_RETRY_COUNT(un);
7489 
7490         /*
7491          * Set the busy retry count to the default value of un_retry_count.
7492          * This can be overridden by entries in sd.conf or the device
7493          * config table.
7494          */
7495         un->un_busy_retry_count = un->un_retry_count;
7496 
7497         /*
7498          * Init the reset threshold for retries.  This number determines
7499          * how many retries must be performed before a reset can be issued
7500          * (for certain error conditions). This can be overridden by entries
7501          * in sd.conf or the device config table.
7502          */
7503         un->un_reset_retry_count = (un->un_retry_count / 2);
7504 
7505         /*
7506          * Set the victim_retry_count to the default un_retry_count
7507          */
7508         un->un_victim_retry_count = (2 * un->un_retry_count);
7509 
7510         /*
7511          * Set the reservation release timeout to the default value of
7512          * 5 seconds. This can be overridden by entries in ssd.conf or the
7513          * device config table.
7514          */
7515         un->un_reserve_release_time = 5;
7516 
7517         /*
7518          * Set up the default maximum transfer size. Note that this may
7519          * get updated later in the attach, when setting up default wide
7520          * operations for disks.
7521          */
7522 #if defined(__i386) || defined(__amd64)
7523         un->un_max_xfer_size = (uint_t)SD_DEFAULT_MAX_XFER_SIZE;
7524         un->un_partial_dma_supported = 1;
7525 #else
7526         un->un_max_xfer_size = (uint_t)maxphys;
7527 #endif
7528 
7529         /*
7530          * Get "allow bus device reset" property (defaults to "enabled" if
7531          * the property was not defined). This is to disable bus resets for
7532          * certain kinds of error recovery. Note: In the future when a run-time
7533          * fibre check is available the soft state flag should default to
7534          * enabled.
7535          */
7536         if (un->un_f_is_fibre == TRUE) {
7537                 un->un_f_allow_bus_device_reset = TRUE;
7538         } else {
7539                 if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
7540                     "allow-bus-device-reset", 1) != 0) {
7541                         un->un_f_allow_bus_device_reset = TRUE;
7542                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
7543                             "sd_unit_attach: un:0x%p Bus device reset "
7544                             "enabled\n", un);
7545                 } else {
7546                         un->un_f_allow_bus_device_reset = FALSE;
7547                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
7548                             "sd_unit_attach: un:0x%p Bus device reset "
7549                             "disabled\n", un);
7550                 }
7551         }
7552 
7553         /*
7554          * Check if this is an ATAPI device. ATAPI devices use Group 1
7555          * Read/Write commands and Group 2 Mode Sense/Select commands.
7556          *
7557          * Note: The "obsolete" way of doing this is to check for the "atapi"
7558          * property. The new "variant" property with a value of "atapi" has been
7559          * introduced so that future 'variants' of standard SCSI behavior (like
7560          * atapi) could be specified by the underlying HBA drivers by supplying
7561          * a new value for the "variant" property, instead of having to define a
7562          * new property.
7563          */
7564         if (ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0, "atapi", -1) != -1) {
7565                 un->un_f_cfg_is_atapi = TRUE;
7566                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7567                     "sd_unit_attach: un:0x%p Atapi device\n", un);
7568         }
7569         if (ddi_prop_lookup_string(DDI_DEV_T_ANY, devi, 0, "variant",
7570             &variantp) == DDI_PROP_SUCCESS) {
7571                 if (strcmp(variantp, "atapi") == 0) {
7572                         un->un_f_cfg_is_atapi = TRUE;
7573                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
7574                             "sd_unit_attach: un:0x%p Atapi device\n", un);
7575                 }
7576                 ddi_prop_free(variantp);
7577         }
7578 
7579         un->un_cmd_timeout   = SD_IO_TIME;
7580 
7581         un->un_busy_timeout  = SD_BSY_TIMEOUT;
7582 
7583         /* Info on current states, statuses, etc. (Updated frequently) */
7584         un->un_state         = SD_STATE_NORMAL;
7585         un->un_last_state    = SD_STATE_NORMAL;
7586 
7587         /* Control & status info for command throttling */
7588         un->un_throttle              = sd_max_throttle;
7589         un->un_saved_throttle        = sd_max_throttle;
7590         un->un_min_throttle  = sd_min_throttle;
7591 
7592         if (un->un_f_is_fibre == TRUE) {
7593                 un->un_f_use_adaptive_throttle = TRUE;
7594         } else {
7595                 un->un_f_use_adaptive_throttle = FALSE;
7596         }
7597 
7598         /* Removable media support. */
7599         cv_init(&un->un_state_cv, NULL, CV_DRIVER, NULL);
7600         un->un_mediastate            = DKIO_NONE;
7601         un->un_specified_mediastate  = DKIO_NONE;
7602 
7603         /* CVs for suspend/resume (PM or DR) */
7604         cv_init(&un->un_suspend_cv,   NULL, CV_DRIVER, NULL);
7605         cv_init(&un->un_disk_busy_cv, NULL, CV_DRIVER, NULL);
7606 
7607         /* Power management support. */
7608         un->un_power_level = SD_SPINDLE_UNINIT;
7609 
7610         cv_init(&un->un_wcc_cv,   NULL, CV_DRIVER, NULL);
7611         un->un_f_wcc_inprog = 0;
7612 
7613         /*
7614          * The open/close semaphore is used to serialize threads executing
7615          * in the driver's open & close entry point routines for a given
7616          * instance.
7617          */
7618         (void) sema_init(&un->un_semoclose, 1, NULL, SEMA_DRIVER, NULL);
7619 
7620         /*
7621          * The conf file entry and softstate variable is a forceful override,
7622          * meaning a non-zero value must be entered to change the default.
7623          */
7624         un->un_f_disksort_disabled = FALSE;
7625         un->un_f_rmw_type = SD_RMW_TYPE_DEFAULT;
7626         un->un_f_enable_rmw = FALSE;
7627 
7628         /*
7629          * GET EVENT STATUS NOTIFICATION media polling enabled by default, but
7630          * can be overridden via [s]sd-config-list "mmc-gesn-polling" property.
7631          */
7632         un->un_f_mmc_gesn_polling = TRUE;
7633 
7634         /*
7635          * physical sector size defaults to DEV_BSIZE currently. We can
7636          * override this value via the driver configuration file so we must
7637          * set it before calling sd_read_unit_properties().
7638          */
7639         un->un_phy_blocksize = DEV_BSIZE;
7640 
7641         /*
7642          * Retrieve the properties from the static driver table or the driver
7643          * configuration file (.conf) for this unit and update the soft state
7644          * for the device as needed for the indicated properties.
7645          * Note: the property configuration needs to occur here as some of the
7646          * following routines may have dependencies on soft state flags set
7647          * as part of the driver property configuration.
7648          */
7649         sd_read_unit_properties(un);
7650         SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7651             "sd_unit_attach: un:0x%p property configuration complete.\n", un);
7652 
7653         /*
7654          * Only if a device has "hotpluggable" property, it is
7655          * treated as hotpluggable device. Otherwise, it is
7656          * regarded as non-hotpluggable one.
7657          */
7658         if (ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0, "hotpluggable",
7659             -1) != -1) {
7660                 un->un_f_is_hotpluggable = TRUE;
7661         }
7662 
7663         /*
7664          * set unit's attributes(flags) according to "hotpluggable" and
7665          * RMB bit in INQUIRY data.
7666          */
7667         sd_set_unit_attributes(un, devi);
7668 
7669         /*
7670          * By default, we mark the capacity, lbasize, and geometry
7671          * as invalid. Only if we successfully read a valid capacity
7672          * will we update the un_blockcount and un_tgt_blocksize with the
7673          * valid values (the geometry will be validated later).
7674          */
7675         un->un_f_blockcount_is_valid = FALSE;
7676         un->un_f_tgt_blocksize_is_valid      = FALSE;
7677 
7678         /*
7679          * Use DEV_BSIZE and DEV_BSHIFT as defaults, until we can determine
7680          * otherwise.
7681          */
7682         un->un_tgt_blocksize  = un->un_sys_blocksize  = DEV_BSIZE;
7683         un->un_blockcount = 0;
7684 
7685         /*
7686          * Set up the per-instance info needed to determine the correct
7687          * CDBs and other info for issuing commands to the target.
7688          */
7689         sd_init_cdb_limits(un);
7690 
7691         /*
7692          * Set up the IO chains to use, based upon the target type.
7693          */
7694         if (un->un_f_non_devbsize_supported) {
7695                 un->un_buf_chain_type = SD_CHAIN_INFO_RMMEDIA;
7696         } else {
7697                 un->un_buf_chain_type = SD_CHAIN_INFO_DISK;
7698         }
7699         un->un_uscsi_chain_type  = SD_CHAIN_INFO_USCSI_CMD;
7700         un->un_direct_chain_type = SD_CHAIN_INFO_DIRECT_CMD;
7701         un->un_priority_chain_type = SD_CHAIN_INFO_PRIORITY_CMD;
7702 
7703         un->un_xbuf_attr = ddi_xbuf_attr_create(sizeof (struct sd_xbuf),
7704             sd_xbuf_strategy, un, sd_xbuf_active_limit,  sd_xbuf_reserve_limit,
7705             ddi_driver_major(devi), DDI_XBUF_QTHREAD_DRIVER);
7706         ddi_xbuf_attr_register_devinfo(un->un_xbuf_attr, devi);
7707 
7708 
7709         if (ISCD(un)) {
7710                 un->un_additional_codes = sd_additional_codes;
7711         } else {
7712                 un->un_additional_codes = NULL;
7713         }
7714 
7715         /*
7716          * Create the kstats here so they can be available for attach-time
7717          * routines that send commands to the unit (either polled or via
7718          * sd_send_scsi_cmd).
7719          *
7720          * Note: This is a critical sequence that needs to be maintained:
7721          *      1) Instantiate the kstats here, before any routines using the
7722          *         iopath (i.e. sd_send_scsi_cmd).
7723          *      2) Instantiate and initialize the partition stats
7724          *         (sd_set_pstats).
7725          *      3) Initialize the error stats (sd_set_errstats), following
7726          *         sd_validate_geometry(),sd_register_devid(),
7727          *         and sd_cache_control().
7728          */
7729 
7730         un->un_stats = kstat_create(sd_label, instance,
7731             NULL, "disk", KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT);
7732         if (un->un_stats != NULL) {
7733                 un->un_stats->ks_lock = SD_MUTEX(un);
7734                 kstat_install(un->un_stats);
7735         }
7736         SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7737             "sd_unit_attach: un:0x%p un_stats created\n", un);
7738 
7739         sd_create_errstats(un, instance);
7740         if (un->un_errstats == NULL) {
7741                 goto create_errstats_failed;
7742         }
7743         SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7744             "sd_unit_attach: un:0x%p errstats created\n", un);
7745 
7746         /*
7747          * The following if/else code was relocated here from below as part
7748          * of the fix for bug (4430280). However with the default setup added
7749          * on entry to this routine, it's no longer absolutely necessary for
7750          * this to be before the call to sd_spin_up_unit.
7751          */
7752         if (SD_IS_PARALLEL_SCSI(un) || SD_IS_SERIAL(un)) {
7753                 int tq_trigger_flag = (((devp->sd_inq->inq_ansi == 4) ||
7754                     (devp->sd_inq->inq_ansi == 5)) &&
7755                     devp->sd_inq->inq_bque) || devp->sd_inq->inq_cmdque;
7756 
7757                 /*
7758                  * If tagged queueing is supported by the target
7759                  * and by the host adapter then we will enable it
7760                  */
7761                 un->un_tagflags = 0;
7762                 if ((devp->sd_inq->inq_rdf == RDF_SCSI2) && tq_trigger_flag &&
7763                     (un->un_f_arq_enabled == TRUE)) {
7764                         if (scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing",
7765                             1, 1) == 1) {
7766                                 un->un_tagflags = FLAG_STAG;
7767                                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7768                                     "sd_unit_attach: un:0x%p tag queueing "
7769                                     "enabled\n", un);
7770                         } else if (scsi_ifgetcap(SD_ADDRESS(un),
7771                             "untagged-qing", 0) == 1) {
7772                                 un->un_f_opt_queueing = TRUE;
7773                                 un->un_saved_throttle = un->un_throttle =
7774                                     min(un->un_throttle, 3);
7775                         } else {
7776                                 un->un_f_opt_queueing = FALSE;
7777                                 un->un_saved_throttle = un->un_throttle = 1;
7778                         }
7779                 } else if ((scsi_ifgetcap(SD_ADDRESS(un), "untagged-qing", 0)
7780                     == 1) && (un->un_f_arq_enabled == TRUE)) {
7781                         /* The Host Adapter supports internal queueing. */
7782                         un->un_f_opt_queueing = TRUE;
7783                         un->un_saved_throttle = un->un_throttle =
7784                             min(un->un_throttle, 3);
7785                 } else {
7786                         un->un_f_opt_queueing = FALSE;
7787                         un->un_saved_throttle = un->un_throttle = 1;
7788                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
7789                             "sd_unit_attach: un:0x%p no tag queueing\n", un);
7790                 }
7791 
7792                 /*
7793                  * Enable large transfers for SATA/SAS drives
7794                  */
7795                 if (SD_IS_SERIAL(un)) {
7796                         un->un_max_xfer_size =
7797                             ddi_getprop(DDI_DEV_T_ANY, devi, 0,
7798                             sd_max_xfer_size, SD_MAX_XFER_SIZE);
7799                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
7800                             "sd_unit_attach: un:0x%p max transfer "
7801                             "size=0x%x\n", un, un->un_max_xfer_size);
7802 
7803                 }
7804 
7805                 /* Setup or tear down default wide operations for disks */
7806 
7807                 /*
7808                  * Note: Legacy: it may be possible for both "sd_max_xfer_size"
7809                  * and "ssd_max_xfer_size" to exist simultaneously on the same
7810                  * system and be set to different values. In the future this
7811                  * code may need to be updated when the ssd module is
7812                  * obsoleted and removed from the system. (4299588)
7813                  */
7814                 if (SD_IS_PARALLEL_SCSI(un) &&
7815                     (devp->sd_inq->inq_rdf == RDF_SCSI2) &&
7816                     (devp->sd_inq->inq_wbus16 || devp->sd_inq->inq_wbus32)) {
7817                         if (scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer",
7818                             1, 1) == 1) {
7819                                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7820                                     "sd_unit_attach: un:0x%p Wide Transfer "
7821                                     "enabled\n", un);
7822                         }
7823 
7824                         /*
7825                          * If tagged queuing has also been enabled, then
7826                          * enable large xfers
7827                          */
7828                         if (un->un_saved_throttle == sd_max_throttle) {
7829                                 un->un_max_xfer_size =
7830                                     ddi_getprop(DDI_DEV_T_ANY, devi, 0,
7831                                     sd_max_xfer_size, SD_MAX_XFER_SIZE);
7832                                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7833                                     "sd_unit_attach: un:0x%p max transfer "
7834                                     "size=0x%x\n", un, un->un_max_xfer_size);
7835                         }
7836                 } else {
7837                         if (scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer",
7838                             0, 1) == 1) {
7839                                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
7840                                     "sd_unit_attach: un:0x%p "
7841                                     "Wide Transfer disabled\n", un);
7842                         }
7843                 }
7844         } else {
7845                 un->un_tagflags = FLAG_STAG;
7846                 un->un_max_xfer_size = ddi_getprop(DDI_DEV_T_ANY,
7847                     devi, 0, sd_max_xfer_size, SD_MAX_XFER_SIZE);
7848         }
7849 
7850         /*
7851          * If this target supports LUN reset, try to enable it.
7852          */
7853         if (un->un_f_lun_reset_enabled) {
7854                 if (scsi_ifsetcap(SD_ADDRESS(un), "lun-reset", 1, 1) == 1) {
7855                         SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_unit_attach: "
7856                             "un:0x%p lun_reset capability set\n", un);
7857                 } else {
7858                         SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_unit_attach: "
7859                             "un:0x%p lun-reset capability not set\n", un);
7860                 }
7861         }
7862 
7863         /*
7864          * Adjust the maximum transfer size. This is to fix
7865          * the problem of partial DMA support on SPARC. Some
7866          * HBA driver, like aac, has very small dma_attr_maxxfer
7867          * size, which requires partial DMA support on SPARC.
7868          * In the future the SPARC pci nexus driver may solve
7869          * the problem instead of this fix.
7870          */
7871         max_xfer_size = scsi_ifgetcap(SD_ADDRESS(un), "dma-max", 1);
7872         if ((max_xfer_size > 0) && (max_xfer_size < un->un_max_xfer_size)) {
7873                 /* We need DMA partial even on sparc to ensure sddump() works */
7874                 un->un_max_xfer_size = max_xfer_size;
7875                 if (un->un_partial_dma_supported == 0)
7876                         un->un_partial_dma_supported = 1;
7877         }
7878         if (ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
7879             DDI_PROP_DONTPASS, "buf_break", 0) == 1) {
7880                 if (ddi_xbuf_attr_setup_brk(un->un_xbuf_attr,
7881                     un->un_max_xfer_size) == 1) {
7882                         un->un_buf_breakup_supported = 1;
7883                         SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_unit_attach: "
7884                             "un:0x%p Buf breakup enabled\n", un);
7885                 }
7886         }
7887 
7888         /*
7889          * Set PKT_DMA_PARTIAL flag.
7890          */
7891         if (un->un_partial_dma_supported == 1) {
7892                 un->un_pkt_flags = PKT_DMA_PARTIAL;
7893         } else {
7894                 un->un_pkt_flags = 0;
7895         }
7896 
7897         /* Initialize sd_ssc_t for internal uscsi commands */
7898         ssc = sd_ssc_init(un);
7899         scsi_fm_init(devp);
7900 
7901         /*
7902          * Allocate memory for SCSI FMA stuffs.
7903          */
7904         un->un_fm_private =
7905             kmem_zalloc(sizeof (struct sd_fm_internal), KM_SLEEP);
7906         sfip = (struct sd_fm_internal *)un->un_fm_private;
7907         sfip->fm_ssc.ssc_uscsi_cmd = &sfip->fm_ucmd;
7908         sfip->fm_ssc.ssc_uscsi_info = &sfip->fm_uinfo;
7909         sfip->fm_ssc.ssc_un = un;
7910 
7911         if (ISCD(un) ||
7912             un->un_f_has_removable_media ||
7913             devp->sd_fm_capable == DDI_FM_NOT_CAPABLE) {
7914                 /*
7915                  * We don't touch CDROM or the DDI_FM_NOT_CAPABLE device.
7916                  * Their log are unchanged.
7917                  */
7918                 sfip->fm_log_level = SD_FM_LOG_NSUP;
7919         } else {
7920                 /*
7921                  * If enter here, it should be non-CDROM and FM-capable
7922                  * device, and it will not keep the old scsi_log as before
7923                  * in /var/adm/messages. However, the property
7924                  * "fm-scsi-log" will control whether the FM telemetry will
7925                  * be logged in /var/adm/messages.
7926                  */
7927                 int fm_scsi_log;
7928                 fm_scsi_log = ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
7929                     DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "fm-scsi-log", 0);
7930 
7931                 if (fm_scsi_log)
7932                         sfip->fm_log_level = SD_FM_LOG_EREPORT;
7933                 else
7934                         sfip->fm_log_level = SD_FM_LOG_SILENT;
7935         }
7936 
7937         /*
7938          * At this point in the attach, we have enough info in the
7939          * soft state to be able to issue commands to the target.
7940          *
7941          * All command paths used below MUST issue their commands as
7942          * SD_PATH_DIRECT. This is important as intermediate layers
7943          * are not all initialized yet (such as PM).
7944          */
7945 
7946         /*
7947          * Send a TEST UNIT READY command to the device. This should clear
7948          * any outstanding UNIT ATTENTION that may be present.
7949          *
7950          * Note: Don't check for success, just track if there is a reservation,
7951          * this is a throw away command to clear any unit attentions.
7952          *
7953          * Note: This MUST be the first command issued to the target during
7954          * attach to ensure power on UNIT ATTENTIONS are cleared.
7955          * Pass in flag SD_DONT_RETRY_TUR to prevent the long delays associated
7956          * with attempts at spinning up a device with no media.
7957          */
7958         status = sd_send_scsi_TEST_UNIT_READY(ssc, SD_DONT_RETRY_TUR);
7959         if (status != 0) {
7960                 if (status == EACCES)
7961                         reservation_flag = SD_TARGET_IS_RESERVED;
7962                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
7963         }
7964 
7965         /*
7966          * If the device is NOT a removable media device, attempt to spin
7967          * it up (using the START_STOP_UNIT command) and read its capacity
7968          * (using the READ CAPACITY command).  Note, however, that either
7969          * of these could fail and in some cases we would continue with
7970          * the attach despite the failure (see below).
7971          */
7972         if (un->un_f_descr_format_supported) {
7973 
7974                 switch (sd_spin_up_unit(ssc)) {
7975                 case 0:
7976                         /*
7977                          * Spin-up was successful; now try to read the
7978                          * capacity.  If successful then save the results
7979                          * and mark the capacity & lbasize as valid.
7980                          */
7981                         SD_TRACE(SD_LOG_ATTACH_DETACH, un,
7982                             "sd_unit_attach: un:0x%p spin-up successful\n", un);
7983 
7984                         status = sd_send_scsi_READ_CAPACITY(ssc, &capacity,
7985                             &lbasize, SD_PATH_DIRECT);
7986 
7987                         switch (status) {
7988                         case 0: {
7989                                 if (capacity > DK_MAX_BLOCKS) {
7990 #ifdef _LP64
7991                                         if ((capacity + 1) >
7992                                             SD_GROUP1_MAX_ADDRESS) {
7993                                                 /*
7994                                                  * Enable descriptor format
7995                                                  * sense data so that we can
7996                                                  * get 64 bit sense data
7997                                                  * fields.
7998                                                  */
7999                                                 sd_enable_descr_sense(ssc);
8000                                         }
8001 #else
8002                                         /* 32-bit kernels can't handle this */
8003                                         scsi_log(SD_DEVINFO(un),
8004                                             sd_label, CE_WARN,
8005                                             "disk has %llu blocks, which "
8006                                             "is too large for a 32-bit "
8007                                             "kernel", capacity);
8008 
8009 #if defined(__i386) || defined(__amd64)
8010                                         /*
8011                                          * 1TB disk was treated as (1T - 512)B
8012                                          * in the past, so that it might have
8013                                          * valid VTOC and solaris partitions,
8014                                          * we have to allow it to continue to
8015                                          * work.
8016                                          */
8017                                         if (capacity -1 > DK_MAX_BLOCKS)
8018 #endif
8019                                         goto spinup_failed;
8020 #endif
8021                                 }
8022 
8023                                 /*
8024                                  * Here it's not necessary to check the case:
8025                                  * the capacity of the device is bigger than
8026                                  * what the max hba cdb can support. Because
8027                                  * sd_send_scsi_READ_CAPACITY will retrieve
8028                                  * the capacity by sending USCSI command, which
8029                                  * is constrained by the max hba cdb. Actually,
8030                                  * sd_send_scsi_READ_CAPACITY will return
8031                                  * EINVAL when using bigger cdb than required
8032                                  * cdb length. Will handle this case in
8033                                  * "case EINVAL".
8034                                  */
8035 
8036                                 /*
8037                                  * The following relies on
8038                                  * sd_send_scsi_READ_CAPACITY never
8039                                  * returning 0 for capacity and/or lbasize.
8040                                  */
8041                                 sd_update_block_info(un, lbasize, capacity);
8042 
8043                                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8044                                     "sd_unit_attach: un:0x%p capacity = %ld "
8045                                     "blocks; lbasize= %ld.\n", un,
8046                                     un->un_blockcount, un->un_tgt_blocksize);
8047 
8048                                 break;
8049                         }
8050                         case EINVAL:
8051                                 /*
8052                                  * In the case where the max-cdb-length property
8053                                  * is smaller than the required CDB length for
8054                                  * a SCSI device, a target driver can fail to
8055                                  * attach to that device.
8056                                  */
8057                                 scsi_log(SD_DEVINFO(un),
8058                                     sd_label, CE_WARN,
8059                                     "disk capacity is too large "
8060                                     "for current cdb length");
8061                                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
8062 
8063                                 goto spinup_failed;
8064                         case EACCES:
8065                                 /*
8066                                  * Should never get here if the spin-up
8067                                  * succeeded, but code it in anyway.
8068                                  * From here, just continue with the attach...
8069                                  */
8070                                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8071                                     "sd_unit_attach: un:0x%p "
8072                                     "sd_send_scsi_READ_CAPACITY "
8073                                     "returned reservation conflict\n", un);
8074                                 reservation_flag = SD_TARGET_IS_RESERVED;
8075                                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
8076                                 break;
8077                         default:
8078                                 /*
8079                                  * Likewise, should never get here if the
8080                                  * spin-up succeeded. Just continue with
8081                                  * the attach...
8082                                  */
8083                                 if (status == EIO)
8084                                         sd_ssc_assessment(ssc,
8085                                             SD_FMT_STATUS_CHECK);
8086                                 else
8087                                         sd_ssc_assessment(ssc,
8088                                             SD_FMT_IGNORE);
8089                                 break;
8090                         }
8091                         break;
8092                 case EACCES:
8093                         /*
8094                          * Device is reserved by another host.  In this case
8095                          * we could not spin it up or read the capacity, but
8096                          * we continue with the attach anyway.
8097                          */
8098                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
8099                             "sd_unit_attach: un:0x%p spin-up reservation "
8100                             "conflict.\n", un);
8101                         reservation_flag = SD_TARGET_IS_RESERVED;
8102                         break;
8103                 default:
8104                         /* Fail the attach if the spin-up failed. */
8105                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
8106                             "sd_unit_attach: un:0x%p spin-up failed.", un);
8107                         goto spinup_failed;
8108                 }
8109 
8110         }
8111 
8112         /*
8113          * Check to see if this is a MMC drive
8114          */
8115         if (ISCD(un)) {
8116                 sd_set_mmc_caps(ssc);
8117         }
8118 
8119         /*
8120          * Add a zero-length attribute to tell the world we support
8121          * kernel ioctls (for layered drivers)
8122          */
8123         (void) ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP,
8124             DDI_KERNEL_IOCTL, NULL, 0);
8125 
8126         /*
8127          * Add a boolean property to tell the world we support
8128          * the B_FAILFAST flag (for layered drivers)
8129          */
8130         (void) ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP,
8131             "ddi-failfast-supported", NULL, 0);
8132 
8133         /*
8134          * Initialize power management
8135          */
8136         mutex_init(&un->un_pm_mutex, NULL, MUTEX_DRIVER, NULL);
8137         cv_init(&un->un_pm_busy_cv, NULL, CV_DRIVER, NULL);
8138         sd_setup_pm(ssc, devi);
8139         if (un->un_f_pm_is_enabled == FALSE) {
8140                 /*
8141                  * For performance, point to a jump table that does
8142                  * not include pm.
8143                  * The direct and priority chains don't change with PM.
8144                  *
8145                  * Note: this is currently done based on individual device
8146                  * capabilities. When an interface for determining system
8147                  * power enabled state becomes available, or when additional
8148                  * layers are added to the command chain, these values will
8149                  * have to be re-evaluated for correctness.
8150                  */
8151                 if (un->un_f_non_devbsize_supported) {
8152                         un->un_buf_chain_type = SD_CHAIN_INFO_RMMEDIA_NO_PM;
8153                 } else {
8154                         un->un_buf_chain_type = SD_CHAIN_INFO_DISK_NO_PM;
8155                 }
8156                 un->un_uscsi_chain_type  = SD_CHAIN_INFO_USCSI_CMD_NO_PM;
8157         }
8158 
8159         /*
8160          * This property is set to 0 by HA software to avoid retries
8161          * on a reserved disk. (The preferred property name is
8162          * "retry-on-reservation-conflict") (1189689)
8163          *
8164          * Note: The use of a global here can have unintended consequences. A
8165          * per instance variable is preferable to match the capabilities of
8166          * different underlying hba's (4402600)
8167          */
8168         sd_retry_on_reservation_conflict = ddi_getprop(DDI_DEV_T_ANY, devi,
8169             DDI_PROP_DONTPASS, "retry-on-reservation-conflict",
8170             sd_retry_on_reservation_conflict);
8171         if (sd_retry_on_reservation_conflict != 0) {
8172                 sd_retry_on_reservation_conflict = ddi_getprop(DDI_DEV_T_ANY,
8173                     devi, DDI_PROP_DONTPASS, sd_resv_conflict_name,
8174                     sd_retry_on_reservation_conflict);
8175         }
8176 
8177         /* Set up options for QFULL handling. */
8178         if ((rval = ddi_getprop(DDI_DEV_T_ANY, devi, 0,
8179             "qfull-retries", -1)) != -1) {
8180                 (void) scsi_ifsetcap(SD_ADDRESS(un), "qfull-retries",
8181                     rval, 1);
8182         }
8183         if ((rval = ddi_getprop(DDI_DEV_T_ANY, devi, 0,
8184             "qfull-retry-interval", -1)) != -1) {
8185                 (void) scsi_ifsetcap(SD_ADDRESS(un), "qfull-retry-interval",
8186                     rval, 1);
8187         }
8188 
8189         /*
8190          * This just prints a message that announces the existence of the
8191          * device. The message is always printed in the system logfile, but
8192          * only appears on the console if the system is booted with the
8193          * -v (verbose) argument.
8194          */
8195         ddi_report_dev(devi);
8196 
8197         un->un_mediastate = DKIO_NONE;
8198 
8199         /*
8200          * Check if this is a SSD(Solid State Drive).
8201          */
8202         sd_check_solid_state(ssc);
8203 
8204         /*
8205          * Check whether the drive is in emulation mode.
8206          */
8207         sd_check_emulation_mode(ssc);
8208 
8209         cmlb_alloc_handle(&un->un_cmlbhandle);
8210 
8211 #if defined(__i386) || defined(__amd64)
8212         /*
8213          * On x86, compensate for off-by-1 legacy error
8214          */
8215         if (!un->un_f_has_removable_media && !un->un_f_is_hotpluggable &&
8216             (lbasize == un->un_sys_blocksize))
8217                 offbyone = CMLB_OFF_BY_ONE;
8218 #endif
8219 
8220         if (cmlb_attach(devi, &sd_tgops, (int)devp->sd_inq->inq_dtype,
8221             VOID2BOOLEAN(un->un_f_has_removable_media != 0),
8222             VOID2BOOLEAN(un->un_f_is_hotpluggable != 0),
8223             un->un_node_type, offbyone, un->un_cmlbhandle,
8224             (void *)SD_PATH_DIRECT) != 0) {
8225                 goto cmlb_attach_failed;
8226         }
8227 
8228 
8229         /*
8230          * Read and validate the device's geometry (ie, disk label)
8231          * A new unformatted drive will not have a valid geometry, but
8232          * the driver needs to successfully attach to this device so
8233          * the drive can be formatted via ioctls.
8234          */
8235         geom_label_valid = (cmlb_validate(un->un_cmlbhandle, 0,
8236             (void *)SD_PATH_DIRECT) == 0) ? 1: 0;
8237 
8238         mutex_enter(SD_MUTEX(un));
8239 
8240         /*
8241          * Read and initialize the devid for the unit.
8242          */
8243         if (un->un_f_devid_supported) {
8244                 sd_register_devid(ssc, devi, reservation_flag);
8245         }
8246         mutex_exit(SD_MUTEX(un));
8247 
8248 #if (defined(__fibre))
8249         /*
8250          * Register callbacks for fibre only.  You can't do this solely
8251          * on the basis of the devid_type because this is hba specific.
8252          * We need to query our hba capabilities to find out whether to
8253          * register or not.
8254          */
8255         if (un->un_f_is_fibre) {
8256                 if (strcmp(un->un_node_type, DDI_NT_BLOCK_CHAN)) {
8257                         sd_init_event_callbacks(un);
8258                         SD_TRACE(SD_LOG_ATTACH_DETACH, un,
8259                             "sd_unit_attach: un:0x%p event callbacks inserted",
8260                             un);
8261                 }
8262         }
8263 #endif
8264 
8265         if (un->un_f_opt_disable_cache == TRUE) {
8266                 /*
8267                  * Disable both read cache and write cache.  This is
8268                  * the historic behavior of the keywords in the config file.
8269                  */
8270                 if (sd_cache_control(ssc, SD_CACHE_DISABLE, SD_CACHE_DISABLE) !=
8271                     0) {
8272                         SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8273                             "sd_unit_attach: un:0x%p Could not disable "
8274                             "caching", un);
8275                         goto devid_failed;
8276                 }
8277         }
8278 
8279         /*
8280          * Check the value of the WCE bit now and
8281          * set un_f_write_cache_enabled accordingly.
8282          */
8283         (void) sd_get_write_cache_enabled(ssc, &wc_enabled);
8284         mutex_enter(SD_MUTEX(un));
8285         un->un_f_write_cache_enabled = (wc_enabled != 0);
8286         mutex_exit(SD_MUTEX(un));
8287 
8288         if ((un->un_f_rmw_type != SD_RMW_TYPE_RETURN_ERROR &&
8289             un->un_tgt_blocksize != DEV_BSIZE) ||
8290             un->un_f_enable_rmw) {
8291                 if (!(un->un_wm_cache)) {
8292                         (void) snprintf(name_str, sizeof (name_str),
8293                             "%s%d_cache",
8294                             ddi_driver_name(SD_DEVINFO(un)),
8295                             ddi_get_instance(SD_DEVINFO(un)));
8296                         un->un_wm_cache = kmem_cache_create(
8297                             name_str, sizeof (struct sd_w_map),
8298                             8, sd_wm_cache_constructor,
8299                             sd_wm_cache_destructor, NULL,
8300                             (void *)un, NULL, 0);
8301                         if (!(un->un_wm_cache)) {
8302                                 goto wm_cache_failed;
8303                         }
8304                 }
8305         }
8306 
8307         /*
8308          * Check the value of the NV_SUP bit and set
8309          * un_f_suppress_cache_flush accordingly.
8310          */
8311         sd_get_nv_sup(ssc);
8312 
8313         /*
8314          * Find out what type of reservation this disk supports.
8315          */
8316         status = sd_send_scsi_PERSISTENT_RESERVE_IN(ssc, SD_READ_KEYS, 0, NULL);
8317 
8318         switch (status) {
8319         case 0:
8320                 /*
8321                  * SCSI-3 reservations are supported.
8322                  */
8323                 un->un_reservation_type = SD_SCSI3_RESERVATION;
8324                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8325                     "sd_unit_attach: un:0x%p SCSI-3 reservations\n", un);
8326                 break;
8327         case ENOTSUP:
8328                 /*
8329                  * The PERSISTENT RESERVE IN command would not be recognized by
8330                  * a SCSI-2 device, so assume the reservation type is SCSI-2.
8331                  */
8332                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8333                     "sd_unit_attach: un:0x%p SCSI-2 reservations\n", un);
8334                 un->un_reservation_type = SD_SCSI2_RESERVATION;
8335 
8336                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
8337                 break;
8338         default:
8339                 /*
8340                  * default to SCSI-3 reservations
8341                  */
8342                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
8343                     "sd_unit_attach: un:0x%p default SCSI3 reservations\n", un);
8344                 un->un_reservation_type = SD_SCSI3_RESERVATION;
8345 
8346                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
8347                 break;
8348         }
8349 
8350         /*
8351          * Set the pstat and error stat values here, so data obtained during the
8352          * previous attach-time routines is available.
8353          *
8354          * Note: This is a critical sequence that needs to be maintained:
8355          *      1) Instantiate the kstats before any routines using the iopath
8356          *         (i.e. sd_send_scsi_cmd).
8357          *      2) Initialize the error stats (sd_set_errstats) and partition
8358          *         stats (sd_set_pstats)here, following
8359          *         cmlb_validate_geometry(), sd_register_devid(), and
8360          *         sd_cache_control().
8361          */
8362 
8363         if (un->un_f_pkstats_enabled && geom_label_valid) {
8364                 sd_set_pstats(un);
8365                 SD_TRACE(SD_LOG_IO_PARTITION, un,
8366                     "sd_unit_attach: un:0x%p pstats created and set\n", un);
8367         }
8368 
8369         sd_set_errstats(un);
8370         SD_TRACE(SD_LOG_ATTACH_DETACH, un,
8371             "sd_unit_attach: un:0x%p errstats set\n", un);
8372 
8373 
8374         /*
8375          * After successfully attaching an instance, we record the information
8376          * of how many luns have been attached on the relative target and
8377          * controller for parallel SCSI. This information is used when sd tries
8378          * to set the tagged queuing capability in HBA.
8379          */
8380         if (SD_IS_PARALLEL_SCSI(un) && (tgt >= 0) && (tgt < NTARGETS_WIDE)) {
8381                 sd_scsi_update_lun_on_target(pdip, tgt, SD_SCSI_LUN_ATTACH);
8382         }
8383 
8384         SD_TRACE(SD_LOG_ATTACH_DETACH, un,
8385             "sd_unit_attach: un:0x%p exit success\n", un);
8386 
8387         /* Uninitialize sd_ssc_t pointer */
8388         sd_ssc_fini(ssc);
8389 
8390         return (DDI_SUCCESS);
8391 
8392         /*
8393          * An error occurred during the attach; clean up & return failure.
8394          */
8395 wm_cache_failed:
8396 devid_failed:
8397 
8398 setup_pm_failed:
8399         ddi_remove_minor_node(devi, NULL);
8400 
8401 cmlb_attach_failed:
8402         /*
8403          * Cleanup from the scsi_ifsetcap() calls (437868)
8404          */
8405         (void) scsi_ifsetcap(SD_ADDRESS(un), "lun-reset", 0, 1);
8406         (void) scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer", 0, 1);
8407 
8408         /*
8409          * Refer to the comments of setting tagged-qing in the beginning of
8410          * sd_unit_attach. We can only disable tagged queuing when there is
8411          * no lun attached on the target.
8412          */
8413         if (sd_scsi_get_target_lun_count(pdip, tgt) < 1) {
8414                 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
8415         }
8416 
8417         if (un->un_f_is_fibre == FALSE) {
8418                 (void) scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 0, 1);
8419         }
8420 
8421 spinup_failed:
8422 
8423         /* Uninitialize sd_ssc_t pointer */
8424         sd_ssc_fini(ssc);
8425 
8426         mutex_enter(SD_MUTEX(un));
8427 
8428         /* Deallocate SCSI FMA memory spaces */
8429         kmem_free(un->un_fm_private, sizeof (struct sd_fm_internal));
8430 
8431         /* Cancel callback for SD_PATH_DIRECT_PRIORITY cmd. restart */
8432         if (un->un_direct_priority_timeid != NULL) {
8433                 timeout_id_t temp_id = un->un_direct_priority_timeid;
8434                 un->un_direct_priority_timeid = NULL;
8435                 mutex_exit(SD_MUTEX(un));
8436                 (void) untimeout(temp_id);
8437                 mutex_enter(SD_MUTEX(un));
8438         }
8439 
8440         /* Cancel any pending start/stop timeouts */
8441         if (un->un_startstop_timeid != NULL) {
8442                 timeout_id_t temp_id = un->un_startstop_timeid;
8443                 un->un_startstop_timeid = NULL;
8444                 mutex_exit(SD_MUTEX(un));
8445                 (void) untimeout(temp_id);
8446                 mutex_enter(SD_MUTEX(un));
8447         }
8448 
8449         /* Cancel any pending reset-throttle timeouts */
8450         if (un->un_reset_throttle_timeid != NULL) {
8451                 timeout_id_t temp_id = un->un_reset_throttle_timeid;
8452                 un->un_reset_throttle_timeid = NULL;
8453                 mutex_exit(SD_MUTEX(un));
8454                 (void) untimeout(temp_id);
8455                 mutex_enter(SD_MUTEX(un));
8456         }
8457 
8458         /* Cancel rmw warning message timeouts */
8459         if (un->un_rmw_msg_timeid != NULL) {
8460                 timeout_id_t temp_id = un->un_rmw_msg_timeid;
8461                 un->un_rmw_msg_timeid = NULL;
8462                 mutex_exit(SD_MUTEX(un));
8463                 (void) untimeout(temp_id);
8464                 mutex_enter(SD_MUTEX(un));
8465         }
8466 
8467         /* Cancel any pending retry timeouts */
8468         if (un->un_retry_timeid != NULL) {
8469                 timeout_id_t temp_id = un->un_retry_timeid;
8470                 un->un_retry_timeid = NULL;
8471                 mutex_exit(SD_MUTEX(un));
8472                 (void) untimeout(temp_id);
8473                 mutex_enter(SD_MUTEX(un));
8474         }
8475 
8476         /* Cancel any pending delayed cv broadcast timeouts */
8477         if (un->un_dcvb_timeid != NULL) {
8478                 timeout_id_t temp_id = un->un_dcvb_timeid;
8479                 un->un_dcvb_timeid = NULL;
8480                 mutex_exit(SD_MUTEX(un));
8481                 (void) untimeout(temp_id);
8482                 mutex_enter(SD_MUTEX(un));
8483         }
8484 
8485         mutex_exit(SD_MUTEX(un));
8486 
8487         /* There should not be any in-progress I/O so ASSERT this check */
8488         ASSERT(un->un_ncmds_in_transport == 0);
8489         ASSERT(un->un_ncmds_in_driver == 0);
8490 
8491         /* Do not free the softstate if the callback routine is active */
8492         sd_sync_with_callback(un);
8493 
8494         /*
8495          * Partition stats apparently are not used with removables. These would
8496          * not have been created during attach, so no need to clean them up...
8497          */
8498         if (un->un_errstats != NULL) {
8499                 kstat_delete(un->un_errstats);
8500                 un->un_errstats = NULL;
8501         }
8502 
8503 create_errstats_failed:
8504 
8505         if (un->un_stats != NULL) {
8506                 kstat_delete(un->un_stats);
8507                 un->un_stats = NULL;
8508         }
8509 
8510         ddi_xbuf_attr_unregister_devinfo(un->un_xbuf_attr, devi);
8511         ddi_xbuf_attr_destroy(un->un_xbuf_attr);
8512 
8513         ddi_prop_remove_all(devi);
8514         sema_destroy(&un->un_semoclose);
8515         cv_destroy(&un->un_state_cv);
8516 
8517 getrbuf_failed:
8518 
8519         sd_free_rqs(un);
8520 
8521 alloc_rqs_failed:
8522 
8523         devp->sd_private = NULL;
8524         bzero(un, sizeof (struct sd_lun));      /* Clear any stale data! */
8525 
8526 get_softstate_failed:
8527         /*
8528          * Note: the man pages are unclear as to whether or not doing a
8529          * ddi_soft_state_free(sd_state, instance) is the right way to
8530          * clean up after the ddi_soft_state_zalloc() if the subsequent
8531          * ddi_get_soft_state() fails.  The implication seems to be
8532          * that the get_soft_state cannot fail if the zalloc succeeds.
8533          */
8534 #ifndef XPV_HVM_DRIVER
8535         ddi_soft_state_free(sd_state, instance);
8536 #endif /* !XPV_HVM_DRIVER */
8537 
8538 probe_failed:
8539         scsi_unprobe(devp);
8540 
8541         return (DDI_FAILURE);
8542 }
8543 
8544 
8545 /*
8546  *    Function: sd_unit_detach
8547  *
8548  * Description: Performs DDI_DETACH processing for sddetach().
8549  *
8550  * Return Code: DDI_SUCCESS
8551  *              DDI_FAILURE
8552  *
8553  *     Context: Kernel thread context
8554  */
8555 
8556 static int
8557 sd_unit_detach(dev_info_t *devi)
8558 {
8559         struct scsi_device      *devp;
8560         struct sd_lun           *un;
8561         int                     i;
8562         int                     tgt;
8563         dev_t                   dev;
8564         dev_info_t              *pdip = ddi_get_parent(devi);
8565 #ifndef XPV_HVM_DRIVER
8566         int                     instance = ddi_get_instance(devi);
8567 #endif /* !XPV_HVM_DRIVER */
8568 
8569         mutex_enter(&sd_detach_mutex);
8570 
8571         /*
8572          * Fail the detach for any of the following:
8573          *  - Unable to get the sd_lun struct for the instance
8574          *  - A layered driver has an outstanding open on the instance
8575          *  - Another thread is already detaching this instance
8576          *  - Another thread is currently performing an open
8577          */
8578         devp = ddi_get_driver_private(devi);
8579         if ((devp == NULL) ||
8580             ((un = (struct sd_lun *)devp->sd_private) == NULL) ||
8581             (un->un_ncmds_in_driver != 0) || (un->un_layer_count != 0) ||
8582             (un->un_detach_count != 0) || (un->un_opens_in_progress != 0)) {
8583                 mutex_exit(&sd_detach_mutex);
8584                 return (DDI_FAILURE);
8585         }
8586 
8587         SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_unit_detach: entry 0x%p\n", un);
8588 
8589         /*
8590          * Mark this instance as currently in a detach, to inhibit any
8591          * opens from a layered driver.
8592          */
8593         un->un_detach_count++;
8594         mutex_exit(&sd_detach_mutex);
8595 
8596         tgt = ddi_prop_get_int(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
8597             SCSI_ADDR_PROP_TARGET, -1);
8598 
8599         dev = sd_make_device(SD_DEVINFO(un));
8600 
8601 #ifndef lint
8602         _NOTE(COMPETING_THREADS_NOW);
8603 #endif
8604 
8605         mutex_enter(SD_MUTEX(un));
8606 
8607         /*
8608          * Fail the detach if there are any outstanding layered
8609          * opens on this device.
8610          */
8611         for (i = 0; i < NDKMAP; i++) {
8612                 if (un->un_ocmap.lyropen[i] != 0) {
8613                         goto err_notclosed;
8614                 }
8615         }
8616 
8617         /*
8618          * Verify there are NO outstanding commands issued to this device.
8619          * ie, un_ncmds_in_transport == 0.
8620          * It's possible to have outstanding commands through the physio
8621          * code path, even though everything's closed.
8622          */
8623         if ((un->un_ncmds_in_transport != 0) || (un->un_retry_timeid != NULL) ||
8624             (un->un_direct_priority_timeid != NULL) ||
8625             (un->un_state == SD_STATE_RWAIT)) {
8626                 mutex_exit(SD_MUTEX(un));
8627                 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8628                     "sd_dr_detach: Detach failure due to outstanding cmds\n");
8629                 goto err_stillbusy;
8630         }
8631 
8632         /*
8633          * If we have the device reserved, release the reservation.
8634          */
8635         if ((un->un_resvd_status & SD_RESERVE) &&
8636             !(un->un_resvd_status & SD_LOST_RESERVE)) {
8637                 mutex_exit(SD_MUTEX(un));
8638                 /*
8639                  * Note: sd_reserve_release sends a command to the device
8640                  * via the sd_ioctlcmd() path, and can sleep.
8641                  */
8642                 if (sd_reserve_release(dev, SD_RELEASE) != 0) {
8643                         SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8644                             "sd_dr_detach: Cannot release reservation \n");
8645                 }
8646         } else {
8647                 mutex_exit(SD_MUTEX(un));
8648         }
8649 
8650         /*
8651          * Untimeout any reserve recover, throttle reset, restart unit
8652          * and delayed broadcast timeout threads. Protect the timeout pointer
8653          * from getting nulled by their callback functions.
8654          */
8655         mutex_enter(SD_MUTEX(un));
8656         if (un->un_resvd_timeid != NULL) {
8657                 timeout_id_t temp_id = un->un_resvd_timeid;
8658                 un->un_resvd_timeid = NULL;
8659                 mutex_exit(SD_MUTEX(un));
8660                 (void) untimeout(temp_id);
8661                 mutex_enter(SD_MUTEX(un));
8662         }
8663 
8664         if (un->un_reset_throttle_timeid != NULL) {
8665                 timeout_id_t temp_id = un->un_reset_throttle_timeid;
8666                 un->un_reset_throttle_timeid = NULL;
8667                 mutex_exit(SD_MUTEX(un));
8668                 (void) untimeout(temp_id);
8669                 mutex_enter(SD_MUTEX(un));
8670         }
8671 
8672         if (un->un_startstop_timeid != NULL) {
8673                 timeout_id_t temp_id = un->un_startstop_timeid;
8674                 un->un_startstop_timeid = NULL;
8675                 mutex_exit(SD_MUTEX(un));
8676                 (void) untimeout(temp_id);
8677                 mutex_enter(SD_MUTEX(un));
8678         }
8679 
8680         if (un->un_rmw_msg_timeid != NULL) {
8681                 timeout_id_t temp_id = un->un_rmw_msg_timeid;
8682                 un->un_rmw_msg_timeid = NULL;
8683                 mutex_exit(SD_MUTEX(un));
8684                 (void) untimeout(temp_id);
8685                 mutex_enter(SD_MUTEX(un));
8686         }
8687 
8688         if (un->un_dcvb_timeid != NULL) {
8689                 timeout_id_t temp_id = un->un_dcvb_timeid;
8690                 un->un_dcvb_timeid = NULL;
8691                 mutex_exit(SD_MUTEX(un));
8692                 (void) untimeout(temp_id);
8693         } else {
8694                 mutex_exit(SD_MUTEX(un));
8695         }
8696 
8697         /* Remove any pending reservation reclaim requests for this device */
8698         sd_rmv_resv_reclaim_req(dev);
8699 
8700         mutex_enter(SD_MUTEX(un));
8701 
8702         /* Cancel any pending callbacks for SD_PATH_DIRECT_PRIORITY cmd. */
8703         if (un->un_direct_priority_timeid != NULL) {
8704                 timeout_id_t temp_id = un->un_direct_priority_timeid;
8705                 un->un_direct_priority_timeid = NULL;
8706                 mutex_exit(SD_MUTEX(un));
8707                 (void) untimeout(temp_id);
8708                 mutex_enter(SD_MUTEX(un));
8709         }
8710 
8711         /* Cancel any active multi-host disk watch thread requests */
8712         if (un->un_mhd_token != NULL) {
8713                 mutex_exit(SD_MUTEX(un));
8714                  _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_mhd_token));
8715                 if (scsi_watch_request_terminate(un->un_mhd_token,
8716                     SCSI_WATCH_TERMINATE_NOWAIT)) {
8717                         SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8718                             "sd_dr_detach: Cannot cancel mhd watch request\n");
8719                         /*
8720                          * Note: We are returning here after having removed
8721                          * some driver timeouts above. This is consistent with
8722                          * the legacy implementation but perhaps the watch
8723                          * terminate call should be made with the wait flag set.
8724                          */
8725                         goto err_stillbusy;
8726                 }
8727                 mutex_enter(SD_MUTEX(un));
8728                 un->un_mhd_token = NULL;
8729         }
8730 
8731         if (un->un_swr_token != NULL) {
8732                 mutex_exit(SD_MUTEX(un));
8733                 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_swr_token));
8734                 if (scsi_watch_request_terminate(un->un_swr_token,
8735                     SCSI_WATCH_TERMINATE_NOWAIT)) {
8736                         SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8737                             "sd_dr_detach: Cannot cancel swr watch request\n");
8738                         /*
8739                          * Note: We are returning here after having removed
8740                          * some driver timeouts above. This is consistent with
8741                          * the legacy implementation but perhaps the watch
8742                          * terminate call should be made with the wait flag set.
8743                          */
8744                         goto err_stillbusy;
8745                 }
8746                 mutex_enter(SD_MUTEX(un));
8747                 un->un_swr_token = NULL;
8748         }
8749 
8750         mutex_exit(SD_MUTEX(un));
8751 
8752         /*
8753          * Clear any scsi_reset_notifies. We clear the reset notifies
8754          * if we have not registered one.
8755          * Note: The sd_mhd_reset_notify_cb() fn tries to acquire SD_MUTEX!
8756          */
8757         (void) scsi_reset_notify(SD_ADDRESS(un), SCSI_RESET_CANCEL,
8758             sd_mhd_reset_notify_cb, (caddr_t)un);
8759 
8760         /*
8761          * protect the timeout pointers from getting nulled by
8762          * their callback functions during the cancellation process.
8763          * In such a scenario untimeout can be invoked with a null value.
8764          */
8765         _NOTE(NO_COMPETING_THREADS_NOW);
8766 
8767         mutex_enter(&un->un_pm_mutex);
8768         if (un->un_pm_idle_timeid != NULL) {
8769                 timeout_id_t temp_id = un->un_pm_idle_timeid;
8770                 un->un_pm_idle_timeid = NULL;
8771                 mutex_exit(&un->un_pm_mutex);
8772 
8773                 /*
8774                  * Timeout is active; cancel it.
8775                  * Note that it'll never be active on a device
8776                  * that does not support PM therefore we don't
8777                  * have to check before calling pm_idle_component.
8778                  */
8779                 (void) untimeout(temp_id);
8780                 (void) pm_idle_component(SD_DEVINFO(un), 0);
8781                 mutex_enter(&un->un_pm_mutex);
8782         }
8783 
8784         /*
8785          * Check whether there is already a timeout scheduled for power
8786          * management. If yes then don't lower the power here, that's.
8787          * the timeout handler's job.
8788          */
8789         if (un->un_pm_timeid != NULL) {
8790                 timeout_id_t temp_id = un->un_pm_timeid;
8791                 un->un_pm_timeid = NULL;
8792                 mutex_exit(&un->un_pm_mutex);
8793                 /*
8794                  * Timeout is active; cancel it.
8795                  * Note that it'll never be active on a device
8796                  * that does not support PM therefore we don't
8797                  * have to check before calling pm_idle_component.
8798                  */
8799                 (void) untimeout(temp_id);
8800                 (void) pm_idle_component(SD_DEVINFO(un), 0);
8801 
8802         } else {
8803                 mutex_exit(&un->un_pm_mutex);
8804                 if ((un->un_f_pm_is_enabled == TRUE) &&
8805                     (pm_lower_power(SD_DEVINFO(un), 0, SD_PM_STATE_STOPPED(un))
8806                     != DDI_SUCCESS)) {
8807                         SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8808                     "sd_dr_detach: Lower power request failed, ignoring.\n");
8809                         /*
8810                          * Fix for bug: 4297749, item # 13
8811                          * The above test now includes a check to see if PM is
8812                          * supported by this device before call
8813                          * pm_lower_power().
8814                          * Note, the following is not dead code. The call to
8815                          * pm_lower_power above will generate a call back into
8816                          * our sdpower routine which might result in a timeout
8817                          * handler getting activated. Therefore the following
8818                          * code is valid and necessary.
8819                          */
8820                         mutex_enter(&un->un_pm_mutex);
8821                         if (un->un_pm_timeid != NULL) {
8822                                 timeout_id_t temp_id = un->un_pm_timeid;
8823                                 un->un_pm_timeid = NULL;
8824                                 mutex_exit(&un->un_pm_mutex);
8825                                 (void) untimeout(temp_id);
8826                                 (void) pm_idle_component(SD_DEVINFO(un), 0);
8827                         } else {
8828                                 mutex_exit(&un->un_pm_mutex);
8829                         }
8830                 }
8831         }
8832 
8833         /*
8834          * Cleanup from the scsi_ifsetcap() calls (437868)
8835          * Relocated here from above to be after the call to
8836          * pm_lower_power, which was getting errors.
8837          */
8838         (void) scsi_ifsetcap(SD_ADDRESS(un), "lun-reset", 0, 1);
8839         (void) scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer", 0, 1);
8840 
8841         /*
8842          * Currently, tagged queuing is supported per target based by HBA.
8843          * Setting this per lun instance actually sets the capability of this
8844          * target in HBA, which affects those luns already attached on the
8845          * same target. So during detach, we can only disable this capability
8846          * only when this is the only lun left on this target. By doing
8847          * this, we assume a target has the same tagged queuing capability
8848          * for every lun. The condition can be removed when HBA is changed to
8849          * support per lun based tagged queuing capability.
8850          */
8851         if (sd_scsi_get_target_lun_count(pdip, tgt) <= 1) {
8852                 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
8853         }
8854 
8855         if (un->un_f_is_fibre == FALSE) {
8856                 (void) scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 0, 1);
8857         }
8858 
8859         /*
8860          * Remove any event callbacks, fibre only
8861          */
8862         if (un->un_f_is_fibre == TRUE) {
8863                 if ((un->un_insert_event != NULL) &&
8864                     (ddi_remove_event_handler(un->un_insert_cb_id) !=
8865                     DDI_SUCCESS)) {
8866                         /*
8867                          * Note: We are returning here after having done
8868                          * substantial cleanup above. This is consistent
8869                          * with the legacy implementation but this may not
8870                          * be the right thing to do.
8871                          */
8872                         SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8873                             "sd_dr_detach: Cannot cancel insert event\n");
8874                         goto err_remove_event;
8875                 }
8876                 un->un_insert_event = NULL;
8877 
8878                 if ((un->un_remove_event != NULL) &&
8879                     (ddi_remove_event_handler(un->un_remove_cb_id) !=
8880                     DDI_SUCCESS)) {
8881                         /*
8882                          * Note: We are returning here after having done
8883                          * substantial cleanup above. This is consistent
8884                          * with the legacy implementation but this may not
8885                          * be the right thing to do.
8886                          */
8887                         SD_ERROR(SD_LOG_ATTACH_DETACH, un,
8888                             "sd_dr_detach: Cannot cancel remove event\n");
8889                         goto err_remove_event;
8890                 }
8891                 un->un_remove_event = NULL;
8892         }
8893 
8894         /* Do not free the softstate if the callback routine is active */
8895         sd_sync_with_callback(un);
8896 
8897         cmlb_detach(un->un_cmlbhandle, (void *)SD_PATH_DIRECT);
8898         cmlb_free_handle(&un->un_cmlbhandle);
8899 
8900         /*
8901          * Hold the detach mutex here, to make sure that no other threads ever
8902          * can access a (partially) freed soft state structure.
8903          */
8904         mutex_enter(&sd_detach_mutex);
8905 
8906         /*
8907          * Clean up the soft state struct.
8908          * Cleanup is done in reverse order of allocs/inits.
8909          * At this point there should be no competing threads anymore.
8910          */
8911 
8912         scsi_fm_fini(devp);
8913 
8914         /*
8915          * Deallocate memory for SCSI FMA.
8916          */
8917         kmem_free(un->un_fm_private, sizeof (struct sd_fm_internal));
8918 
8919         /*
8920          * Unregister and free device id if it was not registered
8921          * by the transport.
8922          */
8923         if (un->un_f_devid_transport_defined == FALSE)
8924                 ddi_devid_unregister(devi);
8925 
8926         /*
8927          * free the devid structure if allocated before (by ddi_devid_init()
8928          * or ddi_devid_get()).
8929          */
8930         if (un->un_devid) {
8931                 ddi_devid_free(un->un_devid);
8932                 un->un_devid = NULL;
8933         }
8934 
8935         /*
8936          * Destroy wmap cache if it exists.
8937          */
8938         if (un->un_wm_cache != NULL) {
8939                 kmem_cache_destroy(un->un_wm_cache);
8940                 un->un_wm_cache = NULL;
8941         }
8942 
8943         /*
8944          * kstat cleanup is done in detach for all device types (4363169).
8945          * We do not want to fail detach if the device kstats are not deleted
8946          * since there is a confusion about the devo_refcnt for the device.
8947          * We just delete the kstats and let detach complete successfully.
8948          */
8949         if (un->un_stats != NULL) {
8950                 kstat_delete(un->un_stats);
8951                 un->un_stats = NULL;
8952         }
8953         if (un->un_errstats != NULL) {
8954                 kstat_delete(un->un_errstats);
8955                 un->un_errstats = NULL;
8956         }
8957 
8958         /* Remove partition stats */
8959         if (un->un_f_pkstats_enabled) {
8960                 for (i = 0; i < NSDMAP; i++) {
8961                         if (un->un_pstats[i] != NULL) {
8962                                 kstat_delete(un->un_pstats[i]);
8963                                 un->un_pstats[i] = NULL;
8964                         }
8965                 }
8966         }
8967 
8968         /* Remove xbuf registration */
8969         ddi_xbuf_attr_unregister_devinfo(un->un_xbuf_attr, devi);
8970         ddi_xbuf_attr_destroy(un->un_xbuf_attr);
8971 
8972         /* Remove driver properties */
8973         ddi_prop_remove_all(devi);
8974 
8975         mutex_destroy(&un->un_pm_mutex);
8976         cv_destroy(&un->un_pm_busy_cv);
8977 
8978         cv_destroy(&un->un_wcc_cv);
8979 
8980         /* Open/close semaphore */
8981         sema_destroy(&un->un_semoclose);
8982 
8983         /* Removable media condvar. */
8984         cv_destroy(&un->un_state_cv);
8985 
8986         /* Suspend/resume condvar. */
8987         cv_destroy(&un->un_suspend_cv);
8988         cv_destroy(&un->un_disk_busy_cv);
8989 
8990         sd_free_rqs(un);
8991 
8992         /* Free up soft state */
8993         devp->sd_private = NULL;
8994 
8995         bzero(un, sizeof (struct sd_lun));
8996 #ifndef XPV_HVM_DRIVER
8997         ddi_soft_state_free(sd_state, instance);
8998 #endif /* !XPV_HVM_DRIVER */
8999 
9000         mutex_exit(&sd_detach_mutex);
9001 
9002         /* This frees up the INQUIRY data associated with the device. */
9003         scsi_unprobe(devp);
9004 
9005         /*
9006          * After successfully detaching an instance, we update the information
9007          * of how many luns have been attached in the relative target and
9008          * controller for parallel SCSI. This information is used when sd tries
9009          * to set the tagged queuing capability in HBA.
9010          * Since un has been released, we can't use SD_IS_PARALLEL_SCSI(un) to
9011          * check if the device is parallel SCSI. However, we don't need to
9012          * check here because we've already checked during attach. No device
9013          * that is not parallel SCSI is in the chain.
9014          */
9015         if ((tgt >= 0) && (tgt < NTARGETS_WIDE)) {
9016                 sd_scsi_update_lun_on_target(pdip, tgt, SD_SCSI_LUN_DETACH);
9017         }
9018 
9019         return (DDI_SUCCESS);
9020 
9021 err_notclosed:
9022         mutex_exit(SD_MUTEX(un));
9023 
9024 err_stillbusy:
9025         _NOTE(NO_COMPETING_THREADS_NOW);
9026 
9027 err_remove_event:
9028         mutex_enter(&sd_detach_mutex);
9029         un->un_detach_count--;
9030         mutex_exit(&sd_detach_mutex);
9031 
9032         SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_unit_detach: exit failure\n");
9033         return (DDI_FAILURE);
9034 }
9035 
9036 
9037 /*
9038  *    Function: sd_create_errstats
9039  *
9040  * Description: This routine instantiates the device error stats.
9041  *
9042  *              Note: During attach the stats are instantiated first so they are
9043  *              available for attach-time routines that utilize the driver
9044  *              iopath to send commands to the device. The stats are initialized
9045  *              separately so data obtained during some attach-time routines is
9046  *              available. (4362483)
9047  *
9048  *   Arguments: un - driver soft state (unit) structure
9049  *              instance - driver instance
9050  *
9051  *     Context: Kernel thread context
9052  */
9053 
9054 static void
9055 sd_create_errstats(struct sd_lun *un, int instance)
9056 {
9057         struct  sd_errstats     *stp;
9058         char    kstatmodule_err[KSTAT_STRLEN];
9059         char    kstatname[KSTAT_STRLEN];
9060         int     ndata = (sizeof (struct sd_errstats) / sizeof (kstat_named_t));
9061 
9062         ASSERT(un != NULL);
9063 
9064         if (un->un_errstats != NULL) {
9065                 return;
9066         }
9067 
9068         (void) snprintf(kstatmodule_err, sizeof (kstatmodule_err),
9069             "%serr", sd_label);
9070         (void) snprintf(kstatname, sizeof (kstatname),
9071             "%s%d,err", sd_label, instance);
9072 
9073         un->un_errstats = kstat_create(kstatmodule_err, instance, kstatname,
9074             "device_error", KSTAT_TYPE_NAMED, ndata, KSTAT_FLAG_PERSISTENT);
9075 
9076         if (un->un_errstats == NULL) {
9077                 SD_ERROR(SD_LOG_ATTACH_DETACH, un,
9078                     "sd_create_errstats: Failed kstat_create\n");
9079                 return;
9080         }
9081 
9082         stp = (struct sd_errstats *)un->un_errstats->ks_data;
9083         kstat_named_init(&stp->sd_softerrs,      "Soft Errors",
9084             KSTAT_DATA_UINT32);
9085         kstat_named_init(&stp->sd_harderrs,      "Hard Errors",
9086             KSTAT_DATA_UINT32);
9087         kstat_named_init(&stp->sd_transerrs,     "Transport Errors",
9088             KSTAT_DATA_UINT32);
9089         kstat_named_init(&stp->sd_vid,           "Vendor",
9090             KSTAT_DATA_CHAR);
9091         kstat_named_init(&stp->sd_pid,           "Product",
9092             KSTAT_DATA_CHAR);
9093         kstat_named_init(&stp->sd_revision,      "Revision",
9094             KSTAT_DATA_CHAR);
9095         kstat_named_init(&stp->sd_serial,        "Serial No",
9096             KSTAT_DATA_CHAR);
9097         kstat_named_init(&stp->sd_capacity,      "Size",
9098             KSTAT_DATA_ULONGLONG);
9099         kstat_named_init(&stp->sd_rq_media_err,  "Media Error",
9100             KSTAT_DATA_UINT32);
9101         kstat_named_init(&stp->sd_rq_ntrdy_err,  "Device Not Ready",
9102             KSTAT_DATA_UINT32);
9103         kstat_named_init(&stp->sd_rq_nodev_err,  "No Device",
9104             KSTAT_DATA_UINT32);
9105         kstat_named_init(&stp->sd_rq_recov_err,  "Recoverable",
9106             KSTAT_DATA_UINT32);
9107         kstat_named_init(&stp->sd_rq_illrq_err,  "Illegal Request",
9108             KSTAT_DATA_UINT32);
9109         kstat_named_init(&stp->sd_rq_pfa_err,    "Predictive Failure Analysis",
9110             KSTAT_DATA_UINT32);
9111 
9112         un->un_errstats->ks_private = un;
9113         un->un_errstats->ks_update  = nulldev;
9114 
9115         kstat_install(un->un_errstats);
9116 }
9117 
9118 
9119 /*
9120  *    Function: sd_set_errstats
9121  *
9122  * Description: This routine sets the value of the vendor id, product id,
9123  *              revision, serial number, and capacity device error stats.
9124  *
9125  *              Note: During attach the stats are instantiated first so they are
9126  *              available for attach-time routines that utilize the driver
9127  *              iopath to send commands to the device. The stats are initialized
9128  *              separately so data obtained during some attach-time routines is
9129  *              available. (4362483)
9130  *
9131  *   Arguments: un - driver soft state (unit) structure
9132  *
9133  *     Context: Kernel thread context
9134  */
9135 
9136 static void
9137 sd_set_errstats(struct sd_lun *un)
9138 {
9139         struct  sd_errstats     *stp;
9140         char                    *sn;
9141 
9142         ASSERT(un != NULL);
9143         ASSERT(un->un_errstats != NULL);
9144         stp = (struct sd_errstats *)un->un_errstats->ks_data;
9145         ASSERT(stp != NULL);
9146         (void) strncpy(stp->sd_vid.value.c, un->un_sd->sd_inq->inq_vid, 8);
9147         (void) strncpy(stp->sd_pid.value.c, un->un_sd->sd_inq->inq_pid, 16);
9148         (void) strncpy(stp->sd_revision.value.c,
9149             un->un_sd->sd_inq->inq_revision, 4);
9150 
9151         /*
9152          * All the errstats are persistent across detach/attach,
9153          * so reset all the errstats here in case of the hot
9154          * replacement of disk drives, except for not changed
9155          * Sun qualified drives.
9156          */
9157         if ((bcmp(&SD_INQUIRY(un)->inq_pid[9], "SUN", 3) != 0) ||
9158             (bcmp(&SD_INQUIRY(un)->inq_serial, stp->sd_serial.value.c,
9159             sizeof (SD_INQUIRY(un)->inq_serial)) != 0)) {
9160                 stp->sd_softerrs.value.ui32 = 0;
9161                 stp->sd_harderrs.value.ui32 = 0;
9162                 stp->sd_transerrs.value.ui32 = 0;
9163                 stp->sd_rq_media_err.value.ui32 = 0;
9164                 stp->sd_rq_ntrdy_err.value.ui32 = 0;
9165                 stp->sd_rq_nodev_err.value.ui32 = 0;
9166                 stp->sd_rq_recov_err.value.ui32 = 0;
9167                 stp->sd_rq_illrq_err.value.ui32 = 0;
9168                 stp->sd_rq_pfa_err.value.ui32 = 0;
9169         }
9170 
9171         /*
9172          * Set the "Serial No" kstat for Sun qualified drives (indicated by
9173          * "SUN" in bytes 25-27 of the inquiry data (bytes 9-11 of the pid)
9174          * (4376302))
9175          */
9176         if (bcmp(&SD_INQUIRY(un)->inq_pid[9], "SUN", 3) == 0) {
9177                 bcopy(&SD_INQUIRY(un)->inq_serial, stp->sd_serial.value.c,
9178                     sizeof (SD_INQUIRY(un)->inq_serial));
9179         } else {
9180                 /*
9181                  * Set the "Serial No" kstat for non-Sun qualified drives
9182                  */
9183                 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, SD_DEVINFO(un),
9184                     DDI_PROP_NOTPROM | DDI_PROP_DONTPASS,
9185                     INQUIRY_SERIAL_NO, &sn) == DDI_SUCCESS) {
9186                         (void) strlcpy(stp->sd_serial.value.c, sn,
9187                             sizeof (stp->sd_serial.value.c));
9188                         ddi_prop_free(sn);
9189                 }
9190         }
9191 
9192         if (un->un_f_blockcount_is_valid != TRUE) {
9193                 /*
9194                  * Set capacity error stat to 0 for no media. This ensures
9195                  * a valid capacity is displayed in response to 'iostat -E'
9196                  * when no media is present in the device.
9197                  */
9198                 stp->sd_capacity.value.ui64 = 0;
9199         } else {
9200                 /*
9201                  * Multiply un_blockcount by un->un_sys_blocksize to get
9202                  * capacity.
9203                  *
9204                  * Note: for non-512 blocksize devices "un_blockcount" has been
9205                  * "scaled" in sd_send_scsi_READ_CAPACITY by multiplying by
9206                  * (un_tgt_blocksize / un->un_sys_blocksize).
9207                  */
9208                 stp->sd_capacity.value.ui64 = (uint64_t)
9209                     ((uint64_t)un->un_blockcount * un->un_sys_blocksize);
9210         }
9211 }
9212 
9213 
9214 /*
9215  *    Function: sd_set_pstats
9216  *
9217  * Description: This routine instantiates and initializes the partition
9218  *              stats for each partition with more than zero blocks.
9219  *              (4363169)
9220  *
9221  *   Arguments: un - driver soft state (unit) structure
9222  *
9223  *     Context: Kernel thread context
9224  */
9225 
9226 static void
9227 sd_set_pstats(struct sd_lun *un)
9228 {
9229         char    kstatname[KSTAT_STRLEN];
9230         int     instance;
9231         int     i;
9232         diskaddr_t      nblks = 0;
9233         char    *partname = NULL;
9234 
9235         ASSERT(un != NULL);
9236 
9237         instance = ddi_get_instance(SD_DEVINFO(un));
9238 
9239         /* Note:x86: is this a VTOC8/VTOC16 difference? */
9240         for (i = 0; i < NSDMAP; i++) {
9241 
9242                 if (cmlb_partinfo(un->un_cmlbhandle, i,
9243                     &nblks, NULL, &partname, NULL, (void *)SD_PATH_DIRECT) != 0)
9244                         continue;
9245                 mutex_enter(SD_MUTEX(un));
9246 
9247                 if ((un->un_pstats[i] == NULL) &&
9248                     (nblks != 0)) {
9249 
9250                         (void) snprintf(kstatname, sizeof (kstatname),
9251                             "%s%d,%s", sd_label, instance,
9252                             partname);
9253 
9254                         un->un_pstats[i] = kstat_create(sd_label,
9255                             instance, kstatname, "partition", KSTAT_TYPE_IO,
9256                             1, KSTAT_FLAG_PERSISTENT);
9257                         if (un->un_pstats[i] != NULL) {
9258                                 un->un_pstats[i]->ks_lock = SD_MUTEX(un);
9259                                 kstat_install(un->un_pstats[i]);
9260                         }
9261                 }
9262                 mutex_exit(SD_MUTEX(un));
9263         }
9264 }
9265 
9266 
9267 #if (defined(__fibre))
9268 /*
9269  *    Function: sd_init_event_callbacks
9270  *
9271  * Description: This routine initializes the insertion and removal event
9272  *              callbacks. (fibre only)
9273  *
9274  *   Arguments: un - driver soft state (unit) structure
9275  *
9276  *     Context: Kernel thread context
9277  */
9278 
9279 static void
9280 sd_init_event_callbacks(struct sd_lun *un)
9281 {
9282         ASSERT(un != NULL);
9283 
9284         if ((un->un_insert_event == NULL) &&
9285             (ddi_get_eventcookie(SD_DEVINFO(un), FCAL_INSERT_EVENT,
9286             &un->un_insert_event) == DDI_SUCCESS)) {
9287                 /*
9288                  * Add the callback for an insertion event
9289                  */
9290                 (void) ddi_add_event_handler(SD_DEVINFO(un),
9291                     un->un_insert_event, sd_event_callback, (void *)un,
9292                     &(un->un_insert_cb_id));
9293         }
9294 
9295         if ((un->un_remove_event == NULL) &&
9296             (ddi_get_eventcookie(SD_DEVINFO(un), FCAL_REMOVE_EVENT,
9297             &un->un_remove_event) == DDI_SUCCESS)) {
9298                 /*
9299                  * Add the callback for a removal event
9300                  */
9301                 (void) ddi_add_event_handler(SD_DEVINFO(un),
9302                     un->un_remove_event, sd_event_callback, (void *)un,
9303                     &(un->un_remove_cb_id));
9304         }
9305 }
9306 
9307 
9308 /*
9309  *    Function: sd_event_callback
9310  *
9311  * Description: This routine handles insert/remove events (photon). The
9312  *              state is changed to OFFLINE which can be used to supress
9313  *              error msgs. (fibre only)
9314  *
9315  *   Arguments: un - driver soft state (unit) structure
9316  *
9317  *     Context: Callout thread context
9318  */
9319 /* ARGSUSED */
9320 static void
9321 sd_event_callback(dev_info_t *dip, ddi_eventcookie_t event, void *arg,
9322     void *bus_impldata)
9323 {
9324         struct sd_lun *un = (struct sd_lun *)arg;
9325 
9326         _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_insert_event));
9327         if (event == un->un_insert_event) {
9328                 SD_TRACE(SD_LOG_COMMON, un, "sd_event_callback: insert event");
9329                 mutex_enter(SD_MUTEX(un));
9330                 if (un->un_state == SD_STATE_OFFLINE) {
9331                         if (un->un_last_state != SD_STATE_SUSPENDED) {
9332                                 un->un_state = un->un_last_state;
9333                         } else {
9334                                 /*
9335                                  * We have gone through SUSPEND/RESUME while
9336                                  * we were offline. Restore the last state
9337                                  */
9338                                 un->un_state = un->un_save_state;
9339                         }
9340                 }
9341                 mutex_exit(SD_MUTEX(un));
9342 
9343         _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_remove_event));
9344         } else if (event == un->un_remove_event) {
9345                 SD_TRACE(SD_LOG_COMMON, un, "sd_event_callback: remove event");
9346                 mutex_enter(SD_MUTEX(un));
9347                 /*
9348                  * We need to handle an event callback that occurs during
9349                  * the suspend operation, since we don't prevent it.
9350                  */
9351                 if (un->un_state != SD_STATE_OFFLINE) {
9352                         if (un->un_state != SD_STATE_SUSPENDED) {
9353                                 New_state(un, SD_STATE_OFFLINE);
9354                         } else {
9355                                 un->un_last_state = SD_STATE_OFFLINE;
9356                         }
9357                 }
9358                 mutex_exit(SD_MUTEX(un));
9359         } else {
9360                 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE,
9361                     "!Unknown event\n");
9362         }
9363 
9364 }
9365 #endif
9366 
9367 /*
9368  *    Function: sd_cache_control()
9369  *
9370  * Description: This routine is the driver entry point for setting
9371  *              read and write caching by modifying the WCE (write cache
9372  *              enable) and RCD (read cache disable) bits of mode
9373  *              page 8 (MODEPAGE_CACHING).
9374  *
9375  *   Arguments: ssc   - ssc contains pointer to driver soft state (unit)
9376  *                      structure for this target.
9377  *              rcd_flag - flag for controlling the read cache
9378  *              wce_flag - flag for controlling the write cache
9379  *
9380  * Return Code: EIO
9381  *              code returned by sd_send_scsi_MODE_SENSE and
9382  *              sd_send_scsi_MODE_SELECT
9383  *
9384  *     Context: Kernel Thread
9385  */
9386 
9387 static int
9388 sd_cache_control(sd_ssc_t *ssc, int rcd_flag, int wce_flag)
9389 {
9390         struct mode_caching     *mode_caching_page;
9391         uchar_t                 *header;
9392         size_t                  buflen;
9393         int                     hdrlen;
9394         int                     bd_len;
9395         int                     rval = 0;
9396         struct mode_header_grp2 *mhp;
9397         struct sd_lun           *un;
9398         int                     status;
9399 
9400         ASSERT(ssc != NULL);
9401         un = ssc->ssc_un;
9402         ASSERT(un != NULL);
9403 
9404         /*
9405          * Do a test unit ready, otherwise a mode sense may not work if this
9406          * is the first command sent to the device after boot.
9407          */
9408         status = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
9409         if (status != 0)
9410                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9411 
9412         if (un->un_f_cfg_is_atapi == TRUE) {
9413                 hdrlen = MODE_HEADER_LENGTH_GRP2;
9414         } else {
9415                 hdrlen = MODE_HEADER_LENGTH;
9416         }
9417 
9418         /*
9419          * Allocate memory for the retrieved mode page and its headers.  Set
9420          * a pointer to the page itself.  Use mode_cache_scsi3 to insure
9421          * we get all of the mode sense data otherwise, the mode select
9422          * will fail.  mode_cache_scsi3 is a superset of mode_caching.
9423          */
9424         buflen = hdrlen + MODE_BLK_DESC_LENGTH +
9425             sizeof (struct mode_cache_scsi3);
9426 
9427         header = kmem_zalloc(buflen, KM_SLEEP);
9428 
9429         /* Get the information from the device. */
9430         if (un->un_f_cfg_is_atapi == TRUE) {
9431                 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, header, buflen,
9432                     MODEPAGE_CACHING, SD_PATH_DIRECT);
9433         } else {
9434                 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, header, buflen,
9435                     MODEPAGE_CACHING, SD_PATH_DIRECT);
9436         }
9437 
9438         if (rval != 0) {
9439                 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
9440                     "sd_cache_control: Mode Sense Failed\n");
9441                 goto mode_sense_failed;
9442         }
9443 
9444         /*
9445          * Determine size of Block Descriptors in order to locate
9446          * the mode page data. ATAPI devices return 0, SCSI devices
9447          * should return MODE_BLK_DESC_LENGTH.
9448          */
9449         if (un->un_f_cfg_is_atapi == TRUE) {
9450                 mhp     = (struct mode_header_grp2 *)header;
9451                 bd_len  = (mhp->bdesc_length_hi << 8) | mhp->bdesc_length_lo;
9452         } else {
9453                 bd_len  = ((struct mode_header *)header)->bdesc_length;
9454         }
9455 
9456         if (bd_len > MODE_BLK_DESC_LENGTH) {
9457                 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, 0,
9458                     "sd_cache_control: Mode Sense returned invalid block "
9459                     "descriptor length\n");
9460                 rval = EIO;
9461                 goto mode_sense_failed;
9462         }
9463 
9464         mode_caching_page = (struct mode_caching *)(header + hdrlen + bd_len);
9465         if (mode_caching_page->mode_page.code != MODEPAGE_CACHING) {
9466                 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
9467                     "sd_cache_control: Mode Sense caching page code mismatch "
9468                     "%d\n", mode_caching_page->mode_page.code);
9469                 rval = EIO;
9470                 goto mode_sense_failed;
9471         }
9472 
9473         /* Check the relevant bits on successful mode sense. */
9474         if ((mode_caching_page->rcd && rcd_flag == SD_CACHE_ENABLE) ||
9475             (!mode_caching_page->rcd && rcd_flag == SD_CACHE_DISABLE) ||
9476             (mode_caching_page->wce && wce_flag == SD_CACHE_DISABLE) ||
9477             (!mode_caching_page->wce && wce_flag == SD_CACHE_ENABLE)) {
9478 
9479                 size_t sbuflen;
9480                 uchar_t save_pg;
9481 
9482                 /*
9483                  * Construct select buffer length based on the
9484                  * length of the sense data returned.
9485                  */
9486                 sbuflen =  hdrlen + bd_len +
9487                     sizeof (struct mode_page) +
9488                     (int)mode_caching_page->mode_page.length;
9489 
9490                 /*
9491                  * Set the caching bits as requested.
9492                  */
9493                 if (rcd_flag == SD_CACHE_ENABLE)
9494                         mode_caching_page->rcd = 0;
9495                 else if (rcd_flag == SD_CACHE_DISABLE)
9496                         mode_caching_page->rcd = 1;
9497 
9498                 if (wce_flag == SD_CACHE_ENABLE)
9499                         mode_caching_page->wce = 1;
9500                 else if (wce_flag == SD_CACHE_DISABLE)
9501                         mode_caching_page->wce = 0;
9502 
9503                 /*
9504                  * Save the page if the mode sense says the
9505                  * drive supports it.
9506                  */
9507                 save_pg = mode_caching_page->mode_page.ps ?
9508                     SD_SAVE_PAGE : SD_DONTSAVE_PAGE;
9509 
9510                 /* Clear reserved bits before mode select. */
9511                 mode_caching_page->mode_page.ps = 0;
9512 
9513                 /*
9514                  * Clear out mode header for mode select.
9515                  * The rest of the retrieved page will be reused.
9516                  */
9517                 bzero(header, hdrlen);
9518 
9519                 if (un->un_f_cfg_is_atapi == TRUE) {
9520                         mhp = (struct mode_header_grp2 *)header;
9521                         mhp->bdesc_length_hi = bd_len >> 8;
9522                         mhp->bdesc_length_lo = (uchar_t)bd_len & 0xff;
9523                 } else {
9524                         ((struct mode_header *)header)->bdesc_length = bd_len;
9525                 }
9526 
9527                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9528 
9529                 /* Issue mode select to change the cache settings */
9530                 if (un->un_f_cfg_is_atapi == TRUE) {
9531                         rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP1, header,
9532                             sbuflen, save_pg, SD_PATH_DIRECT);
9533                 } else {
9534                         rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, header,
9535                             sbuflen, save_pg, SD_PATH_DIRECT);
9536                 }
9537 
9538         }
9539 
9540 
9541 mode_sense_failed:
9542 
9543         kmem_free(header, buflen);
9544 
9545         if (rval != 0) {
9546                 if (rval == EIO)
9547                         sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
9548                 else
9549                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9550         }
9551         return (rval);
9552 }
9553 
9554 
9555 /*
9556  *    Function: sd_get_write_cache_enabled()
9557  *
9558  * Description: This routine is the driver entry point for determining if
9559  *              write caching is enabled.  It examines the WCE (write cache
9560  *              enable) bits of mode page 8 (MODEPAGE_CACHING).
9561  *
9562  *   Arguments: ssc   - ssc contains pointer to driver soft state (unit)
9563  *                      structure for this target.
9564  *              is_enabled - pointer to int where write cache enabled state
9565  *              is returned (non-zero -> write cache enabled)
9566  *
9567  *
9568  * Return Code: EIO
9569  *              code returned by sd_send_scsi_MODE_SENSE
9570  *
9571  *     Context: Kernel Thread
9572  *
9573  * NOTE: If ioctl is added to disable write cache, this sequence should
9574  * be followed so that no locking is required for accesses to
9575  * un->un_f_write_cache_enabled:
9576  *      do mode select to clear wce
9577  *      do synchronize cache to flush cache
9578  *      set un->un_f_write_cache_enabled = FALSE
9579  *
9580  * Conversely, an ioctl to enable the write cache should be done
9581  * in this order:
9582  *      set un->un_f_write_cache_enabled = TRUE
9583  *      do mode select to set wce
9584  */
9585 
9586 static int
9587 sd_get_write_cache_enabled(sd_ssc_t *ssc, int *is_enabled)
9588 {
9589         struct mode_caching     *mode_caching_page;
9590         uchar_t                 *header;
9591         size_t                  buflen;
9592         int                     hdrlen;
9593         int                     bd_len;
9594         int                     rval = 0;
9595         struct sd_lun           *un;
9596         int                     status;
9597 
9598         ASSERT(ssc != NULL);
9599         un = ssc->ssc_un;
9600         ASSERT(un != NULL);
9601         ASSERT(is_enabled != NULL);
9602 
9603         /* in case of error, flag as enabled */
9604         *is_enabled = TRUE;
9605 
9606         /*
9607          * Do a test unit ready, otherwise a mode sense may not work if this
9608          * is the first command sent to the device after boot.
9609          */
9610         status = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
9611 
9612         if (status != 0)
9613                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9614 
9615         if (un->un_f_cfg_is_atapi == TRUE) {
9616                 hdrlen = MODE_HEADER_LENGTH_GRP2;
9617         } else {
9618                 hdrlen = MODE_HEADER_LENGTH;
9619         }
9620 
9621         /*
9622          * Allocate memory for the retrieved mode page and its headers.  Set
9623          * a pointer to the page itself.
9624          */
9625         buflen = hdrlen + MODE_BLK_DESC_LENGTH + sizeof (struct mode_caching);
9626         header = kmem_zalloc(buflen, KM_SLEEP);
9627 
9628         /* Get the information from the device. */
9629         if (un->un_f_cfg_is_atapi == TRUE) {
9630                 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, header, buflen,
9631                     MODEPAGE_CACHING, SD_PATH_DIRECT);
9632         } else {
9633                 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, header, buflen,
9634                     MODEPAGE_CACHING, SD_PATH_DIRECT);
9635         }
9636 
9637         if (rval != 0) {
9638                 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
9639                     "sd_get_write_cache_enabled: Mode Sense Failed\n");
9640                 goto mode_sense_failed;
9641         }
9642 
9643         /*
9644          * Determine size of Block Descriptors in order to locate
9645          * the mode page data. ATAPI devices return 0, SCSI devices
9646          * should return MODE_BLK_DESC_LENGTH.
9647          */
9648         if (un->un_f_cfg_is_atapi == TRUE) {
9649                 struct mode_header_grp2 *mhp;
9650                 mhp     = (struct mode_header_grp2 *)header;
9651                 bd_len  = (mhp->bdesc_length_hi << 8) | mhp->bdesc_length_lo;
9652         } else {
9653                 bd_len  = ((struct mode_header *)header)->bdesc_length;
9654         }
9655 
9656         if (bd_len > MODE_BLK_DESC_LENGTH) {
9657                 /* FMA should make upset complain here */
9658                 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, 0,
9659                     "sd_get_write_cache_enabled: Mode Sense returned invalid "
9660                     "block descriptor length\n");
9661                 rval = EIO;
9662                 goto mode_sense_failed;
9663         }
9664 
9665         mode_caching_page = (struct mode_caching *)(header + hdrlen + bd_len);
9666         if (mode_caching_page->mode_page.code != MODEPAGE_CACHING) {
9667                 /* FMA could make upset complain here */
9668                 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON,
9669                     "sd_get_write_cache_enabled: Mode Sense caching page "
9670                     "code mismatch %d\n", mode_caching_page->mode_page.code);
9671                 rval = EIO;
9672                 goto mode_sense_failed;
9673         }
9674         *is_enabled = mode_caching_page->wce;
9675 
9676 mode_sense_failed:
9677         if (rval == 0) {
9678                 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
9679         } else if (rval == EIO) {
9680                 /*
9681                  * Some disks do not support mode sense(6), we
9682                  * should ignore this kind of error(sense key is
9683                  * 0x5 - illegal request).
9684                  */
9685                 uint8_t *sensep;
9686                 int senlen;
9687 
9688                 sensep = (uint8_t *)ssc->ssc_uscsi_cmd->uscsi_rqbuf;
9689                 senlen = (int)(ssc->ssc_uscsi_cmd->uscsi_rqlen -
9690                     ssc->ssc_uscsi_cmd->uscsi_rqresid);
9691 
9692                 if (senlen > 0 &&
9693                     scsi_sense_key(sensep) == KEY_ILLEGAL_REQUEST) {
9694                         sd_ssc_assessment(ssc, SD_FMT_IGNORE_COMPROMISE);
9695                 } else {
9696                         sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
9697                 }
9698         } else {
9699                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9700         }
9701         kmem_free(header, buflen);
9702         return (rval);
9703 }
9704 
9705 /*
9706  *    Function: sd_get_nv_sup()
9707  *
9708  * Description: This routine is the driver entry point for
9709  * determining whether non-volatile cache is supported. This
9710  * determination process works as follows:
9711  *
9712  * 1. sd first queries sd.conf on whether
9713  * suppress_cache_flush bit is set for this device.
9714  *
9715  * 2. if not there, then queries the internal disk table.
9716  *
9717  * 3. if either sd.conf or internal disk table specifies
9718  * cache flush be suppressed, we don't bother checking
9719  * NV_SUP bit.
9720  *
9721  * If SUPPRESS_CACHE_FLUSH bit is not set to 1, sd queries
9722  * the optional INQUIRY VPD page 0x86. If the device
9723  * supports VPD page 0x86, sd examines the NV_SUP
9724  * (non-volatile cache support) bit in the INQUIRY VPD page
9725  * 0x86:
9726  *   o If NV_SUP bit is set, sd assumes the device has a
9727  *   non-volatile cache and set the
9728  *   un_f_sync_nv_supported to TRUE.
9729  *   o Otherwise cache is not non-volatile,
9730  *   un_f_sync_nv_supported is set to FALSE.
9731  *
9732  * Arguments: un - driver soft state (unit) structure
9733  *
9734  * Return Code:
9735  *
9736  *     Context: Kernel Thread
9737  */
9738 
9739 static void
9740 sd_get_nv_sup(sd_ssc_t *ssc)
9741 {
9742         int             rval            = 0;
9743         uchar_t         *inq86          = NULL;
9744         size_t          inq86_len       = MAX_INQUIRY_SIZE;
9745         size_t          inq86_resid     = 0;
9746         struct          dk_callback *dkc;
9747         struct sd_lun   *un;
9748 
9749         ASSERT(ssc != NULL);
9750         un = ssc->ssc_un;
9751         ASSERT(un != NULL);
9752 
9753         mutex_enter(SD_MUTEX(un));
9754 
9755         /*
9756          * Be conservative on the device's support of
9757          * SYNC_NV bit: un_f_sync_nv_supported is
9758          * initialized to be false.
9759          */
9760         un->un_f_sync_nv_supported = FALSE;
9761 
9762         /*
9763          * If either sd.conf or internal disk table
9764          * specifies cache flush be suppressed, then
9765          * we don't bother checking NV_SUP bit.
9766          */
9767         if (un->un_f_suppress_cache_flush == TRUE) {
9768                 mutex_exit(SD_MUTEX(un));
9769                 return;
9770         }
9771 
9772         if (sd_check_vpd_page_support(ssc) == 0 &&
9773             un->un_vpd_page_mask & SD_VPD_EXTENDED_DATA_PG) {
9774                 mutex_exit(SD_MUTEX(un));
9775                 /* collect page 86 data if available */
9776                 inq86 = kmem_zalloc(inq86_len, KM_SLEEP);
9777 
9778                 rval = sd_send_scsi_INQUIRY(ssc, inq86, inq86_len,
9779                     0x01, 0x86, &inq86_resid);
9780 
9781                 if (rval == 0 && (inq86_len - inq86_resid > 6)) {
9782                         SD_TRACE(SD_LOG_COMMON, un,
9783                             "sd_get_nv_sup: \
9784                             successfully get VPD page: %x \
9785                             PAGE LENGTH: %x BYTE 6: %x\n",
9786                             inq86[1], inq86[3], inq86[6]);
9787 
9788                         mutex_enter(SD_MUTEX(un));
9789                         /*
9790                          * check the value of NV_SUP bit: only if the device
9791                          * reports NV_SUP bit to be 1, the
9792                          * un_f_sync_nv_supported bit will be set to true.
9793                          */
9794                         if (inq86[6] & SD_VPD_NV_SUP) {
9795                                 un->un_f_sync_nv_supported = TRUE;
9796                         }
9797                         mutex_exit(SD_MUTEX(un));
9798                 } else if (rval != 0) {
9799                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9800                 }
9801 
9802                 kmem_free(inq86, inq86_len);
9803         } else {
9804                 mutex_exit(SD_MUTEX(un));
9805         }
9806 
9807         /*
9808          * Send a SYNC CACHE command to check whether
9809          * SYNC_NV bit is supported. This command should have
9810          * un_f_sync_nv_supported set to correct value.
9811          */
9812         mutex_enter(SD_MUTEX(un));
9813         if (un->un_f_sync_nv_supported) {
9814                 mutex_exit(SD_MUTEX(un));
9815                 dkc = kmem_zalloc(sizeof (struct dk_callback), KM_SLEEP);
9816                 dkc->dkc_flag = FLUSH_VOLATILE;
9817                 (void) sd_send_scsi_SYNCHRONIZE_CACHE(un, dkc);
9818 
9819                 /*
9820                  * Send a TEST UNIT READY command to the device. This should
9821                  * clear any outstanding UNIT ATTENTION that may be present.
9822                  */
9823                 rval = sd_send_scsi_TEST_UNIT_READY(ssc, SD_DONT_RETRY_TUR);
9824                 if (rval != 0)
9825                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
9826 
9827                 kmem_free(dkc, sizeof (struct dk_callback));
9828         } else {
9829                 mutex_exit(SD_MUTEX(un));
9830         }
9831 
9832         SD_TRACE(SD_LOG_COMMON, un, "sd_get_nv_sup: \
9833             un_f_suppress_cache_flush is set to %d\n",
9834             un->un_f_suppress_cache_flush);
9835 }
9836 
9837 /*
9838  *    Function: sd_make_device
9839  *
9840  * Description: Utility routine to return the Solaris device number from
9841  *              the data in the device's dev_info structure.
9842  *
9843  * Return Code: The Solaris device number
9844  *
9845  *     Context: Any
9846  */
9847 
9848 static dev_t
9849 sd_make_device(dev_info_t *devi)
9850 {
9851         return (makedevice(ddi_driver_major(devi),
9852             ddi_get_instance(devi) << SDUNIT_SHIFT));
9853 }
9854 
9855 
9856 /*
9857  *    Function: sd_pm_entry
9858  *
9859  * Description: Called at the start of a new command to manage power
9860  *              and busy status of a device. This includes determining whether
9861  *              the current power state of the device is sufficient for
9862  *              performing the command or whether it must be changed.
9863  *              The PM framework is notified appropriately.
9864  *              Only with a return status of DDI_SUCCESS will the
9865  *              component be busy to the framework.
9866  *
9867  *              All callers of sd_pm_entry must check the return status
9868  *              and only call sd_pm_exit it it was DDI_SUCCESS. A status
9869  *              of DDI_FAILURE indicates the device failed to power up.
9870  *              In this case un_pm_count has been adjusted so the result
9871  *              on exit is still powered down, ie. count is less than 0.
9872  *              Calling sd_pm_exit with this count value hits an ASSERT.
9873  *
9874  * Return Code: DDI_SUCCESS or DDI_FAILURE
9875  *
9876  *     Context: Kernel thread context.
9877  */
9878 
9879 static int
9880 sd_pm_entry(struct sd_lun *un)
9881 {
9882         int return_status = DDI_SUCCESS;
9883 
9884         ASSERT(!mutex_owned(SD_MUTEX(un)));
9885         ASSERT(!mutex_owned(&un->un_pm_mutex));
9886 
9887         SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_entry: entry\n");
9888 
9889         if (un->un_f_pm_is_enabled == FALSE) {
9890                 SD_TRACE(SD_LOG_IO_PM, un,
9891                     "sd_pm_entry: exiting, PM not enabled\n");
9892                 return (return_status);
9893         }
9894 
9895         /*
9896          * Just increment a counter if PM is enabled. On the transition from
9897          * 0 ==> 1, mark the device as busy.  The iodone side will decrement
9898          * the count with each IO and mark the device as idle when the count
9899          * hits 0.
9900          *
9901          * If the count is less than 0 the device is powered down. If a powered
9902          * down device is successfully powered up then the count must be
9903          * incremented to reflect the power up. Note that it'll get incremented
9904          * a second time to become busy.
9905          *
9906          * Because the following has the potential to change the device state
9907          * and must release the un_pm_mutex to do so, only one thread can be
9908          * allowed through at a time.
9909          */
9910 
9911         mutex_enter(&un->un_pm_mutex);
9912         while (un->un_pm_busy == TRUE) {
9913                 cv_wait(&un->un_pm_busy_cv, &un->un_pm_mutex);
9914         }
9915         un->un_pm_busy = TRUE;
9916 
9917         if (un->un_pm_count < 1) {
9918 
9919                 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_entry: busy component\n");
9920 
9921                 /*
9922                  * Indicate we are now busy so the framework won't attempt to
9923                  * power down the device. This call will only fail if either
9924                  * we passed a bad component number or the device has no
9925                  * components. Neither of these should ever happen.
9926                  */
9927                 mutex_exit(&un->un_pm_mutex);
9928                 return_status = pm_busy_component(SD_DEVINFO(un), 0);
9929                 ASSERT(return_status == DDI_SUCCESS);
9930 
9931                 mutex_enter(&un->un_pm_mutex);
9932 
9933                 if (un->un_pm_count < 0) {
9934                         mutex_exit(&un->un_pm_mutex);
9935 
9936                         SD_TRACE(SD_LOG_IO_PM, un,
9937                             "sd_pm_entry: power up component\n");
9938 
9939                         /*
9940                          * pm_raise_power will cause sdpower to be called
9941                          * which brings the device power level to the
9942                          * desired state, If successful, un_pm_count and
9943                          * un_power_level will be updated appropriately.
9944                          */
9945                         return_status = pm_raise_power(SD_DEVINFO(un), 0,
9946                             SD_PM_STATE_ACTIVE(un));
9947 
9948                         mutex_enter(&un->un_pm_mutex);
9949 
9950                         if (return_status != DDI_SUCCESS) {
9951                                 /*
9952                                  * Power up failed.
9953                                  * Idle the device and adjust the count
9954                                  * so the result on exit is that we're
9955                                  * still powered down, ie. count is less than 0.
9956                                  */
9957                                 SD_TRACE(SD_LOG_IO_PM, un,
9958                                     "sd_pm_entry: power up failed,"
9959                                     " idle the component\n");
9960 
9961                                 (void) pm_idle_component(SD_DEVINFO(un), 0);
9962                                 un->un_pm_count--;
9963                         } else {
9964                                 /*
9965                                  * Device is powered up, verify the
9966                                  * count is non-negative.
9967                                  * This is debug only.
9968                                  */
9969                                 ASSERT(un->un_pm_count == 0);
9970                         }
9971                 }
9972 
9973                 if (return_status == DDI_SUCCESS) {
9974                         /*
9975                          * For performance, now that the device has been tagged
9976                          * as busy, and it's known to be powered up, update the
9977                          * chain types to use jump tables that do not include
9978                          * pm. This significantly lowers the overhead and
9979                          * therefore improves performance.
9980                          */
9981 
9982                         mutex_exit(&un->un_pm_mutex);
9983                         mutex_enter(SD_MUTEX(un));
9984                         SD_TRACE(SD_LOG_IO_PM, un,
9985                             "sd_pm_entry: changing uscsi_chain_type from %d\n",
9986                             un->un_uscsi_chain_type);
9987 
9988                         if (un->un_f_non_devbsize_supported) {
9989                                 un->un_buf_chain_type =
9990                                     SD_CHAIN_INFO_RMMEDIA_NO_PM;
9991                         } else {
9992                                 un->un_buf_chain_type =
9993                                     SD_CHAIN_INFO_DISK_NO_PM;
9994                         }
9995                         un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD_NO_PM;
9996 
9997                         SD_TRACE(SD_LOG_IO_PM, un,
9998                             "             changed  uscsi_chain_type to   %d\n",
9999                             un->un_uscsi_chain_type);
10000                         mutex_exit(SD_MUTEX(un));
10001                         mutex_enter(&un->un_pm_mutex);
10002 
10003                         if (un->un_pm_idle_timeid == NULL) {
10004                                 /* 300 ms. */
10005                                 un->un_pm_idle_timeid =
10006                                     timeout(sd_pm_idletimeout_handler, un,
10007                                     (drv_usectohz((clock_t)300000)));
10008                                 /*
10009                                  * Include an extra call to busy which keeps the
10010                                  * device busy with-respect-to the PM layer
10011                                  * until the timer fires, at which time it'll
10012                                  * get the extra idle call.
10013                                  */
10014                                 (void) pm_busy_component(SD_DEVINFO(un), 0);
10015                         }
10016                 }
10017         }
10018         un->un_pm_busy = FALSE;
10019         /* Next... */
10020         cv_signal(&un->un_pm_busy_cv);
10021 
10022         un->un_pm_count++;
10023 
10024         SD_TRACE(SD_LOG_IO_PM, un,
10025             "sd_pm_entry: exiting, un_pm_count = %d\n", un->un_pm_count);
10026 
10027         mutex_exit(&un->un_pm_mutex);
10028 
10029         return (return_status);
10030 }
10031 
10032 
10033 /*
10034  *    Function: sd_pm_exit
10035  *
10036  * Description: Called at the completion of a command to manage busy
10037  *              status for the device. If the device becomes idle the
10038  *              PM framework is notified.
10039  *
10040  *     Context: Kernel thread context
10041  */
10042 
10043 static void
10044 sd_pm_exit(struct sd_lun *un)
10045 {
10046         ASSERT(!mutex_owned(SD_MUTEX(un)));
10047         ASSERT(!mutex_owned(&un->un_pm_mutex));
10048 
10049         SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_exit: entry\n");
10050 
10051         /*
10052          * After attach the following flag is only read, so don't
10053          * take the penalty of acquiring a mutex for it.
10054          */
10055         if (un->un_f_pm_is_enabled == TRUE) {
10056 
10057                 mutex_enter(&un->un_pm_mutex);
10058                 un->un_pm_count--;
10059 
10060                 SD_TRACE(SD_LOG_IO_PM, un,
10061                     "sd_pm_exit: un_pm_count = %d\n", un->un_pm_count);
10062 
10063                 ASSERT(un->un_pm_count >= 0);
10064                 if (un->un_pm_count == 0) {
10065                         mutex_exit(&un->un_pm_mutex);
10066 
10067                         SD_TRACE(SD_LOG_IO_PM, un,
10068                             "sd_pm_exit: idle component\n");
10069 
10070                         (void) pm_idle_component(SD_DEVINFO(un), 0);
10071 
10072                 } else {
10073                         mutex_exit(&un->un_pm_mutex);
10074                 }
10075         }
10076 
10077         SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_exit: exiting\n");
10078 }
10079 
10080 
10081 /*
10082  *    Function: sdopen
10083  *
10084  * Description: Driver's open(9e) entry point function.
10085  *
10086  *   Arguments: dev_i   - pointer to device number
10087  *              flag    - how to open file (FEXCL, FNDELAY, FREAD, FWRITE)
10088  *              otyp    - open type (OTYP_BLK, OTYP_CHR, OTYP_LYR)
10089  *              cred_p  - user credential pointer
10090  *
10091  * Return Code: EINVAL
10092  *              ENXIO
10093  *              EIO
10094  *              EROFS
10095  *              EBUSY
10096  *
10097  *     Context: Kernel thread context
10098  */
10099 /* ARGSUSED */
10100 static int
10101 sdopen(dev_t *dev_p, int flag, int otyp, cred_t *cred_p)
10102 {
10103         struct sd_lun   *un;
10104         int             nodelay;
10105         int             part;
10106         uint64_t        partmask;
10107         int             instance;
10108         dev_t           dev;
10109         int             rval = EIO;
10110         diskaddr_t      nblks = 0;
10111         diskaddr_t      label_cap;
10112 
10113         /* Validate the open type */
10114         if (otyp >= OTYPCNT) {
10115                 return (EINVAL);
10116         }
10117 
10118         dev = *dev_p;
10119         instance = SDUNIT(dev);
10120         mutex_enter(&sd_detach_mutex);
10121 
10122         /*
10123          * Fail the open if there is no softstate for the instance, or
10124          * if another thread somewhere is trying to detach the instance.
10125          */
10126         if (((un = ddi_get_soft_state(sd_state, instance)) == NULL) ||
10127             (un->un_detach_count != 0)) {
10128                 mutex_exit(&sd_detach_mutex);
10129                 /*
10130                  * The probe cache only needs to be cleared when open (9e) fails
10131                  * with ENXIO (4238046).
10132                  */
10133                 /*
10134                  * un-conditionally clearing probe cache is ok with
10135                  * separate sd/ssd binaries
10136                  * x86 platform can be an issue with both parallel
10137                  * and fibre in 1 binary
10138                  */
10139                 sd_scsi_clear_probe_cache();
10140                 return (ENXIO);
10141         }
10142 
10143         /*
10144          * The un_layer_count is to prevent another thread in specfs from
10145          * trying to detach the instance, which can happen when we are
10146          * called from a higher-layer driver instead of thru specfs.
10147          * This will not be needed when DDI provides a layered driver
10148          * interface that allows specfs to know that an instance is in
10149          * use by a layered driver & should not be detached.
10150          *
10151          * Note: the semantics for layered driver opens are exactly one
10152          * close for every open.
10153          */
10154         if (otyp == OTYP_LYR) {
10155                 un->un_layer_count++;
10156         }
10157 
10158         /*
10159          * Keep a count of the current # of opens in progress. This is because
10160          * some layered drivers try to call us as a regular open. This can
10161          * cause problems that we cannot prevent, however by keeping this count
10162          * we can at least keep our open and detach routines from racing against
10163          * each other under such conditions.
10164          */
10165         un->un_opens_in_progress++;
10166         mutex_exit(&sd_detach_mutex);
10167 
10168         nodelay  = (flag & (FNDELAY | FNONBLOCK));
10169         part     = SDPART(dev);
10170         partmask = 1 << part;
10171 
10172         /*
10173          * We use a semaphore here in order to serialize
10174          * open and close requests on the device.
10175          */
10176         sema_p(&un->un_semoclose);
10177 
10178         mutex_enter(SD_MUTEX(un));
10179 
10180         /*
10181          * All device accesses go thru sdstrategy() where we check
10182          * on suspend status but there could be a scsi_poll command,
10183          * which bypasses sdstrategy(), so we need to check pm
10184          * status.
10185          */
10186 
10187         if (!nodelay) {
10188                 while ((un->un_state == SD_STATE_SUSPENDED) ||
10189                     (un->un_state == SD_STATE_PM_CHANGING)) {
10190                         cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
10191                 }
10192 
10193                 mutex_exit(SD_MUTEX(un));
10194                 if (sd_pm_entry(un) != DDI_SUCCESS) {
10195                         rval = EIO;
10196                         SD_ERROR(SD_LOG_OPEN_CLOSE, un,
10197                             "sdopen: sd_pm_entry failed\n");
10198                         goto open_failed_with_pm;
10199                 }
10200                 mutex_enter(SD_MUTEX(un));
10201         }
10202 
10203         /* check for previous exclusive open */
10204         SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdopen: un=%p\n", (void *)un);
10205         SD_TRACE(SD_LOG_OPEN_CLOSE, un,
10206             "sdopen: exclopen=%x, flag=%x, regopen=%x\n",
10207             un->un_exclopen, flag, un->un_ocmap.regopen[otyp]);
10208 
10209         if (un->un_exclopen & (partmask)) {
10210                 goto excl_open_fail;
10211         }
10212 
10213         if (flag & FEXCL) {
10214                 int i;
10215                 if (un->un_ocmap.lyropen[part]) {
10216                         goto excl_open_fail;
10217                 }
10218                 for (i = 0; i < (OTYPCNT - 1); i++) {
10219                         if (un->un_ocmap.regopen[i] & (partmask)) {
10220                                 goto excl_open_fail;
10221                         }
10222                 }
10223         }
10224 
10225         /*
10226          * Check the write permission if this is a removable media device,
10227          * NDELAY has not been set, and writable permission is requested.
10228          *
10229          * Note: If NDELAY was set and this is write-protected media the WRITE
10230          * attempt will fail with EIO as part of the I/O processing. This is a
10231          * more permissive implementation that allows the open to succeed and
10232          * WRITE attempts to fail when appropriate.
10233          */
10234         if (un->un_f_chk_wp_open) {
10235                 if ((flag & FWRITE) && (!nodelay)) {
10236                         mutex_exit(SD_MUTEX(un));
10237                         /*
10238                          * Defer the check for write permission on writable
10239                          * DVD drive till sdstrategy and will not fail open even
10240                          * if FWRITE is set as the device can be writable
10241                          * depending upon the media and the media can change
10242                          * after the call to open().
10243                          */
10244                         if (un->un_f_dvdram_writable_device == FALSE) {
10245                                 if (ISCD(un) || sr_check_wp(dev)) {
10246                                 rval = EROFS;
10247                                 mutex_enter(SD_MUTEX(un));
10248                                 SD_ERROR(SD_LOG_OPEN_CLOSE, un, "sdopen: "
10249                                     "write to cd or write protected media\n");
10250                                 goto open_fail;
10251                                 }
10252                         }
10253                         mutex_enter(SD_MUTEX(un));
10254                 }
10255         }
10256 
10257         /*
10258          * If opening in NDELAY/NONBLOCK mode, just return.
10259          * Check if disk is ready and has a valid geometry later.
10260          */
10261         if (!nodelay) {
10262                 sd_ssc_t        *ssc;
10263 
10264                 mutex_exit(SD_MUTEX(un));
10265                 ssc = sd_ssc_init(un);
10266                 rval = sd_ready_and_valid(ssc, part);
10267                 sd_ssc_fini(ssc);
10268                 mutex_enter(SD_MUTEX(un));
10269                 /*
10270                  * Fail if device is not ready or if the number of disk
10271                  * blocks is zero or negative for non CD devices.
10272                  */
10273 
10274                 nblks = 0;
10275 
10276                 if (rval == SD_READY_VALID && (!ISCD(un))) {
10277                         /* if cmlb_partinfo fails, nblks remains 0 */
10278                         mutex_exit(SD_MUTEX(un));
10279                         (void) cmlb_partinfo(un->un_cmlbhandle, part, &nblks,
10280                             NULL, NULL, NULL, (void *)SD_PATH_DIRECT);
10281                         mutex_enter(SD_MUTEX(un));
10282                 }
10283 
10284                 if ((rval != SD_READY_VALID) ||
10285                     (!ISCD(un) && nblks <= 0)) {
10286                         rval = un->un_f_has_removable_media ? ENXIO : EIO;
10287                         SD_ERROR(SD_LOG_OPEN_CLOSE, un, "sdopen: "
10288                             "device not ready or invalid disk block value\n");
10289                         goto open_fail;
10290                 }
10291 #if defined(__i386) || defined(__amd64)
10292         } else {
10293                 uchar_t *cp;
10294                 /*
10295                  * x86 requires special nodelay handling, so that p0 is
10296                  * always defined and accessible.
10297                  * Invalidate geometry only if device is not already open.
10298                  */
10299                 cp = &un->un_ocmap.chkd[0];
10300                 while (cp < &un->un_ocmap.chkd[OCSIZE]) {
10301                         if (*cp != (uchar_t)0) {
10302                                 break;
10303                         }
10304                         cp++;
10305                 }
10306                 if (cp == &un->un_ocmap.chkd[OCSIZE]) {
10307                         mutex_exit(SD_MUTEX(un));
10308                         cmlb_invalidate(un->un_cmlbhandle,
10309                             (void *)SD_PATH_DIRECT);
10310                         mutex_enter(SD_MUTEX(un));
10311                 }
10312 
10313 #endif
10314         }
10315 
10316         if (otyp == OTYP_LYR) {
10317                 un->un_ocmap.lyropen[part]++;
10318         } else {
10319                 un->un_ocmap.regopen[otyp] |= partmask;
10320         }
10321 
10322         /* Set up open and exclusive open flags */
10323         if (flag & FEXCL) {
10324                 un->un_exclopen |= (partmask);
10325         }
10326 
10327         /*
10328          * If the lun is EFI labeled and lun capacity is greater than the
10329          * capacity contained in the label, log a sys-event to notify the
10330          * interested module.
10331          * To avoid an infinite loop of logging sys-event, we only log the
10332          * event when the lun is not opened in NDELAY mode. The event handler
10333          * should open the lun in NDELAY mode.
10334          */
10335         if (!nodelay) {
10336                 mutex_exit(SD_MUTEX(un));
10337                 if (cmlb_efi_label_capacity(un->un_cmlbhandle, &label_cap,
10338                     (void*)SD_PATH_DIRECT) == 0) {
10339                         mutex_enter(SD_MUTEX(un));
10340                         if (un->un_f_blockcount_is_valid &&
10341                             un->un_blockcount > label_cap &&
10342                             un->un_f_expnevent == B_FALSE) {
10343                                 un->un_f_expnevent = B_TRUE;
10344                                 mutex_exit(SD_MUTEX(un));
10345                                 sd_log_lun_expansion_event(un,
10346                                     (nodelay ? KM_NOSLEEP : KM_SLEEP));
10347                                 mutex_enter(SD_MUTEX(un));
10348                         }
10349                 } else {
10350                         mutex_enter(SD_MUTEX(un));
10351                 }
10352         }
10353 
10354         SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdopen: "
10355             "open of part %d type %d\n", part, otyp);
10356 
10357         mutex_exit(SD_MUTEX(un));
10358         if (!nodelay) {
10359                 sd_pm_exit(un);
10360         }
10361 
10362         sema_v(&un->un_semoclose);
10363 
10364         mutex_enter(&sd_detach_mutex);
10365         un->un_opens_in_progress--;
10366         mutex_exit(&sd_detach_mutex);
10367 
10368         SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdopen: exit success\n");
10369         return (DDI_SUCCESS);
10370 
10371 excl_open_fail:
10372         SD_ERROR(SD_LOG_OPEN_CLOSE, un, "sdopen: fail exclusive open\n");
10373         rval = EBUSY;
10374 
10375 open_fail:
10376         mutex_exit(SD_MUTEX(un));
10377 
10378         /*
10379          * On a failed open we must exit the pm management.
10380          */
10381         if (!nodelay) {
10382                 sd_pm_exit(un);
10383         }
10384 open_failed_with_pm:
10385         sema_v(&un->un_semoclose);
10386 
10387         mutex_enter(&sd_detach_mutex);
10388         un->un_opens_in_progress--;
10389         if (otyp == OTYP_LYR) {
10390                 un->un_layer_count--;
10391         }
10392         mutex_exit(&sd_detach_mutex);
10393 
10394         return (rval);
10395 }
10396 
10397 
10398 /*
10399  *    Function: sdclose
10400  *
10401  * Description: Driver's close(9e) entry point function.
10402  *
10403  *   Arguments: dev    - device number
10404  *              flag   - file status flag, informational only
10405  *              otyp   - close type (OTYP_BLK, OTYP_CHR, OTYP_LYR)
10406  *              cred_p - user credential pointer
10407  *
10408  * Return Code: ENXIO
10409  *
10410  *     Context: Kernel thread context
10411  */
10412 /* ARGSUSED */
10413 static int
10414 sdclose(dev_t dev, int flag, int otyp, cred_t *cred_p)
10415 {
10416         struct sd_lun   *un;
10417         uchar_t         *cp;
10418         int             part;
10419         int             nodelay;
10420         int             rval = 0;
10421 
10422         /* Validate the open type */
10423         if (otyp >= OTYPCNT) {
10424                 return (ENXIO);
10425         }
10426 
10427         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
10428                 return (ENXIO);
10429         }
10430 
10431         part = SDPART(dev);
10432         nodelay = flag & (FNDELAY | FNONBLOCK);
10433 
10434         SD_TRACE(SD_LOG_OPEN_CLOSE, un,
10435             "sdclose: close of part %d type %d\n", part, otyp);
10436 
10437         /*
10438          * We use a semaphore here in order to serialize
10439          * open and close requests on the device.
10440          */
10441         sema_p(&un->un_semoclose);
10442 
10443         mutex_enter(SD_MUTEX(un));
10444 
10445         /* Don't proceed if power is being changed. */
10446         while (un->un_state == SD_STATE_PM_CHANGING) {
10447                 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
10448         }
10449 
10450         if (un->un_exclopen & (1 << part)) {
10451                 un->un_exclopen &= ~(1 << part);
10452         }
10453 
10454         /* Update the open partition map */
10455         if (otyp == OTYP_LYR) {
10456                 un->un_ocmap.lyropen[part] -= 1;
10457         } else {
10458                 un->un_ocmap.regopen[otyp] &= ~(1 << part);
10459         }
10460 
10461         cp = &un->un_ocmap.chkd[0];
10462         while (cp < &un->un_ocmap.chkd[OCSIZE]) {
10463                 if (*cp != NULL) {
10464                         break;
10465                 }
10466                 cp++;
10467         }
10468 
10469         if (cp == &un->un_ocmap.chkd[OCSIZE]) {
10470                 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdclose: last close\n");
10471 
10472                 /*
10473                  * We avoid persistance upon the last close, and set
10474                  * the throttle back to the maximum.
10475                  */
10476                 un->un_throttle = un->un_saved_throttle;
10477 
10478                 if (un->un_state == SD_STATE_OFFLINE) {
10479                         if (un->un_f_is_fibre == FALSE) {
10480                                 scsi_log(SD_DEVINFO(un), sd_label,
10481                                     CE_WARN, "offline\n");
10482                         }
10483                         mutex_exit(SD_MUTEX(un));
10484                         cmlb_invalidate(un->un_cmlbhandle,
10485                             (void *)SD_PATH_DIRECT);
10486                         mutex_enter(SD_MUTEX(un));
10487 
10488                 } else {
10489                         /*
10490                          * Flush any outstanding writes in NVRAM cache.
10491                          * Note: SYNCHRONIZE CACHE is an optional SCSI-2
10492                          * cmd, it may not work for non-Pluto devices.
10493                          * SYNCHRONIZE CACHE is not required for removables,
10494                          * except DVD-RAM drives.
10495                          *
10496                          * Also note: because SYNCHRONIZE CACHE is currently
10497                          * the only command issued here that requires the
10498                          * drive be powered up, only do the power up before
10499                          * sending the Sync Cache command. If additional
10500                          * commands are added which require a powered up
10501                          * drive, the following sequence may have to change.
10502                          *
10503                          * And finally, note that parallel SCSI on SPARC
10504                          * only issues a Sync Cache to DVD-RAM, a newly
10505                          * supported device.
10506                          */
10507 #if defined(__i386) || defined(__amd64)
10508                         if ((un->un_f_sync_cache_supported &&
10509                             un->un_f_sync_cache_required) ||
10510                             un->un_f_dvdram_writable_device == TRUE) {
10511 #else
10512                         if (un->un_f_dvdram_writable_device == TRUE) {
10513 #endif
10514                                 mutex_exit(SD_MUTEX(un));
10515                                 if (sd_pm_entry(un) == DDI_SUCCESS) {
10516                                         rval =
10517                                             sd_send_scsi_SYNCHRONIZE_CACHE(un,
10518                                             NULL);
10519                                         /* ignore error if not supported */
10520                                         if (rval == ENOTSUP) {
10521                                                 rval = 0;
10522                                         } else if (rval != 0) {
10523                                                 rval = EIO;
10524                                         }
10525                                         sd_pm_exit(un);
10526                                 } else {
10527                                         rval = EIO;
10528                                 }
10529                                 mutex_enter(SD_MUTEX(un));
10530                         }
10531 
10532                         /*
10533                          * For devices which supports DOOR_LOCK, send an ALLOW
10534                          * MEDIA REMOVAL command, but don't get upset if it
10535                          * fails. We need to raise the power of the drive before
10536                          * we can call sd_send_scsi_DOORLOCK()
10537                          */
10538                         if (un->un_f_doorlock_supported) {
10539                                 mutex_exit(SD_MUTEX(un));
10540                                 if (sd_pm_entry(un) == DDI_SUCCESS) {
10541                                         sd_ssc_t        *ssc;
10542 
10543                                         ssc = sd_ssc_init(un);
10544                                         rval = sd_send_scsi_DOORLOCK(ssc,
10545                                             SD_REMOVAL_ALLOW, SD_PATH_DIRECT);
10546                                         if (rval != 0)
10547                                                 sd_ssc_assessment(ssc,
10548                                                     SD_FMT_IGNORE);
10549                                         sd_ssc_fini(ssc);
10550 
10551                                         sd_pm_exit(un);
10552                                         if (ISCD(un) && (rval != 0) &&
10553                                             (nodelay != 0)) {
10554                                                 rval = ENXIO;
10555                                         }
10556                                 } else {
10557                                         rval = EIO;
10558                                 }
10559                                 mutex_enter(SD_MUTEX(un));
10560                         }
10561 
10562                         /*
10563                          * If a device has removable media, invalidate all
10564                          * parameters related to media, such as geometry,
10565                          * blocksize, and blockcount.
10566                          */
10567                         if (un->un_f_has_removable_media) {
10568                                 sr_ejected(un);
10569                         }
10570 
10571                         /*
10572                          * Destroy the cache (if it exists) which was
10573                          * allocated for the write maps since this is
10574                          * the last close for this media.
10575                          */
10576                         if (un->un_wm_cache) {
10577                                 /*
10578                                  * Check if there are pending commands.
10579                                  * and if there are give a warning and
10580                                  * do not destroy the cache.
10581                                  */
10582                                 if (un->un_ncmds_in_driver > 0) {
10583                                         scsi_log(SD_DEVINFO(un),
10584                                             sd_label, CE_WARN,
10585                                             "Unable to clean up memory "
10586                                             "because of pending I/O\n");
10587                                 } else {
10588                                         kmem_cache_destroy(
10589                                             un->un_wm_cache);
10590                                         un->un_wm_cache = NULL;
10591                                 }
10592                         }
10593                 }
10594         }
10595 
10596         mutex_exit(SD_MUTEX(un));
10597         sema_v(&un->un_semoclose);
10598 
10599         if (otyp == OTYP_LYR) {
10600                 mutex_enter(&sd_detach_mutex);
10601                 /*
10602                  * The detach routine may run when the layer count
10603                  * drops to zero.
10604                  */
10605                 un->un_layer_count--;
10606                 mutex_exit(&sd_detach_mutex);
10607         }
10608 
10609         return (rval);
10610 }
10611 
10612 
10613 /*
10614  *    Function: sd_ready_and_valid
10615  *
10616  * Description: Test if device is ready and has a valid geometry.
10617  *
10618  *   Arguments: ssc - sd_ssc_t will contain un
10619  *              un  - driver soft state (unit) structure
10620  *
10621  * Return Code: SD_READY_VALID          ready and valid label
10622  *              SD_NOT_READY_VALID      not ready, no label
10623  *              SD_RESERVED_BY_OTHERS   reservation conflict
10624  *
10625  *     Context: Never called at interrupt context.
10626  */
10627 
10628 static int
10629 sd_ready_and_valid(sd_ssc_t *ssc, int part)
10630 {
10631         struct sd_errstats      *stp;
10632         uint64_t                capacity;
10633         uint_t                  lbasize;
10634         int                     rval = SD_READY_VALID;
10635         char                    name_str[48];
10636         boolean_t               is_valid;
10637         struct sd_lun           *un;
10638         int                     status;
10639 
10640         ASSERT(ssc != NULL);
10641         un = ssc->ssc_un;
10642         ASSERT(un != NULL);
10643         ASSERT(!mutex_owned(SD_MUTEX(un)));
10644 
10645         mutex_enter(SD_MUTEX(un));
10646         /*
10647          * If a device has removable media, we must check if media is
10648          * ready when checking if this device is ready and valid.
10649          */
10650         if (un->un_f_has_removable_media) {
10651                 mutex_exit(SD_MUTEX(un));
10652                 status = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
10653 
10654                 if (status != 0) {
10655                         rval = SD_NOT_READY_VALID;
10656                         mutex_enter(SD_MUTEX(un));
10657 
10658                         /* Ignore all failed status for removalbe media */
10659                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10660 
10661                         goto done;
10662                 }
10663 
10664                 is_valid = SD_IS_VALID_LABEL(un);
10665                 mutex_enter(SD_MUTEX(un));
10666                 if (!is_valid ||
10667                     (un->un_f_blockcount_is_valid == FALSE) ||
10668                     (un->un_f_tgt_blocksize_is_valid == FALSE)) {
10669 
10670                         /* capacity has to be read every open. */
10671                         mutex_exit(SD_MUTEX(un));
10672                         status = sd_send_scsi_READ_CAPACITY(ssc, &capacity,
10673                             &lbasize, SD_PATH_DIRECT);
10674 
10675                         if (status != 0) {
10676                                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10677 
10678                                 cmlb_invalidate(un->un_cmlbhandle,
10679                                     (void *)SD_PATH_DIRECT);
10680                                 mutex_enter(SD_MUTEX(un));
10681                                 rval = SD_NOT_READY_VALID;
10682 
10683                                 goto done;
10684                         } else {
10685                                 mutex_enter(SD_MUTEX(un));
10686                                 sd_update_block_info(un, lbasize, capacity);
10687                         }
10688                 }
10689 
10690                 /*
10691                  * Check if the media in the device is writable or not.
10692                  */
10693                 if (!is_valid && ISCD(un)) {
10694                         sd_check_for_writable_cd(ssc, SD_PATH_DIRECT);
10695                 }
10696 
10697         } else {
10698                 /*
10699                  * Do a test unit ready to clear any unit attention from non-cd
10700                  * devices.
10701                  */
10702                 mutex_exit(SD_MUTEX(un));
10703 
10704                 status = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
10705                 if (status != 0) {
10706                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10707                 }
10708 
10709                 mutex_enter(SD_MUTEX(un));
10710         }
10711 
10712 
10713         /*
10714          * If this is a non 512 block device, allocate space for
10715          * the wmap cache. This is being done here since every time
10716          * a media is changed this routine will be called and the
10717          * block size is a function of media rather than device.
10718          */
10719         if (((un->un_f_rmw_type != SD_RMW_TYPE_RETURN_ERROR ||
10720             un->un_f_non_devbsize_supported) &&
10721             un->un_tgt_blocksize != DEV_BSIZE) ||
10722             un->un_f_enable_rmw) {
10723                 if (!(un->un_wm_cache)) {
10724                         (void) snprintf(name_str, sizeof (name_str),
10725                             "%s%d_cache",
10726                             ddi_driver_name(SD_DEVINFO(un)),
10727                             ddi_get_instance(SD_DEVINFO(un)));
10728                         un->un_wm_cache = kmem_cache_create(
10729                             name_str, sizeof (struct sd_w_map),
10730                             8, sd_wm_cache_constructor,
10731                             sd_wm_cache_destructor, NULL,
10732                             (void *)un, NULL, 0);
10733                         if (!(un->un_wm_cache)) {
10734                                 rval = ENOMEM;
10735                                 goto done;
10736                         }
10737                 }
10738         }
10739 
10740         if (un->un_state == SD_STATE_NORMAL) {
10741                 /*
10742                  * If the target is not yet ready here (defined by a TUR
10743                  * failure), invalidate the geometry and print an 'offline'
10744                  * message. This is a legacy message, as the state of the
10745                  * target is not actually changed to SD_STATE_OFFLINE.
10746                  *
10747                  * If the TUR fails for EACCES (Reservation Conflict),
10748                  * SD_RESERVED_BY_OTHERS will be returned to indicate
10749                  * reservation conflict. If the TUR fails for other
10750                  * reasons, SD_NOT_READY_VALID will be returned.
10751                  */
10752                 int err;
10753 
10754                 mutex_exit(SD_MUTEX(un));
10755                 err = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
10756                 mutex_enter(SD_MUTEX(un));
10757 
10758                 if (err != 0) {
10759                         mutex_exit(SD_MUTEX(un));
10760                         cmlb_invalidate(un->un_cmlbhandle,
10761                             (void *)SD_PATH_DIRECT);
10762                         mutex_enter(SD_MUTEX(un));
10763                         if (err == EACCES) {
10764                                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
10765                                     "reservation conflict\n");
10766                                 rval = SD_RESERVED_BY_OTHERS;
10767                                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10768                         } else {
10769                                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
10770                                     "drive offline\n");
10771                                 rval = SD_NOT_READY_VALID;
10772                                 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
10773                         }
10774                         goto done;
10775                 }
10776         }
10777 
10778         if (un->un_f_format_in_progress == FALSE) {
10779                 mutex_exit(SD_MUTEX(un));
10780 
10781                 (void) cmlb_validate(un->un_cmlbhandle, 0,
10782                     (void *)SD_PATH_DIRECT);
10783                 if (cmlb_partinfo(un->un_cmlbhandle, part, NULL, NULL, NULL,
10784                     NULL, (void *) SD_PATH_DIRECT) != 0) {
10785                         rval = SD_NOT_READY_VALID;
10786                         mutex_enter(SD_MUTEX(un));
10787 
10788                         goto done;
10789                 }
10790                 if (un->un_f_pkstats_enabled) {
10791                         sd_set_pstats(un);
10792                         SD_TRACE(SD_LOG_IO_PARTITION, un,
10793                             "sd_ready_and_valid: un:0x%p pstats created and "
10794                             "set\n", un);
10795                 }
10796                 mutex_enter(SD_MUTEX(un));
10797         }
10798 
10799         /*
10800          * If this device supports DOOR_LOCK command, try and send
10801          * this command to PREVENT MEDIA REMOVAL, but don't get upset
10802          * if it fails. For a CD, however, it is an error
10803          */
10804         if (un->un_f_doorlock_supported) {
10805                 mutex_exit(SD_MUTEX(un));
10806                 status = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_PREVENT,
10807                     SD_PATH_DIRECT);
10808 
10809                 if ((status != 0) && ISCD(un)) {
10810                         rval = SD_NOT_READY_VALID;
10811                         mutex_enter(SD_MUTEX(un));
10812 
10813                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10814 
10815                         goto done;
10816                 } else if (status != 0)
10817                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
10818                 mutex_enter(SD_MUTEX(un));
10819         }
10820 
10821         /* The state has changed, inform the media watch routines */
10822         un->un_mediastate = DKIO_INSERTED;
10823         cv_broadcast(&un->un_state_cv);
10824         rval = SD_READY_VALID;
10825 
10826 done:
10827 
10828         /*
10829          * Initialize the capacity kstat value, if no media previously
10830          * (capacity kstat is 0) and a media has been inserted
10831          * (un_blockcount > 0).
10832          */
10833         if (un->un_errstats != NULL) {
10834                 stp = (struct sd_errstats *)un->un_errstats->ks_data;
10835                 if ((stp->sd_capacity.value.ui64 == 0) &&
10836                     (un->un_f_blockcount_is_valid == TRUE)) {
10837                         stp->sd_capacity.value.ui64 =
10838                             (uint64_t)((uint64_t)un->un_blockcount *
10839                             un->un_sys_blocksize);
10840                 }
10841         }
10842 
10843         mutex_exit(SD_MUTEX(un));
10844         return (rval);
10845 }
10846 
10847 
10848 /*
10849  *    Function: sdmin
10850  *
10851  * Description: Routine to limit the size of a data transfer. Used in
10852  *              conjunction with physio(9F).
10853  *
10854  *   Arguments: bp - pointer to the indicated buf(9S) struct.
10855  *
10856  *     Context: Kernel thread context.
10857  */
10858 
10859 static void
10860 sdmin(struct buf *bp)
10861 {
10862         struct sd_lun   *un;
10863         int             instance;
10864 
10865         instance = SDUNIT(bp->b_edev);
10866 
10867         un = ddi_get_soft_state(sd_state, instance);
10868         ASSERT(un != NULL);
10869 
10870         /*
10871          * We depend on buf breakup to restrict
10872          * IO size if it is enabled.
10873          */
10874         if (un->un_buf_breakup_supported) {
10875                 return;
10876         }
10877 
10878         if (bp->b_bcount > un->un_max_xfer_size) {
10879                 bp->b_bcount = un->un_max_xfer_size;
10880         }
10881 }
10882 
10883 
10884 /*
10885  *    Function: sdread
10886  *
10887  * Description: Driver's read(9e) entry point function.
10888  *
10889  *   Arguments: dev   - device number
10890  *              uio   - structure pointer describing where data is to be stored
10891  *                      in user's space
10892  *              cred_p  - user credential pointer
10893  *
10894  * Return Code: ENXIO
10895  *              EIO
10896  *              EINVAL
10897  *              value returned by physio
10898  *
10899  *     Context: Kernel thread context.
10900  */
10901 /* ARGSUSED */
10902 static int
10903 sdread(dev_t dev, struct uio *uio, cred_t *cred_p)
10904 {
10905         struct sd_lun   *un = NULL;
10906         int             secmask;
10907         int             err = 0;
10908         sd_ssc_t        *ssc;
10909 
10910         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
10911                 return (ENXIO);
10912         }
10913 
10914         ASSERT(!mutex_owned(SD_MUTEX(un)));
10915 
10916 
10917         if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
10918                 mutex_enter(SD_MUTEX(un));
10919                 /*
10920                  * Because the call to sd_ready_and_valid will issue I/O we
10921                  * must wait here if either the device is suspended or
10922                  * if it's power level is changing.
10923                  */
10924                 while ((un->un_state == SD_STATE_SUSPENDED) ||
10925                     (un->un_state == SD_STATE_PM_CHANGING)) {
10926                         cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
10927                 }
10928                 un->un_ncmds_in_driver++;
10929                 mutex_exit(SD_MUTEX(un));
10930 
10931                 /* Initialize sd_ssc_t for internal uscsi commands */
10932                 ssc = sd_ssc_init(un);
10933                 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) {
10934                         err = EIO;
10935                 } else {
10936                         err = 0;
10937                 }
10938                 sd_ssc_fini(ssc);
10939 
10940                 mutex_enter(SD_MUTEX(un));
10941                 un->un_ncmds_in_driver--;
10942                 ASSERT(un->un_ncmds_in_driver >= 0);
10943                 mutex_exit(SD_MUTEX(un));
10944                 if (err != 0)
10945                         return (err);
10946         }
10947 
10948         /*
10949          * Read requests are restricted to multiples of the system block size.
10950          */
10951         if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR &&
10952             !un->un_f_enable_rmw)
10953                 secmask = un->un_tgt_blocksize - 1;
10954         else
10955                 secmask = DEV_BSIZE - 1;
10956 
10957         if (uio->uio_loffset & ((offset_t)(secmask))) {
10958                 SD_ERROR(SD_LOG_READ_WRITE, un,
10959                     "sdread: file offset not modulo %d\n",
10960                     secmask + 1);
10961                 err = EINVAL;
10962         } else if (uio->uio_iov->iov_len & (secmask)) {
10963                 SD_ERROR(SD_LOG_READ_WRITE, un,
10964                     "sdread: transfer length not modulo %d\n",
10965                     secmask + 1);
10966                 err = EINVAL;
10967         } else {
10968                 err = physio(sdstrategy, NULL, dev, B_READ, sdmin, uio);
10969         }
10970 
10971         return (err);
10972 }
10973 
10974 
10975 /*
10976  *    Function: sdwrite
10977  *
10978  * Description: Driver's write(9e) entry point function.
10979  *
10980  *   Arguments: dev   - device number
10981  *              uio   - structure pointer describing where data is stored in
10982  *                      user's space
10983  *              cred_p  - user credential pointer
10984  *
10985  * Return Code: ENXIO
10986  *              EIO
10987  *              EINVAL
10988  *              value returned by physio
10989  *
10990  *     Context: Kernel thread context.
10991  */
10992 /* ARGSUSED */
10993 static int
10994 sdwrite(dev_t dev, struct uio *uio, cred_t *cred_p)
10995 {
10996         struct sd_lun   *un = NULL;
10997         int             secmask;
10998         int             err = 0;
10999         sd_ssc_t        *ssc;
11000 
11001         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
11002                 return (ENXIO);
11003         }
11004 
11005         ASSERT(!mutex_owned(SD_MUTEX(un)));
11006 
11007         if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
11008                 mutex_enter(SD_MUTEX(un));
11009                 /*
11010                  * Because the call to sd_ready_and_valid will issue I/O we
11011                  * must wait here if either the device is suspended or
11012                  * if it's power level is changing.
11013                  */
11014                 while ((un->un_state == SD_STATE_SUSPENDED) ||
11015                     (un->un_state == SD_STATE_PM_CHANGING)) {
11016                         cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
11017                 }
11018                 un->un_ncmds_in_driver++;
11019                 mutex_exit(SD_MUTEX(un));
11020 
11021                 /* Initialize sd_ssc_t for internal uscsi commands */
11022                 ssc = sd_ssc_init(un);
11023                 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) {
11024                         err = EIO;
11025                 } else {
11026                         err = 0;
11027                 }
11028                 sd_ssc_fini(ssc);
11029 
11030                 mutex_enter(SD_MUTEX(un));
11031                 un->un_ncmds_in_driver--;
11032                 ASSERT(un->un_ncmds_in_driver >= 0);
11033                 mutex_exit(SD_MUTEX(un));
11034                 if (err != 0)
11035                         return (err);
11036         }
11037 
11038         /*
11039          * Write requests are restricted to multiples of the system block size.
11040          */
11041         if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR &&
11042             !un->un_f_enable_rmw)
11043                 secmask = un->un_tgt_blocksize - 1;
11044         else
11045                 secmask = DEV_BSIZE - 1;
11046 
11047         if (uio->uio_loffset & ((offset_t)(secmask))) {
11048                 SD_ERROR(SD_LOG_READ_WRITE, un,
11049                     "sdwrite: file offset not modulo %d\n",
11050                     secmask + 1);
11051                 err = EINVAL;
11052         } else if (uio->uio_iov->iov_len & (secmask)) {
11053                 SD_ERROR(SD_LOG_READ_WRITE, un,
11054                     "sdwrite: transfer length not modulo %d\n",
11055                     secmask + 1);
11056                 err = EINVAL;
11057         } else {
11058                 err = physio(sdstrategy, NULL, dev, B_WRITE, sdmin, uio);
11059         }
11060 
11061         return (err);
11062 }
11063 
11064 
11065 /*
11066  *    Function: sdaread
11067  *
11068  * Description: Driver's aread(9e) entry point function.
11069  *
11070  *   Arguments: dev   - device number
11071  *              aio   - structure pointer describing where data is to be stored
11072  *              cred_p  - user credential pointer
11073  *
11074  * Return Code: ENXIO
11075  *              EIO
11076  *              EINVAL
11077  *              value returned by aphysio
11078  *
11079  *     Context: Kernel thread context.
11080  */
11081 /* ARGSUSED */
11082 static int
11083 sdaread(dev_t dev, struct aio_req *aio, cred_t *cred_p)
11084 {
11085         struct sd_lun   *un = NULL;
11086         struct uio      *uio = aio->aio_uio;
11087         int             secmask;
11088         int             err = 0;
11089         sd_ssc_t        *ssc;
11090 
11091         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
11092                 return (ENXIO);
11093         }
11094 
11095         ASSERT(!mutex_owned(SD_MUTEX(un)));
11096 
11097         if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
11098                 mutex_enter(SD_MUTEX(un));
11099                 /*
11100                  * Because the call to sd_ready_and_valid will issue I/O we
11101                  * must wait here if either the device is suspended or
11102                  * if it's power level is changing.
11103                  */
11104                 while ((un->un_state == SD_STATE_SUSPENDED) ||
11105                     (un->un_state == SD_STATE_PM_CHANGING)) {
11106                         cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
11107                 }
11108                 un->un_ncmds_in_driver++;
11109                 mutex_exit(SD_MUTEX(un));
11110 
11111                 /* Initialize sd_ssc_t for internal uscsi commands */
11112                 ssc = sd_ssc_init(un);
11113                 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) {
11114                         err = EIO;
11115                 } else {
11116                         err = 0;
11117                 }
11118                 sd_ssc_fini(ssc);
11119 
11120                 mutex_enter(SD_MUTEX(un));
11121                 un->un_ncmds_in_driver--;
11122                 ASSERT(un->un_ncmds_in_driver >= 0);
11123                 mutex_exit(SD_MUTEX(un));
11124                 if (err != 0)
11125                         return (err);
11126         }
11127 
11128         /*
11129          * Read requests are restricted to multiples of the system block size.
11130          */
11131         if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR &&
11132             !un->un_f_enable_rmw)
11133                 secmask = un->un_tgt_blocksize - 1;
11134         else
11135                 secmask = DEV_BSIZE - 1;
11136 
11137         if (uio->uio_loffset & ((offset_t)(secmask))) {
11138                 SD_ERROR(SD_LOG_READ_WRITE, un,
11139                     "sdaread: file offset not modulo %d\n",
11140                     secmask + 1);
11141                 err = EINVAL;
11142         } else if (uio->uio_iov->iov_len & (secmask)) {
11143                 SD_ERROR(SD_LOG_READ_WRITE, un,
11144                     "sdaread: transfer length not modulo %d\n",
11145                     secmask + 1);
11146                 err = EINVAL;
11147         } else {
11148                 err = aphysio(sdstrategy, anocancel, dev, B_READ, sdmin, aio);
11149         }
11150 
11151         return (err);
11152 }
11153 
11154 
11155 /*
11156  *    Function: sdawrite
11157  *
11158  * Description: Driver's awrite(9e) entry point function.
11159  *
11160  *   Arguments: dev   - device number
11161  *              aio   - structure pointer describing where data is stored
11162  *              cred_p  - user credential pointer
11163  *
11164  * Return Code: ENXIO
11165  *              EIO
11166  *              EINVAL
11167  *              value returned by aphysio
11168  *
11169  *     Context: Kernel thread context.
11170  */
11171 /* ARGSUSED */
11172 static int
11173 sdawrite(dev_t dev, struct aio_req *aio, cred_t *cred_p)
11174 {
11175         struct sd_lun   *un = NULL;
11176         struct uio      *uio = aio->aio_uio;
11177         int             secmask;
11178         int             err = 0;
11179         sd_ssc_t        *ssc;
11180 
11181         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
11182                 return (ENXIO);
11183         }
11184 
11185         ASSERT(!mutex_owned(SD_MUTEX(un)));
11186 
11187         if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) {
11188                 mutex_enter(SD_MUTEX(un));
11189                 /*
11190                  * Because the call to sd_ready_and_valid will issue I/O we
11191                  * must wait here if either the device is suspended or
11192                  * if it's power level is changing.
11193                  */
11194                 while ((un->un_state == SD_STATE_SUSPENDED) ||
11195                     (un->un_state == SD_STATE_PM_CHANGING)) {
11196                         cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
11197                 }
11198                 un->un_ncmds_in_driver++;
11199                 mutex_exit(SD_MUTEX(un));
11200 
11201                 /* Initialize sd_ssc_t for internal uscsi commands */
11202                 ssc = sd_ssc_init(un);
11203                 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) {
11204                         err = EIO;
11205                 } else {
11206                         err = 0;
11207                 }
11208                 sd_ssc_fini(ssc);
11209 
11210                 mutex_enter(SD_MUTEX(un));
11211                 un->un_ncmds_in_driver--;
11212                 ASSERT(un->un_ncmds_in_driver >= 0);
11213                 mutex_exit(SD_MUTEX(un));
11214                 if (err != 0)
11215                         return (err);
11216         }
11217 
11218         /*
11219          * Write requests are restricted to multiples of the system block size.
11220          */
11221         if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR &&
11222             !un->un_f_enable_rmw)
11223                 secmask = un->un_tgt_blocksize - 1;
11224         else
11225                 secmask = DEV_BSIZE - 1;
11226 
11227         if (uio->uio_loffset & ((offset_t)(secmask))) {
11228                 SD_ERROR(SD_LOG_READ_WRITE, un,
11229                     "sdawrite: file offset not modulo %d\n",
11230                     secmask + 1);
11231                 err = EINVAL;
11232         } else if (uio->uio_iov->iov_len & (secmask)) {
11233                 SD_ERROR(SD_LOG_READ_WRITE, un,
11234                     "sdawrite: transfer length not modulo %d\n",
11235                     secmask + 1);
11236                 err = EINVAL;
11237         } else {
11238                 err = aphysio(sdstrategy, anocancel, dev, B_WRITE, sdmin, aio);
11239         }
11240 
11241         return (err);
11242 }
11243 
11244 
11245 
11246 
11247 
11248 /*
11249  * Driver IO processing follows the following sequence:
11250  *
11251  *     sdioctl(9E)     sdstrategy(9E)         biodone(9F)
11252  *         |                |                     ^
11253  *         v                v                     |
11254  * sd_send_scsi_cmd()  ddi_xbuf_qstrategy()       +-------------------+
11255  *         |                |                     |                   |
11256  *         v                |                     |                   |
11257  * sd_uscsi_strategy() sd_xbuf_strategy()   sd_buf_iodone()   sd_uscsi_iodone()
11258  *         |                |                     ^                   ^
11259  *         v                v                     |                   |
11260  * SD_BEGIN_IOSTART()  SD_BEGIN_IOSTART()         |                   |
11261  *         |                |                     |                   |
11262  *     +---+                |                     +------------+      +-------+
11263  *     |                    |                                  |              |
11264  *     |   SD_NEXT_IOSTART()|                  SD_NEXT_IODONE()|              |
11265  *     |                    v                                  |              |
11266  *     |         sd_mapblockaddr_iostart()           sd_mapblockaddr_iodone() |
11267  *     |                    |                                  ^              |
11268  *     |   SD_NEXT_IOSTART()|                  SD_NEXT_IODONE()|              |
11269  *     |                    v                                  |              |
11270  *     |         sd_mapblocksize_iostart()           sd_mapblocksize_iodone() |
11271  *     |                    |                                  ^              |
11272  *     |   SD_NEXT_IOSTART()|                  SD_NEXT_IODONE()|              |
11273  *     |                    v                                  |              |
11274  *     |           sd_checksum_iostart()               sd_checksum_iodone()   |
11275  *     |                    |                                  ^              |
11276  *     +-> SD_NEXT_IOSTART()|                  SD_NEXT_IODONE()+------------->+
11277  *     |                    v                                  |              |
11278  *     |              sd_pm_iostart()                     sd_pm_iodone()      |
11279  *     |                    |                                  ^              |
11280  *     |                    |                                  |              |
11281  *     +-> SD_NEXT_IOSTART()|               SD_BEGIN_IODONE()--+--------------+
11282  *                          |                           ^
11283  *                          v                           |
11284  *                   sd_core_iostart()                  |
11285  *                          |                           |
11286  *                          |                           +------>(*destroypkt)()
11287  *                          +-> sd_start_cmds() <-+     |           |
11288  *                          |                     |     |           v
11289  *                          |                     |     |  scsi_destroy_pkt(9F)
11290  *                          |                     |     |
11291  *                          +->(*initpkt)()       +- sdintr()
11292  *                          |  |                        |  |
11293  *                          |  +-> scsi_init_pkt(9F)    |  +-> sd_handle_xxx()
11294  *                          |  +-> scsi_setup_cdb(9F)   |
11295  *                          |                           |
11296  *                          +--> scsi_transport(9F)     |
11297  *                                     |                |
11298  *                                     +----> SCSA ---->+
11299  *
11300  *
11301  * This code is based upon the following presumptions:
11302  *
11303  *   - iostart and iodone functions operate on buf(9S) structures. These
11304  *     functions perform the necessary operations on the buf(9S) and pass
11305  *     them along to the next function in the chain by using the macros
11306  *     SD_NEXT_IOSTART() (for iostart side functions) and SD_NEXT_IODONE()
11307  *     (for iodone side functions).
11308  *
11309  *   - The iostart side functions may sleep. The iodone side functions
11310  *     are called under interrupt context and may NOT sleep. Therefore
11311  *     iodone side functions also may not call iostart side functions.
11312  *     (NOTE: iostart side functions should NOT sleep for memory, as
11313  *     this could result in deadlock.)
11314  *
11315  *   - An iostart side function may call its corresponding iodone side
11316  *     function directly (if necessary).
11317  *
11318  *   - In the event of an error, an iostart side function can return a buf(9S)
11319  *     to its caller by calling SD_BEGIN_IODONE() (after setting B_ERROR and
11320  *     b_error in the usual way of course).
11321  *
11322  *   - The taskq mechanism may be used by the iodone side functions to dispatch
11323  *     requests to the iostart side functions.  The iostart side functions in
11324  *     this case would be called under the context of a taskq thread, so it's
11325  *     OK for them to block/sleep/spin in this case.
11326  *
11327  *   - iostart side functions may allocate "shadow" buf(9S) structs and
11328  *     pass them along to the next function in the chain.  The corresponding
11329  *     iodone side functions must coalesce the "shadow" bufs and return
11330  *     the "original" buf to the next higher layer.
11331  *
11332  *   - The b_private field of the buf(9S) struct holds a pointer to
11333  *     an sd_xbuf struct, which contains information needed to
11334  *     construct the scsi_pkt for the command.
11335  *
11336  *   - The SD_MUTEX(un) is NOT held across calls to the next layer. Each
11337  *     layer must acquire & release the SD_MUTEX(un) as needed.
11338  */
11339 
11340 
11341 /*
11342  * Create taskq for all targets in the system. This is created at
11343  * _init(9E) and destroyed at _fini(9E).
11344  *
11345  * Note: here we set the minalloc to a reasonably high number to ensure that
11346  * we will have an adequate supply of task entries available at interrupt time.
11347  * This is used in conjunction with the TASKQ_PREPOPULATE flag in
11348  * sd_create_taskq().  Since we do not want to sleep for allocations at
11349  * interrupt time, set maxalloc equal to minalloc. That way we will just fail
11350  * the command if we ever try to dispatch more than SD_TASKQ_MAXALLOC taskq
11351  * requests any one instant in time.
11352  */
11353 #define SD_TASKQ_NUMTHREADS     8
11354 #define SD_TASKQ_MINALLOC       256
11355 #define SD_TASKQ_MAXALLOC       256
11356 
11357 static taskq_t  *sd_tq = NULL;
11358 _NOTE(SCHEME_PROTECTS_DATA("stable data", sd_tq))
11359 
11360 static int      sd_taskq_minalloc = SD_TASKQ_MINALLOC;
11361 static int      sd_taskq_maxalloc = SD_TASKQ_MAXALLOC;
11362 
11363 /*
11364  * The following task queue is being created for the write part of
11365  * read-modify-write of non-512 block size devices.
11366  * Limit the number of threads to 1 for now. This number has been chosen
11367  * considering the fact that it applies only to dvd ram drives/MO drives
11368  * currently. Performance for which is not main criteria at this stage.
11369  * Note: It needs to be explored if we can use a single taskq in future
11370  */
11371 #define SD_WMR_TASKQ_NUMTHREADS 1
11372 static taskq_t  *sd_wmr_tq = NULL;
11373 _NOTE(SCHEME_PROTECTS_DATA("stable data", sd_wmr_tq))
11374 
11375 /*
11376  *    Function: sd_taskq_create
11377  *
11378  * Description: Create taskq thread(s) and preallocate task entries
11379  *
11380  * Return Code: Returns a pointer to the allocated taskq_t.
11381  *
11382  *     Context: Can sleep. Requires blockable context.
11383  *
11384  *       Notes: - The taskq() facility currently is NOT part of the DDI.
11385  *                (definitely NOT recommeded for 3rd-party drivers!) :-)
11386  *              - taskq_create() will block for memory, also it will panic
11387  *                if it cannot create the requested number of threads.
11388  *              - Currently taskq_create() creates threads that cannot be
11389  *                swapped.
11390  *              - We use TASKQ_PREPOPULATE to ensure we have an adequate
11391  *                supply of taskq entries at interrupt time (ie, so that we
11392  *                do not have to sleep for memory)
11393  */
11394 
11395 static void
11396 sd_taskq_create(void)
11397 {
11398         char    taskq_name[TASKQ_NAMELEN];
11399 
11400         ASSERT(sd_tq == NULL);
11401         ASSERT(sd_wmr_tq == NULL);
11402 
11403         (void) snprintf(taskq_name, sizeof (taskq_name),
11404             "%s_drv_taskq", sd_label);
11405         sd_tq = (taskq_create(taskq_name, SD_TASKQ_NUMTHREADS,
11406             (v.v_maxsyspri - 2), sd_taskq_minalloc, sd_taskq_maxalloc,
11407             TASKQ_PREPOPULATE));
11408 
11409         (void) snprintf(taskq_name, sizeof (taskq_name),
11410             "%s_rmw_taskq", sd_label);
11411         sd_wmr_tq = (taskq_create(taskq_name, SD_WMR_TASKQ_NUMTHREADS,
11412             (v.v_maxsyspri - 2), sd_taskq_minalloc, sd_taskq_maxalloc,
11413             TASKQ_PREPOPULATE));
11414 }
11415 
11416 
11417 /*
11418  *    Function: sd_taskq_delete
11419  *
11420  * Description: Complementary cleanup routine for sd_taskq_create().
11421  *
11422  *     Context: Kernel thread context.
11423  */
11424 
11425 static void
11426 sd_taskq_delete(void)
11427 {
11428         ASSERT(sd_tq != NULL);
11429         ASSERT(sd_wmr_tq != NULL);
11430         taskq_destroy(sd_tq);
11431         taskq_destroy(sd_wmr_tq);
11432         sd_tq = NULL;
11433         sd_wmr_tq = NULL;
11434 }
11435 
11436 
11437 /*
11438  *    Function: sdstrategy
11439  *
11440  * Description: Driver's strategy (9E) entry point function.
11441  *
11442  *   Arguments: bp - pointer to buf(9S)
11443  *
11444  * Return Code: Always returns zero
11445  *
11446  *     Context: Kernel thread context.
11447  */
11448 
11449 static int
11450 sdstrategy(struct buf *bp)
11451 {
11452         struct sd_lun *un;
11453 
11454         un = ddi_get_soft_state(sd_state, SD_GET_INSTANCE_FROM_BUF(bp));
11455         if (un == NULL) {
11456                 bioerror(bp, EIO);
11457                 bp->b_resid = bp->b_bcount;
11458                 biodone(bp);
11459                 return (0);
11460         }
11461 
11462         /* As was done in the past, fail new cmds. if state is dumping. */
11463         if (un->un_state == SD_STATE_DUMPING) {
11464                 bioerror(bp, ENXIO);
11465                 bp->b_resid = bp->b_bcount;
11466                 biodone(bp);
11467                 return (0);
11468         }
11469 
11470         ASSERT(!mutex_owned(SD_MUTEX(un)));
11471 
11472         /*
11473          * Commands may sneak in while we released the mutex in
11474          * DDI_SUSPEND, we should block new commands. However, old
11475          * commands that are still in the driver at this point should
11476          * still be allowed to drain.
11477          */
11478         mutex_enter(SD_MUTEX(un));
11479         /*
11480          * Must wait here if either the device is suspended or
11481          * if it's power level is changing.
11482          */
11483         while ((un->un_state == SD_STATE_SUSPENDED) ||
11484             (un->un_state == SD_STATE_PM_CHANGING)) {
11485                 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
11486         }
11487 
11488         un->un_ncmds_in_driver++;
11489 
11490         /*
11491          * atapi: Since we are running the CD for now in PIO mode we need to
11492          * call bp_mapin here to avoid bp_mapin called interrupt context under
11493          * the HBA's init_pkt routine.
11494          */
11495         if (un->un_f_cfg_is_atapi == TRUE) {
11496                 mutex_exit(SD_MUTEX(un));
11497                 bp_mapin(bp);
11498                 mutex_enter(SD_MUTEX(un));
11499         }
11500         SD_INFO(SD_LOG_IO, un, "sdstrategy: un_ncmds_in_driver = %ld\n",
11501             un->un_ncmds_in_driver);
11502 
11503         if (bp->b_flags & B_WRITE)
11504                 un->un_f_sync_cache_required = TRUE;
11505 
11506         mutex_exit(SD_MUTEX(un));
11507 
11508         /*
11509          * This will (eventually) allocate the sd_xbuf area and
11510          * call sd_xbuf_strategy().  We just want to return the
11511          * result of ddi_xbuf_qstrategy so that we have an opt-
11512          * imized tail call which saves us a stack frame.
11513          */
11514         return (ddi_xbuf_qstrategy(bp, un->un_xbuf_attr));
11515 }
11516 
11517 
11518 /*
11519  *    Function: sd_xbuf_strategy
11520  *
11521  * Description: Function for initiating IO operations via the
11522  *              ddi_xbuf_qstrategy() mechanism.
11523  *
11524  *     Context: Kernel thread context.
11525  */
11526 
11527 static void
11528 sd_xbuf_strategy(struct buf *bp, ddi_xbuf_t xp, void *arg)
11529 {
11530         struct sd_lun *un = arg;
11531 
11532         ASSERT(bp != NULL);
11533         ASSERT(xp != NULL);
11534         ASSERT(un != NULL);
11535         ASSERT(!mutex_owned(SD_MUTEX(un)));
11536 
11537         /*
11538          * Initialize the fields in the xbuf and save a pointer to the
11539          * xbuf in bp->b_private.
11540          */
11541         sd_xbuf_init(un, bp, xp, SD_CHAIN_BUFIO, NULL);
11542 
11543         /* Send the buf down the iostart chain */
11544         SD_BEGIN_IOSTART(((struct sd_xbuf *)xp)->xb_chain_iostart, un, bp);
11545 }
11546 
11547 
11548 /*
11549  *    Function: sd_xbuf_init
11550  *
11551  * Description: Prepare the given sd_xbuf struct for use.
11552  *
11553  *   Arguments: un - ptr to softstate
11554  *              bp - ptr to associated buf(9S)
11555  *              xp - ptr to associated sd_xbuf
11556  *              chain_type - IO chain type to use:
11557  *                      SD_CHAIN_NULL
11558  *                      SD_CHAIN_BUFIO
11559  *                      SD_CHAIN_USCSI
11560  *                      SD_CHAIN_DIRECT
11561  *                      SD_CHAIN_DIRECT_PRIORITY
11562  *              pktinfop - ptr to private data struct for scsi_pkt(9S)
11563  *                      initialization; may be NULL if none.
11564  *
11565  *     Context: Kernel thread context
11566  */
11567 
11568 static void
11569 sd_xbuf_init(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
11570         uchar_t chain_type, void *pktinfop)
11571 {
11572         int index;
11573 
11574         ASSERT(un != NULL);
11575         ASSERT(bp != NULL);
11576         ASSERT(xp != NULL);
11577 
11578         SD_INFO(SD_LOG_IO, un, "sd_xbuf_init: buf:0x%p chain type:0x%x\n",
11579             bp, chain_type);
11580 
11581         xp->xb_un    = un;
11582         xp->xb_pktp  = NULL;
11583         xp->xb_pktinfo       = pktinfop;
11584         xp->xb_private       = bp->b_private;
11585         xp->xb_blkno = (daddr_t)bp->b_blkno;
11586 
11587         /*
11588          * Set up the iostart and iodone chain indexes in the xbuf, based
11589          * upon the specified chain type to use.
11590          */
11591         switch (chain_type) {
11592         case SD_CHAIN_NULL:
11593                 /*
11594                  * Fall thru to just use the values for the buf type, even
11595                  * tho for the NULL chain these values will never be used.
11596                  */
11597                 /* FALLTHRU */
11598         case SD_CHAIN_BUFIO:
11599                 index = un->un_buf_chain_type;
11600                 if ((!un->un_f_has_removable_media) &&
11601                     (un->un_tgt_blocksize != 0) &&
11602                     (un->un_tgt_blocksize != DEV_BSIZE ||
11603                     un->un_f_enable_rmw)) {
11604                         int secmask = 0, blknomask = 0;
11605                         if (un->un_f_enable_rmw) {
11606                                 blknomask =
11607                                     (un->un_phy_blocksize / DEV_BSIZE) - 1;
11608                                 secmask = un->un_phy_blocksize - 1;
11609                         } else {
11610                                 blknomask =
11611                                     (un->un_tgt_blocksize / DEV_BSIZE) - 1;
11612                                 secmask = un->un_tgt_blocksize - 1;
11613                         }
11614 
11615                         if ((bp->b_lblkno & (blknomask)) ||
11616                             (bp->b_bcount & (secmask))) {
11617                                 if ((un->un_f_rmw_type !=
11618                                     SD_RMW_TYPE_RETURN_ERROR) ||
11619                                     un->un_f_enable_rmw) {
11620                                         if (un->un_f_pm_is_enabled == FALSE)
11621                                                 index =
11622                                                     SD_CHAIN_INFO_MSS_DSK_NO_PM;
11623                                         else
11624                                                 index =
11625                                                     SD_CHAIN_INFO_MSS_DISK;
11626                                 }
11627                         }
11628                 }
11629                 break;
11630         case SD_CHAIN_USCSI:
11631                 index = un->un_uscsi_chain_type;
11632                 break;
11633         case SD_CHAIN_DIRECT:
11634                 index = un->un_direct_chain_type;
11635                 break;
11636         case SD_CHAIN_DIRECT_PRIORITY:
11637                 index = un->un_priority_chain_type;
11638                 break;
11639         default:
11640                 /* We're really broken if we ever get here... */
11641                 panic("sd_xbuf_init: illegal chain type!");
11642                 /*NOTREACHED*/
11643         }
11644 
11645         xp->xb_chain_iostart = sd_chain_index_map[index].sci_iostart_index;
11646         xp->xb_chain_iodone = sd_chain_index_map[index].sci_iodone_index;
11647 
11648         /*
11649          * It might be a bit easier to simply bzero the entire xbuf above,
11650          * but it turns out that since we init a fair number of members anyway,
11651          * we save a fair number cycles by doing explicit assignment of zero.
11652          */
11653         xp->xb_pkt_flags     = 0;
11654         xp->xb_dma_resid     = 0;
11655         xp->xb_retry_count   = 0;
11656         xp->xb_victim_retry_count = 0;
11657         xp->xb_ua_retry_count        = 0;
11658         xp->xb_nr_retry_count        = 0;
11659         xp->xb_sense_bp              = NULL;
11660         xp->xb_sense_status  = 0;
11661         xp->xb_sense_state   = 0;
11662         xp->xb_sense_resid   = 0;
11663         xp->xb_ena           = 0;
11664 
11665         bp->b_private        = xp;
11666         bp->b_flags  &= ~(B_DONE | B_ERROR);
11667         bp->b_resid  = 0;
11668         bp->av_forw  = NULL;
11669         bp->av_back  = NULL;
11670         bioerror(bp, 0);
11671 
11672         SD_INFO(SD_LOG_IO, un, "sd_xbuf_init: done.\n");
11673 }
11674 
11675 
11676 /*
11677  *    Function: sd_uscsi_strategy
11678  *
11679  * Description: Wrapper for calling into the USCSI chain via physio(9F)
11680  *
11681  *   Arguments: bp - buf struct ptr
11682  *
11683  * Return Code: Always returns 0
11684  *
11685  *     Context: Kernel thread context
11686  */
11687 
11688 static int
11689 sd_uscsi_strategy(struct buf *bp)
11690 {
11691         struct sd_lun           *un;
11692         struct sd_uscsi_info    *uip;
11693         struct sd_xbuf          *xp;
11694         uchar_t                 chain_type;
11695         uchar_t                 cmd;
11696 
11697         ASSERT(bp != NULL);
11698 
11699         un = ddi_get_soft_state(sd_state, SD_GET_INSTANCE_FROM_BUF(bp));
11700         if (un == NULL) {
11701                 bioerror(bp, EIO);
11702                 bp->b_resid = bp->b_bcount;
11703                 biodone(bp);
11704                 return (0);
11705         }
11706 
11707         ASSERT(!mutex_owned(SD_MUTEX(un)));
11708 
11709         SD_TRACE(SD_LOG_IO, un, "sd_uscsi_strategy: entry: buf:0x%p\n", bp);
11710 
11711         /*
11712          * A pointer to a struct sd_uscsi_info is expected in bp->b_private
11713          */
11714         ASSERT(bp->b_private != NULL);
11715         uip = (struct sd_uscsi_info *)bp->b_private;
11716         cmd = ((struct uscsi_cmd *)(uip->ui_cmdp))->uscsi_cdb[0];
11717 
11718         mutex_enter(SD_MUTEX(un));
11719         /*
11720          * atapi: Since we are running the CD for now in PIO mode we need to
11721          * call bp_mapin here to avoid bp_mapin called interrupt context under
11722          * the HBA's init_pkt routine.
11723          */
11724         if (un->un_f_cfg_is_atapi == TRUE) {
11725                 mutex_exit(SD_MUTEX(un));
11726                 bp_mapin(bp);
11727                 mutex_enter(SD_MUTEX(un));
11728         }
11729         un->un_ncmds_in_driver++;
11730         SD_INFO(SD_LOG_IO, un, "sd_uscsi_strategy: un_ncmds_in_driver = %ld\n",
11731             un->un_ncmds_in_driver);
11732 
11733         if ((bp->b_flags & B_WRITE) && (bp->b_bcount != 0) &&
11734             (cmd != SCMD_MODE_SELECT) && (cmd != SCMD_MODE_SELECT_G1))
11735                 un->un_f_sync_cache_required = TRUE;
11736 
11737         mutex_exit(SD_MUTEX(un));
11738 
11739         switch (uip->ui_flags) {
11740         case SD_PATH_DIRECT:
11741                 chain_type = SD_CHAIN_DIRECT;
11742                 break;
11743         case SD_PATH_DIRECT_PRIORITY:
11744                 chain_type = SD_CHAIN_DIRECT_PRIORITY;
11745                 break;
11746         default:
11747                 chain_type = SD_CHAIN_USCSI;
11748                 break;
11749         }
11750 
11751         /*
11752          * We may allocate extra buf for external USCSI commands. If the
11753          * application asks for bigger than 20-byte sense data via USCSI,
11754          * SCSA layer will allocate 252 bytes sense buf for that command.
11755          */
11756         if (((struct uscsi_cmd *)(uip->ui_cmdp))->uscsi_rqlen >
11757             SENSE_LENGTH) {
11758                 xp = kmem_zalloc(sizeof (struct sd_xbuf) - SENSE_LENGTH +
11759                     MAX_SENSE_LENGTH, KM_SLEEP);
11760         } else {
11761                 xp = kmem_zalloc(sizeof (struct sd_xbuf), KM_SLEEP);
11762         }
11763 
11764         sd_xbuf_init(un, bp, xp, chain_type, uip->ui_cmdp);
11765 
11766         /* Use the index obtained within xbuf_init */
11767         SD_BEGIN_IOSTART(xp->xb_chain_iostart, un, bp);
11768 
11769         SD_TRACE(SD_LOG_IO, un, "sd_uscsi_strategy: exit: buf:0x%p\n", bp);
11770 
11771         return (0);
11772 }
11773 
11774 /*
11775  *    Function: sd_send_scsi_cmd
11776  *
11777  * Description: Runs a USCSI command for user (when called thru sdioctl),
11778  *              or for the driver
11779  *
11780  *   Arguments: dev - the dev_t for the device
11781  *              incmd - ptr to a valid uscsi_cmd struct
11782  *              flag - bit flag, indicating open settings, 32/64 bit type
11783  *              dataspace - UIO_USERSPACE or UIO_SYSSPACE
11784  *              path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
11785  *                      the normal command waitq, or SD_PATH_DIRECT_PRIORITY
11786  *                      to use the USCSI "direct" chain and bypass the normal
11787  *                      command waitq.
11788  *
11789  * Return Code: 0 -  successful completion of the given command
11790  *              EIO - scsi_uscsi_handle_command() failed
11791  *              ENXIO  - soft state not found for specified dev
11792  *              EINVAL
11793  *              EFAULT - copyin/copyout error
11794  *              return code of scsi_uscsi_handle_command():
11795  *                      EIO
11796  *                      ENXIO
11797  *                      EACCES
11798  *
11799  *     Context: Waits for command to complete. Can sleep.
11800  */
11801 
11802 static int
11803 sd_send_scsi_cmd(dev_t dev, struct uscsi_cmd *incmd, int flag,
11804         enum uio_seg dataspace, int path_flag)
11805 {
11806         struct sd_lun   *un;
11807         sd_ssc_t        *ssc;
11808         int             rval;
11809 
11810         un = ddi_get_soft_state(sd_state, SDUNIT(dev));
11811         if (un == NULL) {
11812                 return (ENXIO);
11813         }
11814 
11815         /*
11816          * Using sd_ssc_send to handle uscsi cmd
11817          */
11818         ssc = sd_ssc_init(un);
11819         rval = sd_ssc_send(ssc, incmd, flag, dataspace, path_flag);
11820         sd_ssc_fini(ssc);
11821 
11822         return (rval);
11823 }
11824 
11825 /*
11826  *    Function: sd_ssc_init
11827  *
11828  * Description: Uscsi end-user call this function to initialize necessary
11829  *              fields, such as uscsi_cmd and sd_uscsi_info struct.
11830  *
11831  *              The return value of sd_send_scsi_cmd will be treated as a
11832  *              fault in various conditions. Even it is not Zero, some
11833  *              callers may ignore the return value. That is to say, we can
11834  *              not make an accurate assessment in sdintr, since if a
11835  *              command is failed in sdintr it does not mean the caller of
11836  *              sd_send_scsi_cmd will treat it as a real failure.
11837  *
11838  *              To avoid printing too many error logs for a failed uscsi
11839  *              packet that the caller may not treat it as a failure, the
11840  *              sd will keep silent for handling all uscsi commands.
11841  *
11842  *              During detach->attach and attach-open, for some types of
11843  *              problems, the driver should be providing information about
11844  *              the problem encountered. Device use USCSI_SILENT, which
11845  *              suppresses all driver information. The result is that no
11846  *              information about the problem is available. Being
11847  *              completely silent during this time is inappropriate. The
11848  *              driver needs a more selective filter than USCSI_SILENT, so
11849  *              that information related to faults is provided.
11850  *
11851  *              To make the accurate accessment, the caller  of
11852  *              sd_send_scsi_USCSI_CMD should take the ownership and
11853  *              get necessary information to print error messages.
11854  *
11855  *              If we want to print necessary info of uscsi command, we need to
11856  *              keep the uscsi_cmd and sd_uscsi_info till we can make the
11857  *              assessment. We use sd_ssc_init to alloc necessary
11858  *              structs for sending an uscsi command and we are also
11859  *              responsible for free the memory by calling
11860  *              sd_ssc_fini.
11861  *
11862  *              The calling secquences will look like:
11863  *              sd_ssc_init->
11864  *
11865  *                  ...
11866  *
11867  *                  sd_send_scsi_USCSI_CMD->
11868  *                      sd_ssc_send-> - - - sdintr
11869  *                  ...
11870  *
11871  *                  if we think the return value should be treated as a
11872  *                  failure, we make the accessment here and print out
11873  *                  necessary by retrieving uscsi_cmd and sd_uscsi_info'
11874  *
11875  *                  ...
11876  *
11877  *              sd_ssc_fini
11878  *
11879  *
11880  *   Arguments: un - pointer to driver soft state (unit) structure for this
11881  *                   target.
11882  *
11883  * Return code: sd_ssc_t - pointer to allocated sd_ssc_t struct, it contains
11884  *                         uscsi_cmd and sd_uscsi_info.
11885  *                  NULL - if can not alloc memory for sd_ssc_t struct
11886  *
11887  *     Context: Kernel Thread.
11888  */
11889 static sd_ssc_t *
11890 sd_ssc_init(struct sd_lun *un)
11891 {
11892         sd_ssc_t                *ssc;
11893         struct uscsi_cmd        *ucmdp;
11894         struct sd_uscsi_info    *uip;
11895 
11896         ASSERT(un != NULL);
11897         ASSERT(!mutex_owned(SD_MUTEX(un)));
11898 
11899         /*
11900          * Allocate sd_ssc_t structure
11901          */
11902         ssc = kmem_zalloc(sizeof (sd_ssc_t), KM_SLEEP);
11903 
11904         /*
11905          * Allocate uscsi_cmd by calling scsi_uscsi_alloc common routine
11906          */
11907         ucmdp = scsi_uscsi_alloc();
11908 
11909         /*
11910          * Allocate sd_uscsi_info structure
11911          */
11912         uip = kmem_zalloc(sizeof (struct sd_uscsi_info), KM_SLEEP);
11913 
11914         ssc->ssc_uscsi_cmd = ucmdp;
11915         ssc->ssc_uscsi_info = uip;
11916         ssc->ssc_un = un;
11917 
11918         return (ssc);
11919 }
11920 
11921 /*
11922  * Function: sd_ssc_fini
11923  *
11924  * Description: To free sd_ssc_t and it's hanging off
11925  *
11926  * Arguments: ssc - struct pointer of sd_ssc_t.
11927  */
11928 static void
11929 sd_ssc_fini(sd_ssc_t *ssc)
11930 {
11931         scsi_uscsi_free(ssc->ssc_uscsi_cmd);
11932 
11933         if (ssc->ssc_uscsi_info != NULL) {
11934                 kmem_free(ssc->ssc_uscsi_info, sizeof (struct sd_uscsi_info));
11935                 ssc->ssc_uscsi_info = NULL;
11936         }
11937 
11938         kmem_free(ssc, sizeof (sd_ssc_t));
11939         ssc = NULL;
11940 }
11941 
11942 /*
11943  * Function: sd_ssc_send
11944  *
11945  * Description: Runs a USCSI command for user when called through sdioctl,
11946  *              or for the driver.
11947  *
11948  *   Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and
11949  *                    sd_uscsi_info in.
11950  *              incmd - ptr to a valid uscsi_cmd struct
11951  *              flag - bit flag, indicating open settings, 32/64 bit type
11952  *              dataspace - UIO_USERSPACE or UIO_SYSSPACE
11953  *              path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
11954  *                      the normal command waitq, or SD_PATH_DIRECT_PRIORITY
11955  *                      to use the USCSI "direct" chain and bypass the normal
11956  *                      command waitq.
11957  *
11958  * Return Code: 0 -  successful completion of the given command
11959  *              EIO - scsi_uscsi_handle_command() failed
11960  *              ENXIO  - soft state not found for specified dev
11961  *              ECANCELED - command cancelled due to low power
11962  *              EINVAL
11963  *              EFAULT - copyin/copyout error
11964  *              return code of scsi_uscsi_handle_command():
11965  *                      EIO
11966  *                      ENXIO
11967  *                      EACCES
11968  *
11969  *     Context: Kernel Thread;
11970  *              Waits for command to complete. Can sleep.
11971  */
11972 static int
11973 sd_ssc_send(sd_ssc_t *ssc, struct uscsi_cmd *incmd, int flag,
11974         enum uio_seg dataspace, int path_flag)
11975 {
11976         struct sd_uscsi_info    *uip;
11977         struct uscsi_cmd        *uscmd;
11978         struct sd_lun           *un;
11979         dev_t                   dev;
11980 
11981         int     format = 0;
11982         int     rval;
11983 
11984         ASSERT(ssc != NULL);
11985         un = ssc->ssc_un;
11986         ASSERT(un != NULL);
11987         uscmd = ssc->ssc_uscsi_cmd;
11988         ASSERT(uscmd != NULL);
11989         ASSERT(!mutex_owned(SD_MUTEX(un)));
11990         if (ssc->ssc_flags & SSC_FLAGS_NEED_ASSESSMENT) {
11991                 /*
11992                  * If enter here, it indicates that the previous uscsi
11993                  * command has not been processed by sd_ssc_assessment.
11994                  * This is violating our rules of FMA telemetry processing.
11995                  * We should print out this message and the last undisposed
11996                  * uscsi command.
11997                  */
11998                 if (uscmd->uscsi_cdb != NULL) {
11999                         SD_INFO(SD_LOG_SDTEST, un,
12000                             "sd_ssc_send is missing the alternative "
12001                             "sd_ssc_assessment when running command 0x%x.\n",
12002                             uscmd->uscsi_cdb[0]);
12003                 }
12004                 /*
12005                  * Set the ssc_flags to SSC_FLAGS_UNKNOWN, which should be
12006                  * the initial status.
12007                  */
12008                 ssc->ssc_flags = SSC_FLAGS_UNKNOWN;
12009         }
12010 
12011         /*
12012          * We need to make sure sd_ssc_send will have sd_ssc_assessment
12013          * followed to avoid missing FMA telemetries.
12014          */
12015         ssc->ssc_flags |= SSC_FLAGS_NEED_ASSESSMENT;
12016 
12017         /*
12018          * if USCSI_PMFAILFAST is set and un is in low power, fail the
12019          * command immediately.
12020          */
12021         mutex_enter(SD_MUTEX(un));
12022         mutex_enter(&un->un_pm_mutex);
12023         if ((uscmd->uscsi_flags & USCSI_PMFAILFAST) &&
12024             SD_DEVICE_IS_IN_LOW_POWER(un)) {
12025                 SD_TRACE(SD_LOG_IO, un, "sd_ssc_send:"
12026                     "un:0x%p is in low power\n", un);
12027                 mutex_exit(&un->un_pm_mutex);
12028                 mutex_exit(SD_MUTEX(un));
12029                 return (ECANCELED);
12030         }
12031         mutex_exit(&un->un_pm_mutex);
12032         mutex_exit(SD_MUTEX(un));
12033 
12034 #ifdef SDDEBUG
12035         switch (dataspace) {
12036         case UIO_USERSPACE:
12037                 SD_TRACE(SD_LOG_IO, un,
12038                     "sd_ssc_send: entry: un:0x%p UIO_USERSPACE\n", un);
12039                 break;
12040         case UIO_SYSSPACE:
12041                 SD_TRACE(SD_LOG_IO, un,
12042                     "sd_ssc_send: entry: un:0x%p UIO_SYSSPACE\n", un);
12043                 break;
12044         default:
12045                 SD_TRACE(SD_LOG_IO, un,
12046                     "sd_ssc_send: entry: un:0x%p UNEXPECTED SPACE\n", un);
12047                 break;
12048         }
12049 #endif
12050 
12051         rval = scsi_uscsi_copyin((intptr_t)incmd, flag,
12052             SD_ADDRESS(un), &uscmd);
12053         if (rval != 0) {
12054                 SD_TRACE(SD_LOG_IO, un, "sd_sense_scsi_cmd: "
12055                     "scsi_uscsi_alloc_and_copyin failed\n", un);
12056                 return (rval);
12057         }
12058 
12059         if ((uscmd->uscsi_cdb != NULL) &&
12060             (uscmd->uscsi_cdb[0] == SCMD_FORMAT)) {
12061                 mutex_enter(SD_MUTEX(un));
12062                 un->un_f_format_in_progress = TRUE;
12063                 mutex_exit(SD_MUTEX(un));
12064                 format = 1;
12065         }
12066 
12067         /*
12068          * Allocate an sd_uscsi_info struct and fill it with the info
12069          * needed by sd_initpkt_for_uscsi().  Then put the pointer into
12070          * b_private in the buf for sd_initpkt_for_uscsi().  Note that
12071          * since we allocate the buf here in this function, we do not
12072          * need to preserve the prior contents of b_private.
12073          * The sd_uscsi_info struct is also used by sd_uscsi_strategy()
12074          */
12075         uip = ssc->ssc_uscsi_info;
12076         uip->ui_flags = path_flag;
12077         uip->ui_cmdp = uscmd;
12078 
12079         /*
12080          * Commands sent with priority are intended for error recovery
12081          * situations, and do not have retries performed.
12082          */
12083         if (path_flag == SD_PATH_DIRECT_PRIORITY) {
12084                 uscmd->uscsi_flags |= USCSI_DIAGNOSE;
12085         }
12086         uscmd->uscsi_flags &= ~USCSI_NOINTR;
12087 
12088         dev = SD_GET_DEV(un);
12089         rval = scsi_uscsi_handle_cmd(dev, dataspace, uscmd,
12090             sd_uscsi_strategy, NULL, uip);
12091 
12092         /*
12093          * mark ssc_flags right after handle_cmd to make sure
12094          * the uscsi has been sent
12095          */
12096         ssc->ssc_flags |= SSC_FLAGS_CMD_ISSUED;
12097 
12098 #ifdef SDDEBUG
12099         SD_INFO(SD_LOG_IO, un, "sd_ssc_send: "
12100             "uscsi_status: 0x%02x  uscsi_resid:0x%x\n",
12101             uscmd->uscsi_status, uscmd->uscsi_resid);
12102         if (uscmd->uscsi_bufaddr != NULL) {
12103                 SD_INFO(SD_LOG_IO, un, "sd_ssc_send: "
12104                     "uscmd->uscsi_bufaddr: 0x%p  uscmd->uscsi_buflen:%d\n",
12105                     uscmd->uscsi_bufaddr, uscmd->uscsi_buflen);
12106                 if (dataspace == UIO_SYSSPACE) {
12107                         SD_DUMP_MEMORY(un, SD_LOG_IO,
12108                             "data", (uchar_t *)uscmd->uscsi_bufaddr,
12109                             uscmd->uscsi_buflen, SD_LOG_HEX);
12110                 }
12111         }
12112 #endif
12113 
12114         if (format == 1) {
12115                 mutex_enter(SD_MUTEX(un));
12116                 un->un_f_format_in_progress = FALSE;
12117                 mutex_exit(SD_MUTEX(un));
12118         }
12119 
12120         (void) scsi_uscsi_copyout((intptr_t)incmd, uscmd);
12121 
12122         return (rval);
12123 }
12124 
12125 /*
12126  *     Function: sd_ssc_print
12127  *
12128  * Description: Print information available to the console.
12129  *
12130  * Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and
12131  *                    sd_uscsi_info in.
12132  *            sd_severity - log level.
12133  *     Context: Kernel thread or interrupt context.
12134  */
12135 static void
12136 sd_ssc_print(sd_ssc_t *ssc, int sd_severity)
12137 {
12138         struct uscsi_cmd        *ucmdp;
12139         struct scsi_device      *devp;
12140         dev_info_t              *devinfo;
12141         uchar_t                 *sensep;
12142         int                     senlen;
12143         union scsi_cdb          *cdbp;
12144         uchar_t                 com;
12145         extern struct scsi_key_strings scsi_cmds[];
12146 
12147         ASSERT(ssc != NULL);
12148         ASSERT(ssc->ssc_un != NULL);
12149 
12150         if (SD_FM_LOG(ssc->ssc_un) != SD_FM_LOG_EREPORT)
12151                 return;
12152         ucmdp = ssc->ssc_uscsi_cmd;
12153         devp = SD_SCSI_DEVP(ssc->ssc_un);
12154         devinfo = SD_DEVINFO(ssc->ssc_un);
12155         ASSERT(ucmdp != NULL);
12156         ASSERT(devp != NULL);
12157         ASSERT(devinfo != NULL);
12158         sensep = (uint8_t *)ucmdp->uscsi_rqbuf;
12159         senlen = ucmdp->uscsi_rqlen - ucmdp->uscsi_rqresid;
12160         cdbp = (union scsi_cdb *)ucmdp->uscsi_cdb;
12161 
12162         /* In certain case (like DOORLOCK), the cdb could be NULL. */
12163         if (cdbp == NULL)
12164                 return;
12165         /* We don't print log if no sense data available. */
12166         if (senlen == 0)
12167                 sensep = NULL;
12168         com = cdbp->scc_cmd;
12169         scsi_generic_errmsg(devp, sd_label, sd_severity, 0, 0, com,
12170             scsi_cmds, sensep, ssc->ssc_un->un_additional_codes, NULL);
12171 }
12172 
12173 /*
12174  *     Function: sd_ssc_assessment
12175  *
12176  * Description: We use this function to make an assessment at the point
12177  *              where SD driver may encounter a potential error.
12178  *
12179  * Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and
12180  *                  sd_uscsi_info in.
12181  *            tp_assess - a hint of strategy for ereport posting.
12182  *            Possible values of tp_assess include:
12183  *                SD_FMT_IGNORE - we don't post any ereport because we're
12184  *                sure that it is ok to ignore the underlying problems.
12185  *                SD_FMT_IGNORE_COMPROMISE - we don't post any ereport for now
12186  *                but it might be not correct to ignore the underlying hardware
12187  *                error.
12188  *                SD_FMT_STATUS_CHECK - we will post an ereport with the
12189  *                payload driver-assessment of value "fail" or
12190  *                "fatal"(depending on what information we have here). This
12191  *                assessment value is usually set when SD driver think there
12192  *                is a potential error occurred(Typically, when return value
12193  *                of the SCSI command is EIO).
12194  *                SD_FMT_STANDARD - we will post an ereport with the payload
12195  *                driver-assessment of value "info". This assessment value is
12196  *                set when the SCSI command returned successfully and with
12197  *                sense data sent back.
12198  *
12199  *     Context: Kernel thread.
12200  */
12201 static void
12202 sd_ssc_assessment(sd_ssc_t *ssc, enum sd_type_assessment tp_assess)
12203 {
12204         int senlen = 0;
12205         struct uscsi_cmd *ucmdp = NULL;
12206         struct sd_lun *un;
12207 
12208         ASSERT(ssc != NULL);
12209         un = ssc->ssc_un;
12210         ASSERT(un != NULL);
12211         ucmdp = ssc->ssc_uscsi_cmd;
12212         ASSERT(ucmdp != NULL);
12213 
12214         if (ssc->ssc_flags & SSC_FLAGS_NEED_ASSESSMENT) {
12215                 ssc->ssc_flags &= ~SSC_FLAGS_NEED_ASSESSMENT;
12216         } else {
12217                 /*
12218                  * If enter here, it indicates that we have a wrong
12219                  * calling sequence of sd_ssc_send and sd_ssc_assessment,
12220                  * both of which should be called in a pair in case of
12221                  * loss of FMA telemetries.
12222                  */
12223                 if (ucmdp->uscsi_cdb != NULL) {
12224                         SD_INFO(SD_LOG_SDTEST, un,
12225                             "sd_ssc_assessment is missing the "
12226                             "alternative sd_ssc_send when running 0x%x, "
12227                             "or there are superfluous sd_ssc_assessment for "
12228                             "the same sd_ssc_send.\n",
12229                             ucmdp->uscsi_cdb[0]);
12230                 }
12231                 /*
12232                  * Set the ssc_flags to the initial value to avoid passing
12233                  * down dirty flags to the following sd_ssc_send function.
12234                  */
12235                 ssc->ssc_flags = SSC_FLAGS_UNKNOWN;
12236                 return;
12237         }
12238 
12239         /*
12240          * Only handle an issued command which is waiting for assessment.
12241          * A command which is not issued will not have
12242          * SSC_FLAGS_INVALID_DATA set, so it'ok we just return here.
12243          */
12244         if (!(ssc->ssc_flags & SSC_FLAGS_CMD_ISSUED)) {
12245                 sd_ssc_print(ssc, SCSI_ERR_INFO);
12246                 return;
12247         } else {
12248                 /*
12249                  * For an issued command, we should clear this flag in
12250                  * order to make the sd_ssc_t structure be used off
12251                  * multiple uscsi commands.
12252                  */
12253                 ssc->ssc_flags &= ~SSC_FLAGS_CMD_ISSUED;
12254         }
12255 
12256         /*
12257          * We will not deal with non-retryable(flag USCSI_DIAGNOSE set)
12258          * commands here. And we should clear the ssc_flags before return.
12259          */
12260         if (ucmdp->uscsi_flags & USCSI_DIAGNOSE) {
12261                 ssc->ssc_flags = SSC_FLAGS_UNKNOWN;
12262                 return;
12263         }
12264 
12265         switch (tp_assess) {
12266         case SD_FMT_IGNORE:
12267         case SD_FMT_IGNORE_COMPROMISE:
12268                 break;
12269         case SD_FMT_STATUS_CHECK:
12270                 /*
12271                  * For a failed command(including the succeeded command
12272                  * with invalid data sent back).
12273                  */
12274                 sd_ssc_post(ssc, SD_FM_DRV_FATAL);
12275                 break;
12276         case SD_FMT_STANDARD:
12277                 /*
12278                  * Always for the succeeded commands probably with sense
12279                  * data sent back.
12280                  * Limitation:
12281                  *      We can only handle a succeeded command with sense
12282                  *      data sent back when auto-request-sense is enabled.
12283                  */
12284                 senlen = ssc->ssc_uscsi_cmd->uscsi_rqlen -
12285                     ssc->ssc_uscsi_cmd->uscsi_rqresid;
12286                 if ((ssc->ssc_uscsi_info->ui_pkt_state & STATE_ARQ_DONE) &&
12287                     (un->un_f_arq_enabled == TRUE) &&
12288                     senlen > 0 &&
12289                     ssc->ssc_uscsi_cmd->uscsi_rqbuf != NULL) {
12290                         sd_ssc_post(ssc, SD_FM_DRV_NOTICE);
12291                 }
12292                 break;
12293         default:
12294                 /*
12295                  * Should not have other type of assessment.
12296                  */
12297                 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
12298                     "sd_ssc_assessment got wrong "
12299                     "sd_type_assessment %d.\n", tp_assess);
12300                 break;
12301         }
12302         /*
12303          * Clear up the ssc_flags before return.
12304          */
12305         ssc->ssc_flags = SSC_FLAGS_UNKNOWN;
12306 }
12307 
12308 /*
12309  *    Function: sd_ssc_post
12310  *
12311  * Description: 1. read the driver property to get fm-scsi-log flag.
12312  *              2. print log if fm_log_capable is non-zero.
12313  *              3. call sd_ssc_ereport_post to post ereport if possible.
12314  *
12315  *    Context: May be called from kernel thread or interrupt context.
12316  */
12317 static void
12318 sd_ssc_post(sd_ssc_t *ssc, enum sd_driver_assessment sd_assess)
12319 {
12320         struct sd_lun   *un;
12321         int             sd_severity;
12322 
12323         ASSERT(ssc != NULL);
12324         un = ssc->ssc_un;
12325         ASSERT(un != NULL);
12326 
12327         /*
12328          * We may enter here from sd_ssc_assessment(for USCSI command) or
12329          * by directly called from sdintr context.
12330          * We don't handle a non-disk drive(CD-ROM, removable media).
12331          * Clear the ssc_flags before return in case we've set
12332          * SSC_FLAGS_INVALID_XXX which should be skipped for a non-disk
12333          * driver.
12334          */
12335         if (ISCD(un) || un->un_f_has_removable_media) {
12336                 ssc->ssc_flags = SSC_FLAGS_UNKNOWN;
12337                 return;
12338         }
12339 
12340         switch (sd_assess) {
12341                 case SD_FM_DRV_FATAL:
12342                         sd_severity = SCSI_ERR_FATAL;
12343                         break;
12344                 case SD_FM_DRV_RECOVERY:
12345                         sd_severity = SCSI_ERR_RECOVERED;
12346                         break;
12347                 case SD_FM_DRV_RETRY:
12348                         sd_severity = SCSI_ERR_RETRYABLE;
12349                         break;
12350                 case SD_FM_DRV_NOTICE:
12351                         sd_severity = SCSI_ERR_INFO;
12352                         break;
12353                 default:
12354                         sd_severity = SCSI_ERR_UNKNOWN;
12355         }
12356         /* print log */
12357         sd_ssc_print(ssc, sd_severity);
12358 
12359         /* always post ereport */
12360         sd_ssc_ereport_post(ssc, sd_assess);
12361 }
12362 
12363 /*
12364  *    Function: sd_ssc_set_info
12365  *
12366  * Description: Mark ssc_flags and set ssc_info which would be the
12367  *              payload of uderr ereport. This function will cause
12368  *              sd_ssc_ereport_post to post uderr ereport only.
12369  *              Besides, when ssc_flags == SSC_FLAGS_INVALID_DATA(USCSI),
12370  *              the function will also call SD_ERROR or scsi_log for a
12371  *              CDROM/removable-media/DDI_FM_NOT_CAPABLE device.
12372  *
12373  * Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and
12374  *                  sd_uscsi_info in.
12375  *            ssc_flags - indicate the sub-category of a uderr.
12376  *            comp - this argument is meaningful only when
12377  *                   ssc_flags == SSC_FLAGS_INVALID_DATA, and its possible
12378  *                   values include:
12379  *                   > 0, SD_ERROR is used with comp as the driver logging
12380  *                   component;
12381  *                   = 0, scsi-log is used to log error telemetries;
12382  *                   < 0, no log available for this telemetry.
12383  *
12384  *    Context: Kernel thread or interrupt context
12385  */
12386 static void
12387 sd_ssc_set_info(sd_ssc_t *ssc, int ssc_flags, uint_t comp, const char *fmt, ...)
12388 {
12389         va_list ap;
12390 
12391         ASSERT(ssc != NULL);
12392         ASSERT(ssc->ssc_un != NULL);
12393 
12394         ssc->ssc_flags |= ssc_flags;
12395         va_start(ap, fmt);
12396         (void) vsnprintf(ssc->ssc_info, sizeof (ssc->ssc_info), fmt, ap);
12397         va_end(ap);
12398 
12399         /*
12400          * If SSC_FLAGS_INVALID_DATA is set, it should be a uscsi command
12401          * with invalid data sent back. For non-uscsi command, the
12402          * following code will be bypassed.
12403          */
12404         if (ssc_flags & SSC_FLAGS_INVALID_DATA) {
12405                 if (SD_FM_LOG(ssc->ssc_un) == SD_FM_LOG_NSUP) {
12406                         /*
12407                          * If the error belong to certain component and we
12408                          * do not want it to show up on the console, we
12409                          * will use SD_ERROR, otherwise scsi_log is
12410                          * preferred.
12411                          */
12412                         if (comp > 0) {
12413                                 SD_ERROR(comp, ssc->ssc_un, ssc->ssc_info);
12414                         } else if (comp == 0) {
12415                                 scsi_log(SD_DEVINFO(ssc->ssc_un), sd_label,
12416                                     CE_WARN, ssc->ssc_info);
12417                         }
12418                 }
12419         }
12420 }
12421 
12422 /*
12423  *    Function: sd_buf_iodone
12424  *
12425  * Description: Frees the sd_xbuf & returns the buf to its originator.
12426  *
12427  *     Context: May be called from interrupt context.
12428  */
12429 /* ARGSUSED */
12430 static void
12431 sd_buf_iodone(int index, struct sd_lun *un, struct buf *bp)
12432 {
12433         struct sd_xbuf *xp;
12434 
12435         ASSERT(un != NULL);
12436         ASSERT(bp != NULL);
12437         ASSERT(!mutex_owned(SD_MUTEX(un)));
12438 
12439         SD_TRACE(SD_LOG_IO_CORE, un, "sd_buf_iodone: entry.\n");
12440 
12441         xp = SD_GET_XBUF(bp);
12442         ASSERT(xp != NULL);
12443 
12444         /* xbuf is gone after this */
12445         if (ddi_xbuf_done(bp, un->un_xbuf_attr)) {
12446                 mutex_enter(SD_MUTEX(un));
12447 
12448                 /*
12449                  * Grab time when the cmd completed.
12450                  * This is used for determining if the system has been
12451                  * idle long enough to make it idle to the PM framework.
12452                  * This is for lowering the overhead, and therefore improving
12453                  * performance per I/O operation.
12454                  */
12455                 un->un_pm_idle_time = ddi_get_time();
12456 
12457                 un->un_ncmds_in_driver--;
12458                 ASSERT(un->un_ncmds_in_driver >= 0);
12459                 SD_INFO(SD_LOG_IO, un,
12460                     "sd_buf_iodone: un_ncmds_in_driver = %ld\n",
12461                     un->un_ncmds_in_driver);
12462 
12463                 mutex_exit(SD_MUTEX(un));
12464         }
12465 
12466         biodone(bp);                            /* bp is gone after this */
12467 
12468         SD_TRACE(SD_LOG_IO_CORE, un, "sd_buf_iodone: exit.\n");
12469 }
12470 
12471 
12472 /*
12473  *    Function: sd_uscsi_iodone
12474  *
12475  * Description: Frees the sd_xbuf & returns the buf to its originator.
12476  *
12477  *     Context: May be called from interrupt context.
12478  */
12479 /* ARGSUSED */
12480 static void
12481 sd_uscsi_iodone(int index, struct sd_lun *un, struct buf *bp)
12482 {
12483         struct sd_xbuf *xp;
12484 
12485         ASSERT(un != NULL);
12486         ASSERT(bp != NULL);
12487 
12488         xp = SD_GET_XBUF(bp);
12489         ASSERT(xp != NULL);
12490         ASSERT(!mutex_owned(SD_MUTEX(un)));
12491 
12492         SD_INFO(SD_LOG_IO, un, "sd_uscsi_iodone: entry.\n");
12493 
12494         bp->b_private = xp->xb_private;
12495 
12496         mutex_enter(SD_MUTEX(un));
12497 
12498         /*
12499          * Grab time when the cmd completed.
12500          * This is used for determining if the system has been
12501          * idle long enough to make it idle to the PM framework.
12502          * This is for lowering the overhead, and therefore improving
12503          * performance per I/O operation.
12504          */
12505         un->un_pm_idle_time = ddi_get_time();
12506 
12507         un->un_ncmds_in_driver--;
12508         ASSERT(un->un_ncmds_in_driver >= 0);
12509         SD_INFO(SD_LOG_IO, un, "sd_uscsi_iodone: un_ncmds_in_driver = %ld\n",
12510             un->un_ncmds_in_driver);
12511 
12512         mutex_exit(SD_MUTEX(un));
12513 
12514         if (((struct uscsi_cmd *)(xp->xb_pktinfo))->uscsi_rqlen >
12515             SENSE_LENGTH) {
12516                 kmem_free(xp, sizeof (struct sd_xbuf) - SENSE_LENGTH +
12517                     MAX_SENSE_LENGTH);
12518         } else {
12519                 kmem_free(xp, sizeof (struct sd_xbuf));
12520         }
12521 
12522         biodone(bp);
12523 
12524         SD_INFO(SD_LOG_IO, un, "sd_uscsi_iodone: exit.\n");
12525 }
12526 
12527 
12528 /*
12529  *    Function: sd_mapblockaddr_iostart
12530  *
12531  * Description: Verify request lies within the partition limits for
12532  *              the indicated minor device.  Issue "overrun" buf if
12533  *              request would exceed partition range.  Converts
12534  *              partition-relative block address to absolute.
12535  *
12536  *              Upon exit of this function:
12537  *              1.I/O is aligned
12538  *                 xp->xb_blkno represents the absolute sector address
12539  *              2.I/O is misaligned
12540  *                 xp->xb_blkno represents the absolute logical block address
12541  *                 based on DEV_BSIZE. The logical block address will be
12542  *                 converted to physical sector address in sd_mapblocksize_\
12543  *                 iostart.
12544  *              3.I/O is misaligned but is aligned in "overrun" buf
12545  *                 xp->xb_blkno represents the absolute logical block address
12546  *                 based on DEV_BSIZE. The logical block address will be
12547  *                 converted to physical sector address in sd_mapblocksize_\
12548  *                 iostart. But no RMW will be issued in this case.
12549  *
12550  *     Context: Can sleep
12551  *
12552  *      Issues: This follows what the old code did, in terms of accessing
12553  *              some of the partition info in the unit struct without holding
12554  *              the mutext.  This is a general issue, if the partition info
12555  *              can be altered while IO is in progress... as soon as we send
12556  *              a buf, its partitioning can be invalid before it gets to the
12557  *              device.  Probably the right fix is to move partitioning out
12558  *              of the driver entirely.
12559  */
12560 
12561 static void
12562 sd_mapblockaddr_iostart(int index, struct sd_lun *un, struct buf *bp)
12563 {
12564         diskaddr_t      nblocks;        /* #blocks in the given partition */
12565         daddr_t blocknum;       /* Block number specified by the buf */
12566         size_t  requested_nblocks;
12567         size_t  available_nblocks;
12568         int     partition;
12569         diskaddr_t      partition_offset;
12570         struct sd_xbuf *xp;
12571         int secmask = 0, blknomask = 0;
12572         ushort_t is_aligned = TRUE;
12573 
12574         ASSERT(un != NULL);
12575         ASSERT(bp != NULL);
12576         ASSERT(!mutex_owned(SD_MUTEX(un)));
12577 
12578         SD_TRACE(SD_LOG_IO_PARTITION, un,
12579             "sd_mapblockaddr_iostart: entry: buf:0x%p\n", bp);
12580 
12581         xp = SD_GET_XBUF(bp);
12582         ASSERT(xp != NULL);
12583 
12584         /*
12585          * If the geometry is not indicated as valid, attempt to access
12586          * the unit & verify the geometry/label. This can be the case for
12587          * removable-media devices, of if the device was opened in
12588          * NDELAY/NONBLOCK mode.
12589          */
12590         partition = SDPART(bp->b_edev);
12591 
12592         if (!SD_IS_VALID_LABEL(un)) {
12593                 sd_ssc_t *ssc;
12594                 /*
12595                  * Initialize sd_ssc_t for internal uscsi commands
12596                  * In case of potential porformance issue, we need
12597                  * to alloc memory only if there is invalid label
12598                  */
12599                 ssc = sd_ssc_init(un);
12600 
12601                 if (sd_ready_and_valid(ssc, partition) != SD_READY_VALID) {
12602                         /*
12603                          * For removable devices it is possible to start an
12604                          * I/O without a media by opening the device in nodelay
12605                          * mode. Also for writable CDs there can be many
12606                          * scenarios where there is no geometry yet but volume
12607                          * manager is trying to issue a read() just because
12608                          * it can see TOC on the CD. So do not print a message
12609                          * for removables.
12610                          */
12611                         if (!un->un_f_has_removable_media) {
12612                                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
12613                                     "i/o to invalid geometry\n");
12614                         }
12615                         bioerror(bp, EIO);
12616                         bp->b_resid = bp->b_bcount;
12617                         SD_BEGIN_IODONE(index, un, bp);
12618 
12619                         sd_ssc_fini(ssc);
12620                         return;
12621                 }
12622                 sd_ssc_fini(ssc);
12623         }
12624 
12625         nblocks = 0;
12626         (void) cmlb_partinfo(un->un_cmlbhandle, partition,
12627             &nblocks, &partition_offset, NULL, NULL, (void *)SD_PATH_DIRECT);
12628 
12629         if (un->un_f_enable_rmw) {
12630                 blknomask = (un->un_phy_blocksize / DEV_BSIZE) - 1;
12631                 secmask = un->un_phy_blocksize - 1;
12632         } else {
12633                 blknomask = (un->un_tgt_blocksize / DEV_BSIZE) - 1;
12634                 secmask = un->un_tgt_blocksize - 1;
12635         }
12636 
12637         if ((bp->b_lblkno & (blknomask)) || (bp->b_bcount & (secmask))) {
12638                 is_aligned = FALSE;
12639         }
12640 
12641         if (!(NOT_DEVBSIZE(un)) || un->un_f_enable_rmw) {
12642                 /*
12643                  * If I/O is aligned, no need to involve RMW(Read Modify Write)
12644                  * Convert the logical block number to target's physical sector
12645                  * number.
12646                  */
12647                 if (is_aligned) {
12648                         xp->xb_blkno = SD_SYS2TGTBLOCK(un, xp->xb_blkno);
12649                 } else {
12650                         switch (un->un_f_rmw_type) {
12651                         case SD_RMW_TYPE_RETURN_ERROR:
12652                                 if (un->un_f_enable_rmw)
12653                                         break;
12654                                 else {
12655                                         bp->b_flags |= B_ERROR;
12656                                         goto error_exit;
12657                                 }
12658 
12659                         case SD_RMW_TYPE_DEFAULT:
12660                                 mutex_enter(SD_MUTEX(un));
12661                                 if (!un->un_f_enable_rmw &&
12662                                     un->un_rmw_msg_timeid == NULL) {
12663                                         scsi_log(SD_DEVINFO(un), sd_label,
12664                                             CE_WARN, "I/O request is not "
12665                                             "aligned with %d disk sector size. "
12666                                             "It is handled through Read Modify "
12667                                             "Write but the performance is "
12668                                             "very low.\n",
12669                                             un->un_tgt_blocksize);
12670                                         un->un_rmw_msg_timeid =
12671                                             timeout(sd_rmw_msg_print_handler,
12672                                             un, SD_RMW_MSG_PRINT_TIMEOUT);
12673                                 } else {
12674                                         un->un_rmw_incre_count ++;
12675                                 }
12676                                 mutex_exit(SD_MUTEX(un));
12677                                 break;
12678 
12679                         case SD_RMW_TYPE_NO_WARNING:
12680                         default:
12681                                 break;
12682                         }
12683 
12684                         nblocks = SD_TGT2SYSBLOCK(un, nblocks);
12685                         partition_offset = SD_TGT2SYSBLOCK(un,
12686                             partition_offset);
12687                 }
12688         }
12689 
12690         /*
12691          * blocknum is the starting block number of the request. At this
12692          * point it is still relative to the start of the minor device.
12693          */
12694         blocknum = xp->xb_blkno;
12695 
12696         /*
12697          * Legacy: If the starting block number is one past the last block
12698          * in the partition, do not set B_ERROR in the buf.
12699          */
12700         if (blocknum == nblocks)  {
12701                 goto error_exit;
12702         }
12703 
12704         /*
12705          * Confirm that the first block of the request lies within the
12706          * partition limits. Also the requested number of bytes must be
12707          * a multiple of the system block size.
12708          */
12709         if ((blocknum < 0) || (blocknum >= nblocks) ||
12710             ((bp->b_bcount & (DEV_BSIZE - 1)) != 0)) {
12711                 bp->b_flags |= B_ERROR;
12712                 goto error_exit;
12713         }
12714 
12715         /*
12716          * If the requsted # blocks exceeds the available # blocks, that
12717          * is an overrun of the partition.
12718          */
12719         if ((!NOT_DEVBSIZE(un)) && is_aligned) {
12720                 requested_nblocks = SD_BYTES2TGTBLOCKS(un, bp->b_bcount);
12721         } else {
12722                 requested_nblocks = SD_BYTES2SYSBLOCKS(bp->b_bcount);
12723         }
12724 
12725         available_nblocks = (size_t)(nblocks - blocknum);
12726         ASSERT(nblocks >= blocknum);
12727 
12728         if (requested_nblocks > available_nblocks) {
12729                 size_t resid;
12730 
12731                 /*
12732                  * Allocate an "overrun" buf to allow the request to proceed
12733                  * for the amount of space available in the partition. The
12734                  * amount not transferred will be added into the b_resid
12735                  * when the operation is complete. The overrun buf
12736                  * replaces the original buf here, and the original buf
12737                  * is saved inside the overrun buf, for later use.
12738                  */
12739                 if ((!NOT_DEVBSIZE(un)) && is_aligned) {
12740                         resid = SD_TGTBLOCKS2BYTES(un,
12741                             (offset_t)(requested_nblocks - available_nblocks));
12742                 } else {
12743                         resid = SD_SYSBLOCKS2BYTES(
12744                             (offset_t)(requested_nblocks - available_nblocks));
12745                 }
12746 
12747                 size_t count = bp->b_bcount - resid;
12748                 /*
12749                  * Note: count is an unsigned entity thus it'll NEVER
12750                  * be less than 0 so ASSERT the original values are
12751                  * correct.
12752                  */
12753                 ASSERT(bp->b_bcount >= resid);
12754 
12755                 bp = sd_bioclone_alloc(bp, count, blocknum,
12756                     (int (*)(struct buf *)) sd_mapblockaddr_iodone);
12757                 xp = SD_GET_XBUF(bp); /* Update for 'new' bp! */
12758                 ASSERT(xp != NULL);
12759         }
12760 
12761         /* At this point there should be no residual for this buf. */
12762         ASSERT(bp->b_resid == 0);
12763 
12764         /* Convert the block number to an absolute address. */
12765         xp->xb_blkno += partition_offset;
12766 
12767         SD_NEXT_IOSTART(index, un, bp);
12768 
12769         SD_TRACE(SD_LOG_IO_PARTITION, un,
12770             "sd_mapblockaddr_iostart: exit 0: buf:0x%p\n", bp);
12771 
12772         return;
12773 
12774 error_exit:
12775         bp->b_resid = bp->b_bcount;
12776         SD_BEGIN_IODONE(index, un, bp);
12777         SD_TRACE(SD_LOG_IO_PARTITION, un,
12778             "sd_mapblockaddr_iostart: exit 1: buf:0x%p\n", bp);
12779 }
12780 
12781 
12782 /*
12783  *    Function: sd_mapblockaddr_iodone
12784  *
12785  * Description: Completion-side processing for partition management.
12786  *
12787  *     Context: May be called under interrupt context
12788  */
12789 
12790 static void
12791 sd_mapblockaddr_iodone(int index, struct sd_lun *un, struct buf *bp)
12792 {
12793         /* int  partition; */   /* Not used, see below. */
12794         ASSERT(un != NULL);
12795         ASSERT(bp != NULL);
12796         ASSERT(!mutex_owned(SD_MUTEX(un)));
12797 
12798         SD_TRACE(SD_LOG_IO_PARTITION, un,
12799             "sd_mapblockaddr_iodone: entry: buf:0x%p\n", bp);
12800 
12801         if (bp->b_iodone == (int (*)(struct buf *)) sd_mapblockaddr_iodone) {
12802                 /*
12803                  * We have an "overrun" buf to deal with...
12804                  */
12805                 struct sd_xbuf  *xp;
12806                 struct buf      *obp;   /* ptr to the original buf */
12807 
12808                 xp = SD_GET_XBUF(bp);
12809                 ASSERT(xp != NULL);
12810 
12811                 /* Retrieve the pointer to the original buf */
12812                 obp = (struct buf *)xp->xb_private;
12813                 ASSERT(obp != NULL);
12814 
12815                 obp->b_resid = obp->b_bcount - (bp->b_bcount - bp->b_resid);
12816                 bioerror(obp, bp->b_error);
12817 
12818                 sd_bioclone_free(bp);
12819 
12820                 /*
12821                  * Get back the original buf.
12822                  * Note that since the restoration of xb_blkno below
12823                  * was removed, the sd_xbuf is not needed.
12824                  */
12825                 bp = obp;
12826                 /*
12827                  * xp = SD_GET_XBUF(bp);
12828                  * ASSERT(xp != NULL);
12829                  */
12830         }
12831 
12832         /*
12833          * Convert sd->xb_blkno back to a minor-device relative value.
12834          * Note: this has been commented out, as it is not needed in the
12835          * current implementation of the driver (ie, since this function
12836          * is at the top of the layering chains, so the info will be
12837          * discarded) and it is in the "hot" IO path.
12838          *
12839          * partition = getminor(bp->b_edev) & SDPART_MASK;
12840          * xp->xb_blkno -= un->un_offset[partition];
12841          */
12842 
12843         SD_NEXT_IODONE(index, un, bp);
12844 
12845         SD_TRACE(SD_LOG_IO_PARTITION, un,
12846             "sd_mapblockaddr_iodone: exit: buf:0x%p\n", bp);
12847 }
12848 
12849 
12850 /*
12851  *    Function: sd_mapblocksize_iostart
12852  *
12853  * Description: Convert between system block size (un->un_sys_blocksize)
12854  *              and target block size (un->un_tgt_blocksize).
12855  *
12856  *     Context: Can sleep to allocate resources.
12857  *
12858  * Assumptions: A higher layer has already performed any partition validation,
12859  *              and converted the xp->xb_blkno to an absolute value relative
12860  *              to the start of the device.
12861  *
12862  *              It is also assumed that the higher layer has implemented
12863  *              an "overrun" mechanism for the case where the request would
12864  *              read/write beyond the end of a partition.  In this case we
12865  *              assume (and ASSERT) that bp->b_resid == 0.
12866  *
12867  *              Note: The implementation for this routine assumes the target
12868  *              block size remains constant between allocation and transport.
12869  */
12870 
12871 static void
12872 sd_mapblocksize_iostart(int index, struct sd_lun *un, struct buf *bp)
12873 {
12874         struct sd_mapblocksize_info     *bsp;
12875         struct sd_xbuf                  *xp;
12876         offset_t first_byte;
12877         daddr_t start_block, end_block;
12878         daddr_t request_bytes;
12879         ushort_t is_aligned = FALSE;
12880 
12881         ASSERT(un != NULL);
12882         ASSERT(bp != NULL);
12883         ASSERT(!mutex_owned(SD_MUTEX(un)));
12884         ASSERT(bp->b_resid == 0);
12885 
12886         SD_TRACE(SD_LOG_IO_RMMEDIA, un,
12887             "sd_mapblocksize_iostart: entry: buf:0x%p\n", bp);
12888 
12889         /*
12890          * For a non-writable CD, a write request is an error
12891          */
12892         if (ISCD(un) && ((bp->b_flags & B_READ) == 0) &&
12893             (un->un_f_mmc_writable_media == FALSE)) {
12894                 bioerror(bp, EIO);
12895                 bp->b_resid = bp->b_bcount;
12896                 SD_BEGIN_IODONE(index, un, bp);
12897                 return;
12898         }
12899 
12900         /*
12901          * We do not need a shadow buf if the device is using
12902          * un->un_sys_blocksize as its block size or if bcount == 0.
12903          * In this case there is no layer-private data block allocated.
12904          */
12905         if ((un->un_tgt_blocksize == DEV_BSIZE && !un->un_f_enable_rmw) ||
12906             (bp->b_bcount == 0)) {
12907                 goto done;
12908         }
12909 
12910 #if defined(__i386) || defined(__amd64)
12911         /* We do not support non-block-aligned transfers for ROD devices */
12912         ASSERT(!ISROD(un));
12913 #endif
12914 
12915         xp = SD_GET_XBUF(bp);
12916         ASSERT(xp != NULL);
12917 
12918         SD_INFO(SD_LOG_IO_RMMEDIA, un, "sd_mapblocksize_iostart: "
12919             "tgt_blocksize:0x%x sys_blocksize: 0x%x\n",
12920             un->un_tgt_blocksize, DEV_BSIZE);
12921         SD_INFO(SD_LOG_IO_RMMEDIA, un, "sd_mapblocksize_iostart: "
12922             "request start block:0x%x\n", xp->xb_blkno);
12923         SD_INFO(SD_LOG_IO_RMMEDIA, un, "sd_mapblocksize_iostart: "
12924             "request len:0x%x\n", bp->b_bcount);
12925 
12926         /*
12927          * Allocate the layer-private data area for the mapblocksize layer.
12928          * Layers are allowed to use the xp_private member of the sd_xbuf
12929          * struct to store the pointer to their layer-private data block, but
12930          * each layer also has the responsibility of restoring the prior
12931          * contents of xb_private before returning the buf/xbuf to the
12932          * higher layer that sent it.
12933          *
12934          * Here we save the prior contents of xp->xb_private into the
12935          * bsp->mbs_oprivate field of our layer-private data area. This value
12936          * is restored by sd_mapblocksize_iodone() just prior to freeing up
12937          * the layer-private area and returning the buf/xbuf to the layer
12938          * that sent it.
12939          *
12940          * Note that here we use kmem_zalloc for the allocation as there are
12941          * parts of the mapblocksize code that expect certain fields to be
12942          * zero unless explicitly set to a required value.
12943          */
12944         bsp = kmem_zalloc(sizeof (struct sd_mapblocksize_info), KM_SLEEP);
12945         bsp->mbs_oprivate = xp->xb_private;
12946         xp->xb_private = bsp;
12947 
12948         /*
12949          * This treats the data on the disk (target) as an array of bytes.
12950          * first_byte is the byte offset, from the beginning of the device,
12951          * to the location of the request. This is converted from a
12952          * un->un_sys_blocksize block address to a byte offset, and then back
12953          * to a block address based upon a un->un_tgt_blocksize block size.
12954          *
12955          * xp->xb_blkno should be absolute upon entry into this function,
12956          * but, but it is based upon partitions that use the "system"
12957          * block size. It must be adjusted to reflect the block size of
12958          * the target.
12959          *
12960          * Note that end_block is actually the block that follows the last
12961          * block of the request, but that's what is needed for the computation.
12962          */
12963         first_byte  = SD_SYSBLOCKS2BYTES((offset_t)xp->xb_blkno);
12964         if (un->un_f_enable_rmw) {
12965                 start_block = xp->xb_blkno =
12966                     (first_byte / un->un_phy_blocksize) *
12967                     (un->un_phy_blocksize / DEV_BSIZE);
12968                 end_block   = ((first_byte + bp->b_bcount +
12969                     un->un_phy_blocksize - 1) / un->un_phy_blocksize) *
12970                     (un->un_phy_blocksize / DEV_BSIZE);
12971         } else {
12972                 start_block = xp->xb_blkno = first_byte / un->un_tgt_blocksize;
12973                 end_block   = (first_byte + bp->b_bcount +
12974                     un->un_tgt_blocksize - 1) / un->un_tgt_blocksize;
12975         }
12976 
12977         /* request_bytes is rounded up to a multiple of the target block size */
12978         request_bytes = (end_block - start_block) * un->un_tgt_blocksize;
12979 
12980         /*
12981          * See if the starting address of the request and the request
12982          * length are aligned on a un->un_tgt_blocksize boundary. If aligned
12983          * then we do not need to allocate a shadow buf to handle the request.
12984          */
12985         if (un->un_f_enable_rmw) {
12986                 if (((first_byte % un->un_phy_blocksize) == 0) &&
12987                     ((bp->b_bcount % un->un_phy_blocksize) == 0)) {
12988                         is_aligned = TRUE;
12989                 }
12990         } else {
12991                 if (((first_byte % un->un_tgt_blocksize) == 0) &&
12992                     ((bp->b_bcount % un->un_tgt_blocksize) == 0)) {
12993                         is_aligned = TRUE;
12994                 }
12995         }
12996 
12997         if ((bp->b_flags & B_READ) == 0) {
12998                 /*
12999                  * Lock the range for a write operation. An aligned request is
13000                  * considered a simple write; otherwise the request must be a
13001                  * read-modify-write.
13002                  */
13003                 bsp->mbs_wmp = sd_range_lock(un, start_block, end_block - 1,
13004                     (is_aligned == TRUE) ? SD_WTYPE_SIMPLE : SD_WTYPE_RMW);
13005         }
13006 
13007         /*
13008          * Alloc a shadow buf if the request is not aligned. Also, this is
13009          * where the READ command is generated for a read-modify-write. (The
13010          * write phase is deferred until after the read completes.)
13011          */
13012         if (is_aligned == FALSE) {
13013 
13014                 struct sd_mapblocksize_info     *shadow_bsp;
13015                 struct sd_xbuf  *shadow_xp;
13016                 struct buf      *shadow_bp;
13017 
13018                 /*
13019                  * Allocate the shadow buf and it associated xbuf. Note that
13020                  * after this call the xb_blkno value in both the original
13021                  * buf's sd_xbuf _and_ the shadow buf's sd_xbuf will be the
13022                  * same: absolute relative to the start of the device, and
13023                  * adjusted for the target block size. The b_blkno in the
13024                  * shadow buf will also be set to this value. We should never
13025                  * change b_blkno in the original bp however.
13026                  *
13027                  * Note also that the shadow buf will always need to be a
13028                  * READ command, regardless of whether the incoming command
13029                  * is a READ or a WRITE.
13030                  */
13031                 shadow_bp = sd_shadow_buf_alloc(bp, request_bytes, B_READ,
13032                     xp->xb_blkno,
13033                     (int (*)(struct buf *)) sd_mapblocksize_iodone);
13034 
13035                 shadow_xp = SD_GET_XBUF(shadow_bp);
13036 
13037                 /*
13038                  * Allocate the layer-private data for the shadow buf.
13039                  * (No need to preserve xb_private in the shadow xbuf.)
13040                  */
13041                 shadow_xp->xb_private = shadow_bsp =
13042                     kmem_zalloc(sizeof (struct sd_mapblocksize_info), KM_SLEEP);
13043 
13044                 /*
13045                  * bsp->mbs_copy_offset is used later by sd_mapblocksize_iodone
13046                  * to figure out where the start of the user data is (based upon
13047                  * the system block size) in the data returned by the READ
13048                  * command (which will be based upon the target blocksize). Note
13049                  * that this is only really used if the request is unaligned.
13050                  */
13051                 if (un->un_f_enable_rmw) {
13052                         bsp->mbs_copy_offset = (ssize_t)(first_byte -
13053                             ((offset_t)xp->xb_blkno * un->un_sys_blocksize));
13054                         ASSERT((bsp->mbs_copy_offset >= 0) &&
13055                             (bsp->mbs_copy_offset < un->un_phy_blocksize));
13056                 } else {
13057                         bsp->mbs_copy_offset = (ssize_t)(first_byte -
13058                             ((offset_t)xp->xb_blkno * un->un_tgt_blocksize));
13059                         ASSERT((bsp->mbs_copy_offset >= 0) &&
13060                             (bsp->mbs_copy_offset < un->un_tgt_blocksize));
13061                 }
13062 
13063                 shadow_bsp->mbs_copy_offset = bsp->mbs_copy_offset;
13064 
13065                 shadow_bsp->mbs_layer_index = bsp->mbs_layer_index = index;
13066 
13067                 /* Transfer the wmap (if any) to the shadow buf */
13068                 shadow_bsp->mbs_wmp = bsp->mbs_wmp;
13069                 bsp->mbs_wmp = NULL;
13070 
13071                 /*
13072                  * The shadow buf goes on from here in place of the
13073                  * original buf.
13074                  */
13075                 shadow_bsp->mbs_orig_bp = bp;
13076                 bp = shadow_bp;
13077         }
13078 
13079         SD_INFO(SD_LOG_IO_RMMEDIA, un,
13080             "sd_mapblocksize_iostart: tgt start block:0x%x\n", xp->xb_blkno);
13081         SD_INFO(SD_LOG_IO_RMMEDIA, un,
13082             "sd_mapblocksize_iostart: tgt request len:0x%x\n",
13083             request_bytes);
13084         SD_INFO(SD_LOG_IO_RMMEDIA, un,
13085             "sd_mapblocksize_iostart: shadow buf:0x%x\n", bp);
13086 
13087 done:
13088         SD_NEXT_IOSTART(index, un, bp);
13089 
13090         SD_TRACE(SD_LOG_IO_RMMEDIA, un,
13091             "sd_mapblocksize_iostart: exit: buf:0x%p\n", bp);
13092 }
13093 
13094 
13095 /*
13096  *    Function: sd_mapblocksize_iodone
13097  *
13098  * Description: Completion side processing for block-size mapping.
13099  *
13100  *     Context: May be called under interrupt context
13101  */
13102 
13103 static void
13104 sd_mapblocksize_iodone(int index, struct sd_lun *un, struct buf *bp)
13105 {
13106         struct sd_mapblocksize_info     *bsp;
13107         struct sd_xbuf  *xp;
13108         struct sd_xbuf  *orig_xp;       /* sd_xbuf for the original buf */
13109         struct buf      *orig_bp;       /* ptr to the original buf */
13110         offset_t        shadow_end;
13111         offset_t        request_end;
13112         offset_t        shadow_start;
13113         ssize_t         copy_offset;
13114         size_t          copy_length;
13115         size_t          shortfall;
13116         uint_t          is_write;       /* TRUE if this bp is a WRITE */
13117         uint_t          has_wmap;       /* TRUE is this bp has a wmap */
13118 
13119         ASSERT(un != NULL);
13120         ASSERT(bp != NULL);
13121 
13122         SD_TRACE(SD_LOG_IO_RMMEDIA, un,
13123             "sd_mapblocksize_iodone: entry: buf:0x%p\n", bp);
13124 
13125         /*
13126          * There is no shadow buf or layer-private data if the target is
13127          * using un->un_sys_blocksize as its block size or if bcount == 0.
13128          */
13129         if ((un->un_tgt_blocksize == DEV_BSIZE && !un->un_f_enable_rmw) ||
13130             (bp->b_bcount == 0)) {
13131                 goto exit;
13132         }
13133 
13134         xp = SD_GET_XBUF(bp);
13135         ASSERT(xp != NULL);
13136 
13137         /* Retrieve the pointer to the layer-private data area from the xbuf. */
13138         bsp = xp->xb_private;
13139 
13140         is_write = ((bp->b_flags & B_READ) == 0) ? TRUE : FALSE;
13141         has_wmap = (bsp->mbs_wmp != NULL) ? TRUE : FALSE;
13142 
13143         if (is_write) {
13144                 /*
13145                  * For a WRITE request we must free up the block range that
13146                  * we have locked up.  This holds regardless of whether this is
13147                  * an aligned write request or a read-modify-write request.
13148                  */
13149                 sd_range_unlock(un, bsp->mbs_wmp);
13150                 bsp->mbs_wmp = NULL;
13151         }
13152 
13153         if ((bp->b_iodone != (int(*)(struct buf *))sd_mapblocksize_iodone)) {
13154                 /*
13155                  * An aligned read or write command will have no shadow buf;
13156                  * there is not much else to do with it.
13157                  */
13158                 goto done;
13159         }
13160 
13161         orig_bp = bsp->mbs_orig_bp;
13162         ASSERT(orig_bp != NULL);
13163         orig_xp = SD_GET_XBUF(orig_bp);
13164         ASSERT(orig_xp != NULL);
13165         ASSERT(!mutex_owned(SD_MUTEX(un)));
13166 
13167         if (!is_write && has_wmap) {
13168                 /*
13169                  * A READ with a wmap means this is the READ phase of a
13170                  * read-modify-write. If an error occurred on the READ then
13171                  * we do not proceed with the WRITE phase or copy any data.
13172                  * Just release the write maps and return with an error.
13173                  */
13174                 if ((bp->b_resid != 0) || (bp->b_error != 0)) {
13175                         orig_bp->b_resid = orig_bp->b_bcount;
13176                         bioerror(orig_bp, bp->b_error);
13177                         sd_range_unlock(un, bsp->mbs_wmp);
13178                         goto freebuf_done;
13179                 }
13180         }
13181 
13182         /*
13183          * Here is where we set up to copy the data from the shadow buf
13184          * into the space associated with the original buf.
13185          *
13186          * To deal with the conversion between block sizes, these
13187          * computations treat the data as an array of bytes, with the
13188          * first byte (byte 0) corresponding to the first byte in the
13189          * first block on the disk.
13190          */
13191 
13192         /*
13193          * shadow_start and shadow_len indicate the location and size of
13194          * the data returned with the shadow IO request.
13195          */
13196         if (un->un_f_enable_rmw) {
13197                 shadow_start  = SD_SYSBLOCKS2BYTES((offset_t)xp->xb_blkno);
13198         } else {
13199                 shadow_start  = SD_TGTBLOCKS2BYTES(un, (offset_t)xp->xb_blkno);
13200         }
13201         shadow_end    = shadow_start + bp->b_bcount - bp->b_resid;
13202 
13203         /*
13204          * copy_offset gives the offset (in bytes) from the start of the first
13205          * block of the READ request to the beginning of the data.  We retrieve
13206          * this value from xb_pktp in the ORIGINAL xbuf, as it has been saved
13207          * there by sd_mapblockize_iostart(). copy_length gives the amount of
13208          * data to be copied (in bytes).
13209          */
13210         copy_offset  = bsp->mbs_copy_offset;
13211         if (un->un_f_enable_rmw) {
13212                 ASSERT((copy_offset >= 0) &&
13213                     (copy_offset < un->un_phy_blocksize));
13214         } else {
13215                 ASSERT((copy_offset >= 0) &&
13216                     (copy_offset < un->un_tgt_blocksize));
13217         }
13218 
13219         copy_length  = orig_bp->b_bcount;
13220         request_end  = shadow_start + copy_offset + orig_bp->b_bcount;
13221 
13222         /*
13223          * Set up the resid and error fields of orig_bp as appropriate.
13224          */
13225         if (shadow_end >= request_end) {
13226                 /* We got all the requested data; set resid to zero */
13227                 orig_bp->b_resid = 0;
13228         } else {
13229                 /*
13230                  * We failed to get enough data to fully satisfy the original
13231                  * request. Just copy back whatever data we got and set
13232                  * up the residual and error code as required.
13233                  *
13234                  * 'shortfall' is the amount by which the data received with the
13235                  * shadow buf has "fallen short" of the requested amount.
13236                  */
13237                 shortfall = (size_t)(request_end - shadow_end);
13238 
13239                 if (shortfall > orig_bp->b_bcount) {
13240                         /*
13241                          * We did not get enough data to even partially
13242                          * fulfill the original request.  The residual is
13243                          * equal to the amount requested.
13244                          */
13245                         orig_bp->b_resid = orig_bp->b_bcount;
13246                 } else {
13247                         /*
13248                          * We did not get all the data that we requested
13249                          * from the device, but we will try to return what
13250                          * portion we did get.
13251                          */
13252                         orig_bp->b_resid = shortfall;
13253                 }
13254                 ASSERT(copy_length >= orig_bp->b_resid);
13255                 copy_length  -= orig_bp->b_resid;
13256         }
13257 
13258         /* Propagate the error code from the shadow buf to the original buf */
13259         bioerror(orig_bp, bp->b_error);
13260 
13261         if (is_write) {
13262                 goto freebuf_done;      /* No data copying for a WRITE */
13263         }
13264 
13265         if (has_wmap) {
13266                 /*
13267                  * This is a READ command from the READ phase of a
13268                  * read-modify-write request. We have to copy the data given
13269                  * by the user OVER the data returned by the READ command,
13270                  * then convert the command from a READ to a WRITE and send
13271                  * it back to the target.
13272                  */
13273                 bcopy(orig_bp->b_un.b_addr, bp->b_un.b_addr + copy_offset,
13274                     copy_length);
13275 
13276                 bp->b_flags &= ~((int)B_READ);   /* Convert to a WRITE */
13277 
13278                 /*
13279                  * Dispatch the WRITE command to the taskq thread, which
13280                  * will in turn send the command to the target. When the
13281                  * WRITE command completes, we (sd_mapblocksize_iodone())
13282                  * will get called again as part of the iodone chain
13283                  * processing for it. Note that we will still be dealing
13284                  * with the shadow buf at that point.
13285                  */
13286                 if (taskq_dispatch(sd_wmr_tq, sd_read_modify_write_task, bp,
13287                     KM_NOSLEEP) != 0) {
13288                         /*
13289                          * Dispatch was successful so we are done. Return
13290                          * without going any higher up the iodone chain. Do
13291                          * not free up any layer-private data until after the
13292                          * WRITE completes.
13293                          */
13294                         return;
13295                 }
13296 
13297                 /*
13298                  * Dispatch of the WRITE command failed; set up the error
13299                  * condition and send this IO back up the iodone chain.
13300                  */
13301                 bioerror(orig_bp, EIO);
13302                 orig_bp->b_resid = orig_bp->b_bcount;
13303 
13304         } else {
13305                 /*
13306                  * This is a regular READ request (ie, not a RMW). Copy the
13307                  * data from the shadow buf into the original buf. The
13308                  * copy_offset compensates for any "misalignment" between the
13309                  * shadow buf (with its un->un_tgt_blocksize blocks) and the
13310                  * original buf (with its un->un_sys_blocksize blocks).
13311                  */
13312                 bcopy(bp->b_un.b_addr + copy_offset, orig_bp->b_un.b_addr,
13313                     copy_length);
13314         }
13315 
13316 freebuf_done:
13317 
13318         /*
13319          * At this point we still have both the shadow buf AND the original
13320          * buf to deal with, as well as the layer-private data area in each.
13321          * Local variables are as follows:
13322          *
13323          * bp -- points to shadow buf
13324          * xp -- points to xbuf of shadow buf
13325          * bsp -- points to layer-private data area of shadow buf
13326          * orig_bp -- points to original buf
13327          *
13328          * First free the shadow buf and its associated xbuf, then free the
13329          * layer-private data area from the shadow buf. There is no need to
13330          * restore xb_private in the shadow xbuf.
13331          */
13332         sd_shadow_buf_free(bp);
13333         kmem_free(bsp, sizeof (struct sd_mapblocksize_info));
13334 
13335         /*
13336          * Now update the local variables to point to the original buf, xbuf,
13337          * and layer-private area.
13338          */
13339         bp = orig_bp;
13340         xp = SD_GET_XBUF(bp);
13341         ASSERT(xp != NULL);
13342         ASSERT(xp == orig_xp);
13343         bsp = xp->xb_private;
13344         ASSERT(bsp != NULL);
13345 
13346 done:
13347         /*
13348          * Restore xb_private to whatever it was set to by the next higher
13349          * layer in the chain, then free the layer-private data area.
13350          */
13351         xp->xb_private = bsp->mbs_oprivate;
13352         kmem_free(bsp, sizeof (struct sd_mapblocksize_info));
13353 
13354 exit:
13355         SD_TRACE(SD_LOG_IO_RMMEDIA, SD_GET_UN(bp),
13356             "sd_mapblocksize_iodone: calling SD_NEXT_IODONE: buf:0x%p\n", bp);
13357 
13358         SD_NEXT_IODONE(index, un, bp);
13359 }
13360 
13361 
13362 /*
13363  *    Function: sd_checksum_iostart
13364  *
13365  * Description: A stub function for a layer that's currently not used.
13366  *              For now just a placeholder.
13367  *
13368  *     Context: Kernel thread context
13369  */
13370 
13371 static void
13372 sd_checksum_iostart(int index, struct sd_lun *un, struct buf *bp)
13373 {
13374         ASSERT(un != NULL);
13375         ASSERT(bp != NULL);
13376         ASSERT(!mutex_owned(SD_MUTEX(un)));
13377         SD_NEXT_IOSTART(index, un, bp);
13378 }
13379 
13380 
13381 /*
13382  *    Function: sd_checksum_iodone
13383  *
13384  * Description: A stub function for a layer that's currently not used.
13385  *              For now just a placeholder.
13386  *
13387  *     Context: May be called under interrupt context
13388  */
13389 
13390 static void
13391 sd_checksum_iodone(int index, struct sd_lun *un, struct buf *bp)
13392 {
13393         ASSERT(un != NULL);
13394         ASSERT(bp != NULL);
13395         ASSERT(!mutex_owned(SD_MUTEX(un)));
13396         SD_NEXT_IODONE(index, un, bp);
13397 }
13398 
13399 
13400 /*
13401  *    Function: sd_checksum_uscsi_iostart
13402  *
13403  * Description: A stub function for a layer that's currently not used.
13404  *              For now just a placeholder.
13405  *
13406  *     Context: Kernel thread context
13407  */
13408 
13409 static void
13410 sd_checksum_uscsi_iostart(int index, struct sd_lun *un, struct buf *bp)
13411 {
13412         ASSERT(un != NULL);
13413         ASSERT(bp != NULL);
13414         ASSERT(!mutex_owned(SD_MUTEX(un)));
13415         SD_NEXT_IOSTART(index, un, bp);
13416 }
13417 
13418 
13419 /*
13420  *    Function: sd_checksum_uscsi_iodone
13421  *
13422  * Description: A stub function for a layer that's currently not used.
13423  *              For now just a placeholder.
13424  *
13425  *     Context: May be called under interrupt context
13426  */
13427 
13428 static void
13429 sd_checksum_uscsi_iodone(int index, struct sd_lun *un, struct buf *bp)
13430 {
13431         ASSERT(un != NULL);
13432         ASSERT(bp != NULL);
13433         ASSERT(!mutex_owned(SD_MUTEX(un)));
13434         SD_NEXT_IODONE(index, un, bp);
13435 }
13436 
13437 
13438 /*
13439  *    Function: sd_pm_iostart
13440  *
13441  * Description: iostart-side routine for Power mangement.
13442  *
13443  *     Context: Kernel thread context
13444  */
13445 
13446 static void
13447 sd_pm_iostart(int index, struct sd_lun *un, struct buf *bp)
13448 {
13449         ASSERT(un != NULL);
13450         ASSERT(bp != NULL);
13451         ASSERT(!mutex_owned(SD_MUTEX(un)));
13452         ASSERT(!mutex_owned(&un->un_pm_mutex));
13453 
13454         SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iostart: entry\n");
13455 
13456         if (sd_pm_entry(un) != DDI_SUCCESS) {
13457                 /*
13458                  * Set up to return the failed buf back up the 'iodone'
13459                  * side of the calling chain.
13460                  */
13461                 bioerror(bp, EIO);
13462                 bp->b_resid = bp->b_bcount;
13463 
13464                 SD_BEGIN_IODONE(index, un, bp);
13465 
13466                 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iostart: exit\n");
13467                 return;
13468         }
13469 
13470         SD_NEXT_IOSTART(index, un, bp);
13471 
13472         SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iostart: exit\n");
13473 }
13474 
13475 
13476 /*
13477  *    Function: sd_pm_iodone
13478  *
13479  * Description: iodone-side routine for power mangement.
13480  *
13481  *     Context: may be called from interrupt context
13482  */
13483 
13484 static void
13485 sd_pm_iodone(int index, struct sd_lun *un, struct buf *bp)
13486 {
13487         ASSERT(un != NULL);
13488         ASSERT(bp != NULL);
13489         ASSERT(!mutex_owned(&un->un_pm_mutex));
13490 
13491         SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iodone: entry\n");
13492 
13493         /*
13494          * After attach the following flag is only read, so don't
13495          * take the penalty of acquiring a mutex for it.
13496          */
13497         if (un->un_f_pm_is_enabled == TRUE) {
13498                 sd_pm_exit(un);
13499         }
13500 
13501         SD_NEXT_IODONE(index, un, bp);
13502 
13503         SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iodone: exit\n");
13504 }
13505 
13506 
13507 /*
13508  *    Function: sd_core_iostart
13509  *
13510  * Description: Primary driver function for enqueuing buf(9S) structs from
13511  *              the system and initiating IO to the target device
13512  *
13513  *     Context: Kernel thread context. Can sleep.
13514  *
13515  * Assumptions:  - The given xp->xb_blkno is absolute
13516  *                 (ie, relative to the start of the device).
13517  *               - The IO is to be done using the native blocksize of
13518  *                 the device, as specified in un->un_tgt_blocksize.
13519  */
13520 /* ARGSUSED */
13521 static void
13522 sd_core_iostart(int index, struct sd_lun *un, struct buf *bp)
13523 {
13524         struct sd_xbuf *xp;
13525 
13526         ASSERT(un != NULL);
13527         ASSERT(bp != NULL);
13528         ASSERT(!mutex_owned(SD_MUTEX(un)));
13529         ASSERT(bp->b_resid == 0);
13530 
13531         SD_TRACE(SD_LOG_IO_CORE, un, "sd_core_iostart: entry: bp:0x%p\n", bp);
13532 
13533         xp = SD_GET_XBUF(bp);
13534         ASSERT(xp != NULL);
13535 
13536         mutex_enter(SD_MUTEX(un));
13537 
13538         /*
13539          * If we are currently in the failfast state, fail any new IO
13540          * that has B_FAILFAST set, then return.
13541          */
13542         if ((bp->b_flags & B_FAILFAST) &&
13543             (un->un_failfast_state == SD_FAILFAST_ACTIVE)) {
13544                 mutex_exit(SD_MUTEX(un));
13545                 bioerror(bp, EIO);
13546                 bp->b_resid = bp->b_bcount;
13547                 SD_BEGIN_IODONE(index, un, bp);
13548                 return;
13549         }
13550 
13551         if (SD_IS_DIRECT_PRIORITY(xp)) {
13552                 /*
13553                  * Priority command -- transport it immediately.
13554                  *
13555                  * Note: We may want to assert that USCSI_DIAGNOSE is set,
13556                  * because all direct priority commands should be associated
13557                  * with error recovery actions which we don't want to retry.
13558                  */
13559                 sd_start_cmds(un, bp);
13560         } else {
13561                 /*
13562                  * Normal command -- add it to the wait queue, then start
13563                  * transporting commands from the wait queue.
13564                  */
13565                 sd_add_buf_to_waitq(un, bp);
13566                 SD_UPDATE_KSTATS(un, kstat_waitq_enter, bp);
13567                 sd_start_cmds(un, NULL);
13568         }
13569 
13570         mutex_exit(SD_MUTEX(un));
13571 
13572         SD_TRACE(SD_LOG_IO_CORE, un, "sd_core_iostart: exit: bp:0x%p\n", bp);
13573 }
13574 
13575 
13576 /*
13577  *    Function: sd_init_cdb_limits
13578  *
13579  * Description: This is to handle scsi_pkt initialization differences
13580  *              between the driver platforms.
13581  *
13582  *              Legacy behaviors:
13583  *
13584  *              If the block number or the sector count exceeds the
13585  *              capabilities of a Group 0 command, shift over to a
13586  *              Group 1 command. We don't blindly use Group 1
13587  *              commands because a) some drives (CDC Wren IVs) get a
13588  *              bit confused, and b) there is probably a fair amount
13589  *              of speed difference for a target to receive and decode
13590  *              a 10 byte command instead of a 6 byte command.
13591  *
13592  *              The xfer time difference of 6 vs 10 byte CDBs is
13593  *              still significant so this code is still worthwhile.
13594  *              10 byte CDBs are very inefficient with the fas HBA driver
13595  *              and older disks. Each CDB byte took 1 usec with some
13596  *              popular disks.
13597  *
13598  *     Context: Must be called at attach time
13599  */
13600 
13601 static void
13602 sd_init_cdb_limits(struct sd_lun *un)
13603 {
13604         int hba_cdb_limit;
13605 
13606         /*
13607          * Use CDB_GROUP1 commands for most devices except for
13608          * parallel SCSI fixed drives in which case we get better
13609          * performance using CDB_GROUP0 commands (where applicable).
13610          */
13611         un->un_mincdb = SD_CDB_GROUP1;
13612 #if !defined(__fibre)
13613         if (!un->un_f_is_fibre && !un->un_f_cfg_is_atapi && !ISROD(un) &&
13614             !un->un_f_has_removable_media) {
13615                 un->un_mincdb = SD_CDB_GROUP0;
13616         }
13617 #endif
13618 
13619         /*
13620          * Try to read the max-cdb-length supported by HBA.
13621          */
13622         un->un_max_hba_cdb = scsi_ifgetcap(SD_ADDRESS(un), "max-cdb-length", 1);
13623         if (0 >= un->un_max_hba_cdb) {
13624                 un->un_max_hba_cdb = CDB_GROUP4;
13625                 hba_cdb_limit = SD_CDB_GROUP4;
13626         } else if (0 < un->un_max_hba_cdb &&
13627             un->un_max_hba_cdb < CDB_GROUP1) {
13628                 hba_cdb_limit = SD_CDB_GROUP0;
13629         } else if (CDB_GROUP1 <= un->un_max_hba_cdb &&
13630             un->un_max_hba_cdb < CDB_GROUP5) {
13631                 hba_cdb_limit = SD_CDB_GROUP1;
13632         } else if (CDB_GROUP5 <= un->un_max_hba_cdb &&
13633             un->un_max_hba_cdb < CDB_GROUP4) {
13634                 hba_cdb_limit = SD_CDB_GROUP5;
13635         } else {
13636                 hba_cdb_limit = SD_CDB_GROUP4;
13637         }
13638 
13639         /*
13640          * Use CDB_GROUP5 commands for removable devices.  Use CDB_GROUP4
13641          * commands for fixed disks unless we are building for a 32 bit
13642          * kernel.
13643          */
13644 #ifdef _LP64
13645         un->un_maxcdb = (un->un_f_has_removable_media) ? SD_CDB_GROUP5 :
13646             min(hba_cdb_limit, SD_CDB_GROUP4);
13647 #else
13648         un->un_maxcdb = (un->un_f_has_removable_media) ? SD_CDB_GROUP5 :
13649             min(hba_cdb_limit, SD_CDB_GROUP1);
13650 #endif
13651 
13652         un->un_status_len = (int)((un->un_f_arq_enabled == TRUE)
13653             ? sizeof (struct scsi_arq_status) : 1);
13654         un->un_cmd_timeout = (ushort_t)sd_io_time;
13655         un->un_uscsi_timeout = ((ISCD(un)) ? 2 : 1) * un->un_cmd_timeout;
13656 }
13657 
13658 
13659 /*
13660  *    Function: sd_initpkt_for_buf
13661  *
13662  * Description: Allocate and initialize for transport a scsi_pkt struct,
13663  *              based upon the info specified in the given buf struct.
13664  *
13665  *              Assumes the xb_blkno in the request is absolute (ie,
13666  *              relative to the start of the device (NOT partition!).
13667  *              Also assumes that the request is using the native block
13668  *              size of the device (as returned by the READ CAPACITY
13669  *              command).
13670  *
13671  * Return Code: SD_PKT_ALLOC_SUCCESS
13672  *              SD_PKT_ALLOC_FAILURE
13673  *              SD_PKT_ALLOC_FAILURE_NO_DMA
13674  *              SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL
13675  *
13676  *     Context: Kernel thread and may be called from software interrupt context
13677  *              as part of a sdrunout callback. This function may not block or
13678  *              call routines that block
13679  */
13680 
13681 static int
13682 sd_initpkt_for_buf(struct buf *bp, struct scsi_pkt **pktpp)
13683 {
13684         struct sd_xbuf  *xp;
13685         struct scsi_pkt *pktp = NULL;
13686         struct sd_lun   *un;
13687         size_t          blockcount;
13688         daddr_t         startblock;
13689         int             rval;
13690         int             cmd_flags;
13691 
13692         ASSERT(bp != NULL);
13693         ASSERT(pktpp != NULL);
13694         xp = SD_GET_XBUF(bp);
13695         ASSERT(xp != NULL);
13696         un = SD_GET_UN(bp);
13697         ASSERT(un != NULL);
13698         ASSERT(mutex_owned(SD_MUTEX(un)));
13699         ASSERT(bp->b_resid == 0);
13700 
13701         SD_TRACE(SD_LOG_IO_CORE, un,
13702             "sd_initpkt_for_buf: entry: buf:0x%p\n", bp);
13703 
13704         mutex_exit(SD_MUTEX(un));
13705 
13706 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
13707         if (xp->xb_pkt_flags & SD_XB_DMA_FREED) {
13708                 /*
13709                  * Already have a scsi_pkt -- just need DMA resources.
13710                  * We must recompute the CDB in case the mapping returns
13711                  * a nonzero pkt_resid.
13712                  * Note: if this is a portion of a PKT_DMA_PARTIAL transfer
13713                  * that is being retried, the unmap/remap of the DMA resouces
13714                  * will result in the entire transfer starting over again
13715                  * from the very first block.
13716                  */
13717                 ASSERT(xp->xb_pktp != NULL);
13718                 pktp = xp->xb_pktp;
13719         } else {
13720                 pktp = NULL;
13721         }
13722 #endif /* __i386 || __amd64 */
13723 
13724         startblock = xp->xb_blkno;   /* Absolute block num. */
13725         blockcount = SD_BYTES2TGTBLOCKS(un, bp->b_bcount);
13726 
13727         cmd_flags = un->un_pkt_flags | (xp->xb_pkt_flags & SD_XB_INITPKT_MASK);
13728 
13729         /*
13730          * sd_setup_rw_pkt will determine the appropriate CDB group to use,
13731          * call scsi_init_pkt, and build the CDB.
13732          */
13733         rval = sd_setup_rw_pkt(un, &pktp, bp,
13734             cmd_flags, sdrunout, (caddr_t)un,
13735             startblock, blockcount);
13736 
13737         if (rval == 0) {
13738                 /*
13739                  * Success.
13740                  *
13741                  * If partial DMA is being used and required for this transfer.
13742                  * set it up here.
13743                  */
13744                 if ((un->un_pkt_flags & PKT_DMA_PARTIAL) != 0 &&
13745                     (pktp->pkt_resid != 0)) {
13746 
13747                         /*
13748                          * Save the CDB length and pkt_resid for the
13749                          * next xfer
13750                          */
13751                         xp->xb_dma_resid = pktp->pkt_resid;
13752 
13753                         /* rezero resid */
13754                         pktp->pkt_resid = 0;
13755 
13756                 } else {
13757                         xp->xb_dma_resid = 0;
13758                 }
13759 
13760                 pktp->pkt_flags = un->un_tagflags;
13761                 pktp->pkt_time  = un->un_cmd_timeout;
13762                 pktp->pkt_comp  = sdintr;
13763 
13764                 pktp->pkt_private = bp;
13765                 *pktpp = pktp;
13766 
13767                 SD_TRACE(SD_LOG_IO_CORE, un,
13768                     "sd_initpkt_for_buf: exit: buf:0x%p\n", bp);
13769 
13770 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
13771                 xp->xb_pkt_flags &= ~SD_XB_DMA_FREED;
13772 #endif
13773 
13774                 mutex_enter(SD_MUTEX(un));
13775                 return (SD_PKT_ALLOC_SUCCESS);
13776 
13777         }
13778 
13779         /*
13780          * SD_PKT_ALLOC_FAILURE is the only expected failure code
13781          * from sd_setup_rw_pkt.
13782          */
13783         ASSERT(rval == SD_PKT_ALLOC_FAILURE);
13784 
13785         if (rval == SD_PKT_ALLOC_FAILURE) {
13786                 *pktpp = NULL;
13787                 /*
13788                  * Set the driver state to RWAIT to indicate the driver
13789                  * is waiting on resource allocations. The driver will not
13790                  * suspend, pm_suspend, or detatch while the state is RWAIT.
13791                  */
13792                 mutex_enter(SD_MUTEX(un));
13793                 New_state(un, SD_STATE_RWAIT);
13794 
13795                 SD_ERROR(SD_LOG_IO_CORE, un,
13796                     "sd_initpkt_for_buf: No pktp. exit bp:0x%p\n", bp);
13797 
13798                 if ((bp->b_flags & B_ERROR) != 0) {
13799                         return (SD_PKT_ALLOC_FAILURE_NO_DMA);
13800                 }
13801                 return (SD_PKT_ALLOC_FAILURE);
13802         } else {
13803                 /*
13804                  * PKT_ALLOC_FAILURE_CDB_TOO_SMALL
13805                  *
13806                  * This should never happen.  Maybe someone messed with the
13807                  * kernel's minphys?
13808                  */
13809                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
13810                     "Request rejected: too large for CDB: "
13811                     "lba:0x%08lx  len:0x%08lx\n", startblock, blockcount);
13812                 SD_ERROR(SD_LOG_IO_CORE, un,
13813                     "sd_initpkt_for_buf: No cp. exit bp:0x%p\n", bp);
13814                 mutex_enter(SD_MUTEX(un));
13815                 return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL);
13816 
13817         }
13818 }
13819 
13820 
13821 /*
13822  *    Function: sd_destroypkt_for_buf
13823  *
13824  * Description: Free the scsi_pkt(9S) for the given bp (buf IO processing).
13825  *
13826  *     Context: Kernel thread or interrupt context
13827  */
13828 
13829 static void
13830 sd_destroypkt_for_buf(struct buf *bp)
13831 {
13832         ASSERT(bp != NULL);
13833         ASSERT(SD_GET_UN(bp) != NULL);
13834 
13835         SD_TRACE(SD_LOG_IO_CORE, SD_GET_UN(bp),
13836             "sd_destroypkt_for_buf: entry: buf:0x%p\n", bp);
13837 
13838         ASSERT(SD_GET_PKTP(bp) != NULL);
13839         scsi_destroy_pkt(SD_GET_PKTP(bp));
13840 
13841         SD_TRACE(SD_LOG_IO_CORE, SD_GET_UN(bp),
13842             "sd_destroypkt_for_buf: exit: buf:0x%p\n", bp);
13843 }
13844 
13845 /*
13846  *    Function: sd_setup_rw_pkt
13847  *
13848  * Description: Determines appropriate CDB group for the requested LBA
13849  *              and transfer length, calls scsi_init_pkt, and builds
13850  *              the CDB.  Do not use for partial DMA transfers except
13851  *              for the initial transfer since the CDB size must
13852  *              remain constant.
13853  *
13854  *     Context: Kernel thread and may be called from software interrupt
13855  *              context as part of a sdrunout callback. This function may not
13856  *              block or call routines that block
13857  */
13858 
13859 
13860 int
13861 sd_setup_rw_pkt(struct sd_lun *un,
13862     struct scsi_pkt **pktpp, struct buf *bp, int flags,
13863     int (*callback)(caddr_t), caddr_t callback_arg,
13864     diskaddr_t lba, uint32_t blockcount)
13865 {
13866         struct scsi_pkt *return_pktp;
13867         union scsi_cdb *cdbp;
13868         struct sd_cdbinfo *cp = NULL;
13869         int i;
13870 
13871         /*
13872          * See which size CDB to use, based upon the request.
13873          */
13874         for (i = un->un_mincdb; i <= un->un_maxcdb; i++) {
13875 
13876                 /*
13877                  * Check lba and block count against sd_cdbtab limits.
13878                  * In the partial DMA case, we have to use the same size
13879                  * CDB for all the transfers.  Check lba + blockcount
13880                  * against the max LBA so we know that segment of the
13881                  * transfer can use the CDB we select.
13882                  */
13883                 if ((lba + blockcount - 1 <= sd_cdbtab[i].sc_maxlba) &&
13884                     (blockcount <= sd_cdbtab[i].sc_maxlen)) {
13885 
13886                         /*
13887                          * The command will fit into the CDB type
13888                          * specified by sd_cdbtab[i].
13889                          */
13890                         cp = sd_cdbtab + i;
13891 
13892                         /*
13893                          * Call scsi_init_pkt so we can fill in the
13894                          * CDB.
13895                          */
13896                         return_pktp = scsi_init_pkt(SD_ADDRESS(un), *pktpp,
13897                             bp, cp->sc_grpcode, un->un_status_len, 0,
13898                             flags, callback, callback_arg);
13899 
13900                         if (return_pktp != NULL) {
13901 
13902                                 /*
13903                                  * Return new value of pkt
13904                                  */
13905                                 *pktpp = return_pktp;
13906 
13907                                 /*
13908                                  * To be safe, zero the CDB insuring there is
13909                                  * no leftover data from a previous command.
13910                                  */
13911                                 bzero(return_pktp->pkt_cdbp, cp->sc_grpcode);
13912 
13913                                 /*
13914                                  * Handle partial DMA mapping
13915                                  */
13916                                 if (return_pktp->pkt_resid != 0) {
13917 
13918                                         /*
13919                                          * Not going to xfer as many blocks as
13920                                          * originally expected
13921                                          */
13922                                         blockcount -=
13923                                             SD_BYTES2TGTBLOCKS(un,
13924                                             return_pktp->pkt_resid);
13925                                 }
13926 
13927                                 cdbp = (union scsi_cdb *)return_pktp->pkt_cdbp;
13928 
13929                                 /*
13930                                  * Set command byte based on the CDB
13931                                  * type we matched.
13932                                  */
13933                                 cdbp->scc_cmd = cp->sc_grpmask |
13934                                     ((bp->b_flags & B_READ) ?
13935                                     SCMD_READ : SCMD_WRITE);
13936 
13937                                 SD_FILL_SCSI1_LUN(un, return_pktp);
13938 
13939                                 /*
13940                                  * Fill in LBA and length
13941                                  */
13942                                 ASSERT((cp->sc_grpcode == CDB_GROUP1) ||
13943                                     (cp->sc_grpcode == CDB_GROUP4) ||
13944                                     (cp->sc_grpcode == CDB_GROUP0) ||
13945                                     (cp->sc_grpcode == CDB_GROUP5));
13946 
13947                                 if (cp->sc_grpcode == CDB_GROUP1) {
13948                                         FORMG1ADDR(cdbp, lba);
13949                                         FORMG1COUNT(cdbp, blockcount);
13950                                         return (0);
13951                                 } else if (cp->sc_grpcode == CDB_GROUP4) {
13952                                         FORMG4LONGADDR(cdbp, lba);
13953                                         FORMG4COUNT(cdbp, blockcount);
13954                                         return (0);
13955                                 } else if (cp->sc_grpcode == CDB_GROUP0) {
13956                                         FORMG0ADDR(cdbp, lba);
13957                                         FORMG0COUNT(cdbp, blockcount);
13958                                         return (0);
13959                                 } else if (cp->sc_grpcode == CDB_GROUP5) {
13960                                         FORMG5ADDR(cdbp, lba);
13961                                         FORMG5COUNT(cdbp, blockcount);
13962                                         return (0);
13963                                 }
13964 
13965                                 /*
13966                                  * It should be impossible to not match one
13967                                  * of the CDB types above, so we should never
13968                                  * reach this point.  Set the CDB command byte
13969                                  * to test-unit-ready to avoid writing
13970                                  * to somewhere we don't intend.
13971                                  */
13972                                 cdbp->scc_cmd = SCMD_TEST_UNIT_READY;
13973                                 return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL);
13974                         } else {
13975                                 /*
13976                                  * Couldn't get scsi_pkt
13977                                  */
13978                                 return (SD_PKT_ALLOC_FAILURE);
13979                         }
13980                 }
13981         }
13982 
13983         /*
13984          * None of the available CDB types were suitable.  This really
13985          * should never happen:  on a 64 bit system we support
13986          * READ16/WRITE16 which will hold an entire 64 bit disk address
13987          * and on a 32 bit system we will refuse to bind to a device
13988          * larger than 2TB so addresses will never be larger than 32 bits.
13989          */
13990         return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL);
13991 }
13992 
13993 /*
13994  *    Function: sd_setup_next_rw_pkt
13995  *
13996  * Description: Setup packet for partial DMA transfers, except for the
13997  *              initial transfer.  sd_setup_rw_pkt should be used for
13998  *              the initial transfer.
13999  *
14000  *     Context: Kernel thread and may be called from interrupt context.
14001  */
14002 
14003 int
14004 sd_setup_next_rw_pkt(struct sd_lun *un,
14005     struct scsi_pkt *pktp, struct buf *bp,
14006     diskaddr_t lba, uint32_t blockcount)
14007 {
14008         uchar_t com;
14009         union scsi_cdb *cdbp;
14010         uchar_t cdb_group_id;
14011 
14012         ASSERT(pktp != NULL);
14013         ASSERT(pktp->pkt_cdbp != NULL);
14014 
14015         cdbp = (union scsi_cdb *)pktp->pkt_cdbp;
14016         com = cdbp->scc_cmd;
14017         cdb_group_id = CDB_GROUPID(com);
14018 
14019         ASSERT((cdb_group_id == CDB_GROUPID_0) ||
14020             (cdb_group_id == CDB_GROUPID_1) ||
14021             (cdb_group_id == CDB_GROUPID_4) ||
14022             (cdb_group_id == CDB_GROUPID_5));
14023 
14024         /*
14025          * Move pkt to the next portion of the xfer.
14026          * func is NULL_FUNC so we do not have to release
14027          * the disk mutex here.
14028          */
14029         if (scsi_init_pkt(SD_ADDRESS(un), pktp, bp, 0, 0, 0, 0,
14030             NULL_FUNC, NULL) == pktp) {
14031                 /* Success.  Handle partial DMA */
14032                 if (pktp->pkt_resid != 0) {
14033                         blockcount -=
14034                             SD_BYTES2TGTBLOCKS(un, pktp->pkt_resid);
14035                 }
14036 
14037                 cdbp->scc_cmd = com;
14038                 SD_FILL_SCSI1_LUN(un, pktp);
14039                 if (cdb_group_id == CDB_GROUPID_1) {
14040                         FORMG1ADDR(cdbp, lba);
14041                         FORMG1COUNT(cdbp, blockcount);
14042                         return (0);
14043                 } else if (cdb_group_id == CDB_GROUPID_4) {
14044                         FORMG4LONGADDR(cdbp, lba);
14045                         FORMG4COUNT(cdbp, blockcount);
14046                         return (0);
14047                 } else if (cdb_group_id == CDB_GROUPID_0) {
14048                         FORMG0ADDR(cdbp, lba);
14049                         FORMG0COUNT(cdbp, blockcount);
14050                         return (0);
14051                 } else if (cdb_group_id == CDB_GROUPID_5) {
14052                         FORMG5ADDR(cdbp, lba);
14053                         FORMG5COUNT(cdbp, blockcount);
14054                         return (0);
14055                 }
14056 
14057                 /* Unreachable */
14058                 return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL);
14059         }
14060 
14061         /*
14062          * Error setting up next portion of cmd transfer.
14063          * Something is definitely very wrong and this
14064          * should not happen.
14065          */
14066         return (SD_PKT_ALLOC_FAILURE);
14067 }
14068 
14069 /*
14070  *    Function: sd_initpkt_for_uscsi
14071  *
14072  * Description: Allocate and initialize for transport a scsi_pkt struct,
14073  *              based upon the info specified in the given uscsi_cmd struct.
14074  *
14075  * Return Code: SD_PKT_ALLOC_SUCCESS
14076  *              SD_PKT_ALLOC_FAILURE
14077  *              SD_PKT_ALLOC_FAILURE_NO_DMA
14078  *              SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL
14079  *
14080  *     Context: Kernel thread and may be called from software interrupt context
14081  *              as part of a sdrunout callback. This function may not block or
14082  *              call routines that block
14083  */
14084 
14085 static int
14086 sd_initpkt_for_uscsi(struct buf *bp, struct scsi_pkt **pktpp)
14087 {
14088         struct uscsi_cmd *uscmd;
14089         struct sd_xbuf  *xp;
14090         struct scsi_pkt *pktp;
14091         struct sd_lun   *un;
14092         uint32_t        flags = 0;
14093 
14094         ASSERT(bp != NULL);
14095         ASSERT(pktpp != NULL);
14096         xp = SD_GET_XBUF(bp);
14097         ASSERT(xp != NULL);
14098         un = SD_GET_UN(bp);
14099         ASSERT(un != NULL);
14100         ASSERT(mutex_owned(SD_MUTEX(un)));
14101 
14102         /* The pointer to the uscsi_cmd struct is expected in xb_pktinfo */
14103         uscmd = (struct uscsi_cmd *)xp->xb_pktinfo;
14104         ASSERT(uscmd != NULL);
14105 
14106         SD_TRACE(SD_LOG_IO_CORE, un,
14107             "sd_initpkt_for_uscsi: entry: buf:0x%p\n", bp);
14108 
14109         /*
14110          * Allocate the scsi_pkt for the command.
14111          * Note: If PKT_DMA_PARTIAL flag is set, scsi_vhci binds a path
14112          *       during scsi_init_pkt time and will continue to use the
14113          *       same path as long as the same scsi_pkt is used without
14114          *       intervening scsi_dma_free(). Since uscsi command does
14115          *       not call scsi_dmafree() before retry failed command, it
14116          *       is necessary to make sure PKT_DMA_PARTIAL flag is NOT
14117          *       set such that scsi_vhci can use other available path for
14118          *       retry. Besides, ucsci command does not allow DMA breakup,
14119          *       so there is no need to set PKT_DMA_PARTIAL flag.
14120          */
14121         if (uscmd->uscsi_rqlen > SENSE_LENGTH) {
14122                 pktp = scsi_init_pkt(SD_ADDRESS(un), NULL,
14123                     ((bp->b_bcount != 0) ? bp : NULL), uscmd->uscsi_cdblen,
14124                     ((int)(uscmd->uscsi_rqlen) + sizeof (struct scsi_arq_status)
14125                     - sizeof (struct scsi_extended_sense)), 0,
14126                     (un->un_pkt_flags & ~PKT_DMA_PARTIAL) | PKT_XARQ,
14127                     sdrunout, (caddr_t)un);
14128         } else {
14129                 pktp = scsi_init_pkt(SD_ADDRESS(un), NULL,
14130                     ((bp->b_bcount != 0) ? bp : NULL), uscmd->uscsi_cdblen,
14131                     sizeof (struct scsi_arq_status), 0,
14132                     (un->un_pkt_flags & ~PKT_DMA_PARTIAL),
14133                     sdrunout, (caddr_t)un);
14134         }
14135 
14136         if (pktp == NULL) {
14137                 *pktpp = NULL;
14138                 /*
14139                  * Set the driver state to RWAIT to indicate the driver
14140                  * is waiting on resource allocations. The driver will not
14141                  * suspend, pm_suspend, or detatch while the state is RWAIT.
14142                  */
14143                 New_state(un, SD_STATE_RWAIT);
14144 
14145                 SD_ERROR(SD_LOG_IO_CORE, un,
14146                     "sd_initpkt_for_uscsi: No pktp. exit bp:0x%p\n", bp);
14147 
14148                 if ((bp->b_flags & B_ERROR) != 0) {
14149                         return (SD_PKT_ALLOC_FAILURE_NO_DMA);
14150                 }
14151                 return (SD_PKT_ALLOC_FAILURE);
14152         }
14153 
14154         /*
14155          * We do not do DMA breakup for USCSI commands, so return failure
14156          * here if all the needed DMA resources were not allocated.
14157          */
14158         if ((un->un_pkt_flags & PKT_DMA_PARTIAL) &&
14159             (bp->b_bcount != 0) && (pktp->pkt_resid != 0)) {
14160                 scsi_destroy_pkt(pktp);
14161                 SD_ERROR(SD_LOG_IO_CORE, un, "sd_initpkt_for_uscsi: "
14162                     "No partial DMA for USCSI. exit: buf:0x%p\n", bp);
14163                 return (SD_PKT_ALLOC_FAILURE_PKT_TOO_SMALL);
14164         }
14165 
14166         /* Init the cdb from the given uscsi struct */
14167         (void) scsi_setup_cdb((union scsi_cdb *)pktp->pkt_cdbp,
14168             uscmd->uscsi_cdb[0], 0, 0, 0);
14169 
14170         SD_FILL_SCSI1_LUN(un, pktp);
14171 
14172         /*
14173          * Set up the optional USCSI flags. See the uscsi (7I) man page
14174          * for listing of the supported flags.
14175          */
14176 
14177         if (uscmd->uscsi_flags & USCSI_SILENT) {
14178                 flags |= FLAG_SILENT;
14179         }
14180 
14181         if (uscmd->uscsi_flags & USCSI_DIAGNOSE) {
14182                 flags |= FLAG_DIAGNOSE;
14183         }
14184 
14185         if (uscmd->uscsi_flags & USCSI_ISOLATE) {
14186                 flags |= FLAG_ISOLATE;
14187         }
14188 
14189         if (un->un_f_is_fibre == FALSE) {
14190                 if (uscmd->uscsi_flags & USCSI_RENEGOT) {
14191                         flags |= FLAG_RENEGOTIATE_WIDE_SYNC;
14192                 }
14193         }
14194 
14195         /*
14196          * Set the pkt flags here so we save time later.
14197          * Note: These flags are NOT in the uscsi man page!!!
14198          */
14199         if (uscmd->uscsi_flags & USCSI_HEAD) {
14200                 flags |= FLAG_HEAD;
14201         }
14202 
14203         if (uscmd->uscsi_flags & USCSI_NOINTR) {
14204                 flags |= FLAG_NOINTR;
14205         }
14206 
14207         /*
14208          * For tagged queueing, things get a bit complicated.
14209          * Check first for head of queue and last for ordered queue.
14210          * If neither head nor order, use the default driver tag flags.
14211          */
14212         if ((uscmd->uscsi_flags & USCSI_NOTAG) == 0) {
14213                 if (uscmd->uscsi_flags & USCSI_HTAG) {
14214                         flags |= FLAG_HTAG;
14215                 } else if (uscmd->uscsi_flags & USCSI_OTAG) {
14216                         flags |= FLAG_OTAG;
14217                 } else {
14218                         flags |= un->un_tagflags & FLAG_TAGMASK;
14219                 }
14220         }
14221 
14222         if (uscmd->uscsi_flags & USCSI_NODISCON) {
14223                 flags = (flags & ~FLAG_TAGMASK) | FLAG_NODISCON;
14224         }
14225 
14226         pktp->pkt_flags = flags;
14227 
14228         /* Transfer uscsi information to scsi_pkt */
14229         (void) scsi_uscsi_pktinit(uscmd, pktp);
14230 
14231         /* Copy the caller's CDB into the pkt... */
14232         bcopy(uscmd->uscsi_cdb, pktp->pkt_cdbp, uscmd->uscsi_cdblen);
14233 
14234         if (uscmd->uscsi_timeout == 0) {
14235                 pktp->pkt_time = un->un_uscsi_timeout;
14236         } else {
14237                 pktp->pkt_time = uscmd->uscsi_timeout;
14238         }
14239 
14240         /* need it later to identify USCSI request in sdintr */
14241         xp->xb_pkt_flags |= SD_XB_USCSICMD;
14242 
14243         xp->xb_sense_resid = uscmd->uscsi_rqresid;
14244 
14245         pktp->pkt_private = bp;
14246         pktp->pkt_comp = sdintr;
14247         *pktpp = pktp;
14248 
14249         SD_TRACE(SD_LOG_IO_CORE, un,
14250             "sd_initpkt_for_uscsi: exit: buf:0x%p\n", bp);
14251 
14252         return (SD_PKT_ALLOC_SUCCESS);
14253 }
14254 
14255 
14256 /*
14257  *    Function: sd_destroypkt_for_uscsi
14258  *
14259  * Description: Free the scsi_pkt(9S) struct for the given bp, for uscsi
14260  *              IOs.. Also saves relevant info into the associated uscsi_cmd
14261  *              struct.
14262  *
14263  *     Context: May be called under interrupt context
14264  */
14265 
14266 static void
14267 sd_destroypkt_for_uscsi(struct buf *bp)
14268 {
14269         struct uscsi_cmd *uscmd;
14270         struct sd_xbuf  *xp;
14271         struct scsi_pkt *pktp;
14272         struct sd_lun   *un;
14273         struct sd_uscsi_info *suip;
14274 
14275         ASSERT(bp != NULL);
14276         xp = SD_GET_XBUF(bp);
14277         ASSERT(xp != NULL);
14278         un = SD_GET_UN(bp);
14279         ASSERT(un != NULL);
14280         ASSERT(!mutex_owned(SD_MUTEX(un)));
14281         pktp = SD_GET_PKTP(bp);
14282         ASSERT(pktp != NULL);
14283 
14284         SD_TRACE(SD_LOG_IO_CORE, un,
14285             "sd_destroypkt_for_uscsi: entry: buf:0x%p\n", bp);
14286 
14287         /* The pointer to the uscsi_cmd struct is expected in xb_pktinfo */
14288         uscmd = (struct uscsi_cmd *)xp->xb_pktinfo;
14289         ASSERT(uscmd != NULL);
14290 
14291         /* Save the status and the residual into the uscsi_cmd struct */
14292         uscmd->uscsi_status = ((*(pktp)->pkt_scbp) & STATUS_MASK);
14293         uscmd->uscsi_resid  = bp->b_resid;
14294 
14295         /* Transfer scsi_pkt information to uscsi */
14296         (void) scsi_uscsi_pktfini(pktp, uscmd);
14297 
14298         /*
14299          * If enabled, copy any saved sense data into the area specified
14300          * by the uscsi command.
14301          */
14302         if (((uscmd->uscsi_flags & USCSI_RQENABLE) != 0) &&
14303             (uscmd->uscsi_rqlen != 0) && (uscmd->uscsi_rqbuf != NULL)) {
14304                 /*
14305                  * Note: uscmd->uscsi_rqbuf should always point to a buffer
14306                  * at least SENSE_LENGTH bytes in size (see sd_send_scsi_cmd())
14307                  */
14308                 uscmd->uscsi_rqstatus = xp->xb_sense_status;
14309                 uscmd->uscsi_rqresid  = xp->xb_sense_resid;
14310                 if (uscmd->uscsi_rqlen > SENSE_LENGTH) {
14311                         bcopy(xp->xb_sense_data, uscmd->uscsi_rqbuf,
14312                             MAX_SENSE_LENGTH);
14313                 } else {
14314                         bcopy(xp->xb_sense_data, uscmd->uscsi_rqbuf,
14315                             SENSE_LENGTH);
14316                 }
14317         }
14318         /*
14319          * The following assignments are for SCSI FMA.
14320          */
14321         ASSERT(xp->xb_private != NULL);
14322         suip = (struct sd_uscsi_info *)xp->xb_private;
14323         suip->ui_pkt_reason = pktp->pkt_reason;
14324         suip->ui_pkt_state = pktp->pkt_state;
14325         suip->ui_pkt_statistics = pktp->pkt_statistics;
14326         suip->ui_lba = (uint64_t)SD_GET_BLKNO(bp);
14327 
14328         /* We are done with the scsi_pkt; free it now */
14329         ASSERT(SD_GET_PKTP(bp) != NULL);
14330         scsi_destroy_pkt(SD_GET_PKTP(bp));
14331 
14332         SD_TRACE(SD_LOG_IO_CORE, un,
14333             "sd_destroypkt_for_uscsi: exit: buf:0x%p\n", bp);
14334 }
14335 
14336 
14337 /*
14338  *    Function: sd_bioclone_alloc
14339  *
14340  * Description: Allocate a buf(9S) and init it as per the given buf
14341  *              and the various arguments.  The associated sd_xbuf
14342  *              struct is (nearly) duplicated.  The struct buf *bp
14343  *              argument is saved in new_xp->xb_private.
14344  *
14345  *   Arguments: bp - ptr the the buf(9S) to be "shadowed"
14346  *              datalen - size of data area for the shadow bp
14347  *              blkno - starting LBA
14348  *              func - function pointer for b_iodone in the shadow buf. (May
14349  *                      be NULL if none.)
14350  *
14351  * Return Code: Pointer to allocates buf(9S) struct
14352  *
14353  *     Context: Can sleep.
14354  */
14355 
14356 static struct buf *
14357 sd_bioclone_alloc(struct buf *bp, size_t datalen,
14358         daddr_t blkno, int (*func)(struct buf *))
14359 {
14360         struct  sd_lun  *un;
14361         struct  sd_xbuf *xp;
14362         struct  sd_xbuf *new_xp;
14363         struct  buf     *new_bp;
14364 
14365         ASSERT(bp != NULL);
14366         xp = SD_GET_XBUF(bp);
14367         ASSERT(xp != NULL);
14368         un = SD_GET_UN(bp);
14369         ASSERT(un != NULL);
14370         ASSERT(!mutex_owned(SD_MUTEX(un)));
14371 
14372         new_bp = bioclone(bp, 0, datalen, SD_GET_DEV(un), blkno, func,
14373             NULL, KM_SLEEP);
14374 
14375         new_bp->b_lblkno     = blkno;
14376 
14377         /*
14378          * Allocate an xbuf for the shadow bp and copy the contents of the
14379          * original xbuf into it.
14380          */
14381         new_xp = kmem_alloc(sizeof (struct sd_xbuf), KM_SLEEP);
14382         bcopy(xp, new_xp, sizeof (struct sd_xbuf));
14383 
14384         /*
14385          * The given bp is automatically saved in the xb_private member
14386          * of the new xbuf.  Callers are allowed to depend on this.
14387          */
14388         new_xp->xb_private = bp;
14389 
14390         new_bp->b_private  = new_xp;
14391 
14392         return (new_bp);
14393 }
14394 
14395 /*
14396  *    Function: sd_shadow_buf_alloc
14397  *
14398  * Description: Allocate a buf(9S) and init it as per the given buf
14399  *              and the various arguments.  The associated sd_xbuf
14400  *              struct is (nearly) duplicated.  The struct buf *bp
14401  *              argument is saved in new_xp->xb_private.
14402  *
14403  *   Arguments: bp - ptr the the buf(9S) to be "shadowed"
14404  *              datalen - size of data area for the shadow bp
14405  *              bflags - B_READ or B_WRITE (pseudo flag)
14406  *              blkno - starting LBA
14407  *              func - function pointer for b_iodone in the shadow buf. (May
14408  *                      be NULL if none.)
14409  *
14410  * Return Code: Pointer to allocates buf(9S) struct
14411  *
14412  *     Context: Can sleep.
14413  */
14414 
14415 static struct buf *
14416 sd_shadow_buf_alloc(struct buf *bp, size_t datalen, uint_t bflags,
14417         daddr_t blkno, int (*func)(struct buf *))
14418 {
14419         struct  sd_lun  *un;
14420         struct  sd_xbuf *xp;
14421         struct  sd_xbuf *new_xp;
14422         struct  buf     *new_bp;
14423 
14424         ASSERT(bp != NULL);
14425         xp = SD_GET_XBUF(bp);
14426         ASSERT(xp != NULL);
14427         un = SD_GET_UN(bp);
14428         ASSERT(un != NULL);
14429         ASSERT(!mutex_owned(SD_MUTEX(un)));
14430 
14431         if (bp->b_flags & (B_PAGEIO | B_PHYS)) {
14432                 bp_mapin(bp);
14433         }
14434 
14435         bflags &= (B_READ | B_WRITE);
14436 #if defined(__i386) || defined(__amd64)
14437         new_bp = getrbuf(KM_SLEEP);
14438         new_bp->b_un.b_addr = kmem_zalloc(datalen, KM_SLEEP);
14439         new_bp->b_bcount = datalen;
14440         new_bp->b_flags = bflags |
14441             (bp->b_flags & ~(B_PAGEIO | B_PHYS | B_REMAPPED | B_SHADOW));
14442 #else
14443         new_bp = scsi_alloc_consistent_buf(SD_ADDRESS(un), NULL,
14444             datalen, bflags, SLEEP_FUNC, NULL);
14445 #endif
14446         new_bp->av_forw      = NULL;
14447         new_bp->av_back      = NULL;
14448         new_bp->b_dev        = bp->b_dev;
14449         new_bp->b_blkno      = blkno;
14450         new_bp->b_iodone = func;
14451         new_bp->b_edev       = bp->b_edev;
14452         new_bp->b_resid      = 0;
14453 
14454         /* We need to preserve the B_FAILFAST flag */
14455         if (bp->b_flags & B_FAILFAST) {
14456                 new_bp->b_flags |= B_FAILFAST;
14457         }
14458 
14459         /*
14460          * Allocate an xbuf for the shadow bp and copy the contents of the
14461          * original xbuf into it.
14462          */
14463         new_xp = kmem_alloc(sizeof (struct sd_xbuf), KM_SLEEP);
14464         bcopy(xp, new_xp, sizeof (struct sd_xbuf));
14465 
14466         /* Need later to copy data between the shadow buf & original buf! */
14467         new_xp->xb_pkt_flags |= PKT_CONSISTENT;
14468 
14469         /*
14470          * The given bp is automatically saved in the xb_private member
14471          * of the new xbuf.  Callers are allowed to depend on this.
14472          */
14473         new_xp->xb_private = bp;
14474 
14475         new_bp->b_private  = new_xp;
14476 
14477         return (new_bp);
14478 }
14479 
14480 /*
14481  *    Function: sd_bioclone_free
14482  *
14483  * Description: Deallocate a buf(9S) that was used for 'shadow' IO operations
14484  *              in the larger than partition operation.
14485  *
14486  *     Context: May be called under interrupt context
14487  */
14488 
14489 static void
14490 sd_bioclone_free(struct buf *bp)
14491 {
14492         struct sd_xbuf  *xp;
14493 
14494         ASSERT(bp != NULL);
14495         xp = SD_GET_XBUF(bp);
14496         ASSERT(xp != NULL);
14497 
14498         /*
14499          * Call bp_mapout() before freeing the buf,  in case a lower
14500          * layer or HBA  had done a bp_mapin().  we must do this here
14501          * as we are the "originator" of the shadow buf.
14502          */
14503         bp_mapout(bp);
14504 
14505         /*
14506          * Null out b_iodone before freeing the bp, to ensure that the driver
14507          * never gets confused by a stale value in this field. (Just a little
14508          * extra defensiveness here.)
14509          */
14510         bp->b_iodone = NULL;
14511 
14512         freerbuf(bp);
14513 
14514         kmem_free(xp, sizeof (struct sd_xbuf));
14515 }
14516 
14517 /*
14518  *    Function: sd_shadow_buf_free
14519  *
14520  * Description: Deallocate a buf(9S) that was used for 'shadow' IO operations.
14521  *
14522  *     Context: May be called under interrupt context
14523  */
14524 
14525 static void
14526 sd_shadow_buf_free(struct buf *bp)
14527 {
14528         struct sd_xbuf  *xp;
14529 
14530         ASSERT(bp != NULL);
14531         xp = SD_GET_XBUF(bp);
14532         ASSERT(xp != NULL);
14533 
14534 #if defined(__sparc)
14535         /*
14536          * Call bp_mapout() before freeing the buf,  in case a lower
14537          * layer or HBA  had done a bp_mapin().  we must do this here
14538          * as we are the "originator" of the shadow buf.
14539          */
14540         bp_mapout(bp);
14541 #endif
14542 
14543         /*
14544          * Null out b_iodone before freeing the bp, to ensure that the driver
14545          * never gets confused by a stale value in this field. (Just a little
14546          * extra defensiveness here.)
14547          */
14548         bp->b_iodone = NULL;
14549 
14550 #if defined(__i386) || defined(__amd64)
14551         kmem_free(bp->b_un.b_addr, bp->b_bcount);
14552         freerbuf(bp);
14553 #else
14554         scsi_free_consistent_buf(bp);
14555 #endif
14556 
14557         kmem_free(xp, sizeof (struct sd_xbuf));
14558 }
14559 
14560 
14561 /*
14562  *    Function: sd_print_transport_rejected_message
14563  *
14564  * Description: This implements the ludicrously complex rules for printing
14565  *              a "transport rejected" message.  This is to address the
14566  *              specific problem of having a flood of this error message
14567  *              produced when a failover occurs.
14568  *
14569  *     Context: Any.
14570  */
14571 
14572 static void
14573 sd_print_transport_rejected_message(struct sd_lun *un, struct sd_xbuf *xp,
14574         int code)
14575 {
14576         ASSERT(un != NULL);
14577         ASSERT(mutex_owned(SD_MUTEX(un)));
14578         ASSERT(xp != NULL);
14579 
14580         /*
14581          * Print the "transport rejected" message under the following
14582          * conditions:
14583          *
14584          * - Whenever the SD_LOGMASK_DIAG bit of sd_level_mask is set
14585          * - The error code from scsi_transport() is NOT a TRAN_FATAL_ERROR.
14586          * - If the error code IS a TRAN_FATAL_ERROR, then the message is
14587          *   printed the FIRST time a TRAN_FATAL_ERROR is returned from
14588          *   scsi_transport(9F) (which indicates that the target might have
14589          *   gone off-line).  This uses the un->un_tran_fatal_count
14590          *   count, which is incremented whenever a TRAN_FATAL_ERROR is
14591          *   received, and reset to zero whenver a TRAN_ACCEPT is returned
14592          *   from scsi_transport().
14593          *
14594          * The FLAG_SILENT in the scsi_pkt must be CLEARED in ALL of
14595          * the preceeding cases in order for the message to be printed.
14596          */
14597         if (((xp->xb_pktp->pkt_flags & FLAG_SILENT) == 0) &&
14598             (SD_FM_LOG(un) == SD_FM_LOG_NSUP)) {
14599                 if ((sd_level_mask & SD_LOGMASK_DIAG) ||
14600                     (code != TRAN_FATAL_ERROR) ||
14601                     (un->un_tran_fatal_count == 1)) {
14602                         switch (code) {
14603                         case TRAN_BADPKT:
14604                                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
14605                                     "transport rejected bad packet\n");
14606                                 break;
14607                         case TRAN_FATAL_ERROR:
14608                                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
14609                                     "transport rejected fatal error\n");
14610                                 break;
14611                         default:
14612                                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
14613                                     "transport rejected (%d)\n", code);
14614                                 break;
14615                         }
14616                 }
14617         }
14618 }
14619 
14620 
14621 /*
14622  *    Function: sd_add_buf_to_waitq
14623  *
14624  * Description: Add the given buf(9S) struct to the wait queue for the
14625  *              instance.  If sorting is enabled, then the buf is added
14626  *              to the queue via an elevator sort algorithm (a la
14627  *              disksort(9F)).  The SD_GET_BLKNO(bp) is used as the sort key.
14628  *              If sorting is not enabled, then the buf is just added
14629  *              to the end of the wait queue.
14630  *
14631  * Return Code: void
14632  *
14633  *     Context: Does not sleep/block, therefore technically can be called
14634  *              from any context.  However if sorting is enabled then the
14635  *              execution time is indeterminate, and may take long if
14636  *              the wait queue grows large.
14637  */
14638 
14639 static void
14640 sd_add_buf_to_waitq(struct sd_lun *un, struct buf *bp)
14641 {
14642         struct buf *ap;
14643 
14644         ASSERT(bp != NULL);
14645         ASSERT(un != NULL);
14646         ASSERT(mutex_owned(SD_MUTEX(un)));
14647 
14648         /* If the queue is empty, add the buf as the only entry & return. */
14649         if (un->un_waitq_headp == NULL) {
14650                 ASSERT(un->un_waitq_tailp == NULL);
14651                 un->un_waitq_headp = un->un_waitq_tailp = bp;
14652                 bp->av_forw = NULL;
14653                 return;
14654         }
14655 
14656         ASSERT(un->un_waitq_tailp != NULL);
14657 
14658         /*
14659          * If sorting is disabled, just add the buf to the tail end of
14660          * the wait queue and return.
14661          */
14662         if (un->un_f_disksort_disabled || un->un_f_enable_rmw) {
14663                 un->un_waitq_tailp->av_forw = bp;
14664                 un->un_waitq_tailp = bp;
14665                 bp->av_forw = NULL;
14666                 return;
14667         }
14668 
14669         /*
14670          * Sort thru the list of requests currently on the wait queue
14671          * and add the new buf request at the appropriate position.
14672          *
14673          * The un->un_waitq_headp is an activity chain pointer on which
14674          * we keep two queues, sorted in ascending SD_GET_BLKNO() order. The
14675          * first queue holds those requests which are positioned after
14676          * the current SD_GET_BLKNO() (in the first request); the second holds
14677          * requests which came in after their SD_GET_BLKNO() number was passed.
14678          * Thus we implement a one way scan, retracting after reaching
14679          * the end of the drive to the first request on the second
14680          * queue, at which time it becomes the first queue.
14681          * A one-way scan is natural because of the way UNIX read-ahead
14682          * blocks are allocated.
14683          *
14684          * If we lie after the first request, then we must locate the
14685          * second request list and add ourselves to it.
14686          */
14687         ap = un->un_waitq_headp;
14688         if (SD_GET_BLKNO(bp) < SD_GET_BLKNO(ap)) {
14689                 while (ap->av_forw != NULL) {
14690                         /*
14691                          * Look for an "inversion" in the (normally
14692                          * ascending) block numbers. This indicates
14693                          * the start of the second request list.
14694                          */
14695                         if (SD_GET_BLKNO(ap->av_forw) < SD_GET_BLKNO(ap)) {
14696                                 /*
14697                                  * Search the second request list for the
14698                                  * first request at a larger block number.
14699                                  * We go before that; however if there is
14700                                  * no such request, we go at the end.
14701                                  */
14702                                 do {
14703                                         if (SD_GET_BLKNO(bp) <
14704                                             SD_GET_BLKNO(ap->av_forw)) {
14705                                                 goto insert;
14706                                         }
14707                                         ap = ap->av_forw;
14708                                 } while (ap->av_forw != NULL);
14709                                 goto insert;            /* after last */
14710                         }
14711                         ap = ap->av_forw;
14712                 }
14713 
14714                 /*
14715                  * No inversions... we will go after the last, and
14716                  * be the first request in the second request list.
14717                  */
14718                 goto insert;
14719         }
14720 
14721         /*
14722          * Request is at/after the current request...
14723          * sort in the first request list.
14724          */
14725         while (ap->av_forw != NULL) {
14726                 /*
14727                  * We want to go after the current request (1) if
14728                  * there is an inversion after it (i.e. it is the end
14729                  * of the first request list), or (2) if the next
14730                  * request is a larger block no. than our request.
14731                  */
14732                 if ((SD_GET_BLKNO(ap->av_forw) < SD_GET_BLKNO(ap)) ||
14733                     (SD_GET_BLKNO(bp) < SD_GET_BLKNO(ap->av_forw))) {
14734                         goto insert;
14735                 }
14736                 ap = ap->av_forw;
14737         }
14738 
14739         /*
14740          * Neither a second list nor a larger request, therefore
14741          * we go at the end of the first list (which is the same
14742          * as the end of the whole schebang).
14743          */
14744 insert:
14745         bp->av_forw = ap->av_forw;
14746         ap->av_forw = bp;
14747 
14748         /*
14749          * If we inserted onto the tail end of the waitq, make sure the
14750          * tail pointer is updated.
14751          */
14752         if (ap == un->un_waitq_tailp) {
14753                 un->un_waitq_tailp = bp;
14754         }
14755 }
14756 
14757 
14758 /*
14759  *    Function: sd_start_cmds
14760  *
14761  * Description: Remove and transport cmds from the driver queues.
14762  *
14763  *   Arguments: un - pointer to the unit (soft state) struct for the target.
14764  *
14765  *              immed_bp - ptr to a buf to be transported immediately. Only
14766  *              the immed_bp is transported; bufs on the waitq are not
14767  *              processed and the un_retry_bp is not checked.  If immed_bp is
14768  *              NULL, then normal queue processing is performed.
14769  *
14770  *     Context: May be called from kernel thread context, interrupt context,
14771  *              or runout callback context. This function may not block or
14772  *              call routines that block.
14773  */
14774 
14775 static void
14776 sd_start_cmds(struct sd_lun *un, struct buf *immed_bp)
14777 {
14778         struct  sd_xbuf *xp;
14779         struct  buf     *bp;
14780         void    (*statp)(kstat_io_t *);
14781 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
14782         void    (*saved_statp)(kstat_io_t *);
14783 #endif
14784         int     rval;
14785         struct sd_fm_internal *sfip = NULL;
14786 
14787         ASSERT(un != NULL);
14788         ASSERT(mutex_owned(SD_MUTEX(un)));
14789         ASSERT(un->un_ncmds_in_transport >= 0);
14790         ASSERT(un->un_throttle >= 0);
14791 
14792         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_start_cmds: entry\n");
14793 
14794         do {
14795 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
14796                 saved_statp = NULL;
14797 #endif
14798 
14799                 /*
14800                  * If we are syncing or dumping, fail the command to
14801                  * avoid recursively calling back into scsi_transport().
14802                  * The dump I/O itself uses a separate code path so this
14803                  * only prevents non-dump I/O from being sent while dumping.
14804                  * File system sync takes place before dumping begins.
14805                  * During panic, filesystem I/O is allowed provided
14806                  * un_in_callback is <= 1.  This is to prevent recursion
14807                  * such as sd_start_cmds -> scsi_transport -> sdintr ->
14808                  * sd_start_cmds and so on.  See panic.c for more information
14809                  * about the states the system can be in during panic.
14810                  */
14811                 if ((un->un_state == SD_STATE_DUMPING) ||
14812                     (ddi_in_panic() && (un->un_in_callback > 1))) {
14813                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14814                             "sd_start_cmds: panicking\n");
14815                         goto exit;
14816                 }
14817 
14818                 if ((bp = immed_bp) != NULL) {
14819                         /*
14820                          * We have a bp that must be transported immediately.
14821                          * It's OK to transport the immed_bp here without doing
14822                          * the throttle limit check because the immed_bp is
14823                          * always used in a retry/recovery case. This means
14824                          * that we know we are not at the throttle limit by
14825                          * virtue of the fact that to get here we must have
14826                          * already gotten a command back via sdintr(). This also
14827                          * relies on (1) the command on un_retry_bp preventing
14828                          * further commands from the waitq from being issued;
14829                          * and (2) the code in sd_retry_command checking the
14830                          * throttle limit before issuing a delayed or immediate
14831                          * retry. This holds even if the throttle limit is
14832                          * currently ratcheted down from its maximum value.
14833                          */
14834                         statp = kstat_runq_enter;
14835                         if (bp == un->un_retry_bp) {
14836                                 ASSERT((un->un_retry_statp == NULL) ||
14837                                     (un->un_retry_statp == kstat_waitq_enter) ||
14838                                     (un->un_retry_statp ==
14839                                     kstat_runq_back_to_waitq));
14840                                 /*
14841                                  * If the waitq kstat was incremented when
14842                                  * sd_set_retry_bp() queued this bp for a retry,
14843                                  * then we must set up statp so that the waitq
14844                                  * count will get decremented correctly below.
14845                                  * Also we must clear un->un_retry_statp to
14846                                  * ensure that we do not act on a stale value
14847                                  * in this field.
14848                                  */
14849                                 if ((un->un_retry_statp == kstat_waitq_enter) ||
14850                                     (un->un_retry_statp ==
14851                                     kstat_runq_back_to_waitq)) {
14852                                         statp = kstat_waitq_to_runq;
14853                                 }
14854 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
14855                                 saved_statp = un->un_retry_statp;
14856 #endif
14857                                 un->un_retry_statp = NULL;
14858 
14859                                 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
14860                                     "sd_start_cmds: un:0x%p: GOT retry_bp:0x%p "
14861                                     "un_throttle:%d un_ncmds_in_transport:%d\n",
14862                                     un, un->un_retry_bp, un->un_throttle,
14863                                     un->un_ncmds_in_transport);
14864                         } else {
14865                                 SD_TRACE(SD_LOG_IO_CORE, un, "sd_start_cmds: "
14866                                     "processing priority bp:0x%p\n", bp);
14867                         }
14868 
14869                 } else if ((bp = un->un_waitq_headp) != NULL) {
14870                         /*
14871                          * A command on the waitq is ready to go, but do not
14872                          * send it if:
14873                          *
14874                          * (1) the throttle limit has been reached, or
14875                          * (2) a retry is pending, or
14876                          * (3) a START_STOP_UNIT callback pending, or
14877                          * (4) a callback for a SD_PATH_DIRECT_PRIORITY
14878                          *      command is pending.
14879                          *
14880                          * For all of these conditions, IO processing will
14881                          * restart after the condition is cleared.
14882                          */
14883                         if (un->un_ncmds_in_transport >= un->un_throttle) {
14884                                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14885                                     "sd_start_cmds: exiting, "
14886                                     "throttle limit reached!\n");
14887                                 goto exit;
14888                         }
14889                         if (un->un_retry_bp != NULL) {
14890                                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14891                                     "sd_start_cmds: exiting, retry pending!\n");
14892                                 goto exit;
14893                         }
14894                         if (un->un_startstop_timeid != NULL) {
14895                                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14896                                     "sd_start_cmds: exiting, "
14897                                     "START_STOP pending!\n");
14898                                 goto exit;
14899                         }
14900                         if (un->un_direct_priority_timeid != NULL) {
14901                                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
14902                                     "sd_start_cmds: exiting, "
14903                                     "SD_PATH_DIRECT_PRIORITY cmd. pending!\n");
14904                                 goto exit;
14905                         }
14906 
14907                         /* Dequeue the command */
14908                         un->un_waitq_headp = bp->av_forw;
14909                         if (un->un_waitq_headp == NULL) {
14910                                 un->un_waitq_tailp = NULL;
14911                         }
14912                         bp->av_forw = NULL;
14913                         statp = kstat_waitq_to_runq;
14914                         SD_TRACE(SD_LOG_IO_CORE, un,
14915                             "sd_start_cmds: processing waitq bp:0x%p\n", bp);
14916 
14917                 } else {
14918                         /* No work to do so bail out now */
14919                         SD_TRACE(SD_LOG_IO_CORE, un,
14920                             "sd_start_cmds: no more work, exiting!\n");
14921                         goto exit;
14922                 }
14923 
14924                 /*
14925                  * Reset the state to normal. This is the mechanism by which
14926                  * the state transitions from either SD_STATE_RWAIT or
14927                  * SD_STATE_OFFLINE to SD_STATE_NORMAL.
14928                  * If state is SD_STATE_PM_CHANGING then this command is
14929                  * part of the device power control and the state must
14930                  * not be put back to normal. Doing so would would
14931                  * allow new commands to proceed when they shouldn't,
14932                  * the device may be going off.
14933                  */
14934                 if ((un->un_state != SD_STATE_SUSPENDED) &&
14935                     (un->un_state != SD_STATE_PM_CHANGING)) {
14936                         New_state(un, SD_STATE_NORMAL);
14937                 }
14938 
14939                 xp = SD_GET_XBUF(bp);
14940                 ASSERT(xp != NULL);
14941 
14942 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
14943                 /*
14944                  * Allocate the scsi_pkt if we need one, or attach DMA
14945                  * resources if we have a scsi_pkt that needs them. The
14946                  * latter should only occur for commands that are being
14947                  * retried.
14948                  */
14949                 if ((xp->xb_pktp == NULL) ||
14950                     ((xp->xb_pkt_flags & SD_XB_DMA_FREED) != 0)) {
14951 #else
14952                 if (xp->xb_pktp == NULL) {
14953 #endif
14954                         /*
14955                          * There is no scsi_pkt allocated for this buf. Call
14956                          * the initpkt function to allocate & init one.
14957                          *
14958                          * The scsi_init_pkt runout callback functionality is
14959                          * implemented as follows:
14960                          *
14961                          * 1) The initpkt function always calls
14962                          *    scsi_init_pkt(9F) with sdrunout specified as the
14963                          *    callback routine.
14964                          * 2) A successful packet allocation is initialized and
14965                          *    the I/O is transported.
14966                          * 3) The I/O associated with an allocation resource
14967                          *    failure is left on its queue to be retried via
14968                          *    runout or the next I/O.
14969                          * 4) The I/O associated with a DMA error is removed
14970                          *    from the queue and failed with EIO. Processing of
14971                          *    the transport queues is also halted to be
14972                          *    restarted via runout or the next I/O.
14973                          * 5) The I/O associated with a CDB size or packet
14974                          *    size error is removed from the queue and failed
14975                          *    with EIO. Processing of the transport queues is
14976                          *    continued.
14977                          *
14978                          * Note: there is no interface for canceling a runout
14979                          * callback. To prevent the driver from detaching or
14980                          * suspending while a runout is pending the driver
14981                          * state is set to SD_STATE_RWAIT
14982                          *
14983                          * Note: using the scsi_init_pkt callback facility can
14984                          * result in an I/O request persisting at the head of
14985                          * the list which cannot be satisfied even after
14986                          * multiple retries. In the future the driver may
14987                          * implement some kind of maximum runout count before
14988                          * failing an I/O.
14989                          *
14990                          * Note: the use of funcp below may seem superfluous,
14991                          * but it helps warlock figure out the correct
14992                          * initpkt function calls (see [s]sd.wlcmd).
14993                          */
14994                         struct scsi_pkt *pktp;
14995                         int (*funcp)(struct buf *bp, struct scsi_pkt **pktp);
14996 
14997                         ASSERT(bp != un->un_rqs_bp);
14998 
14999                         funcp = sd_initpkt_map[xp->xb_chain_iostart];
15000                         switch ((*funcp)(bp, &pktp)) {
15001                         case  SD_PKT_ALLOC_SUCCESS:
15002                                 xp->xb_pktp = pktp;
15003                                 SD_TRACE(SD_LOG_IO_CORE, un,
15004                                     "sd_start_cmd: SD_PKT_ALLOC_SUCCESS 0x%p\n",
15005                                     pktp);
15006                                 goto got_pkt;
15007 
15008                         case SD_PKT_ALLOC_FAILURE:
15009                                 /*
15010                                  * Temporary (hopefully) resource depletion.
15011                                  * Since retries and RQS commands always have a
15012                                  * scsi_pkt allocated, these cases should never
15013                                  * get here. So the only cases this needs to
15014                                  * handle is a bp from the waitq (which we put
15015                                  * back onto the waitq for sdrunout), or a bp
15016                                  * sent as an immed_bp (which we just fail).
15017                                  */
15018                                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15019                                     "sd_start_cmds: SD_PKT_ALLOC_FAILURE\n");
15020 
15021 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
15022 
15023                                 if (bp == immed_bp) {
15024                                         /*
15025                                          * If SD_XB_DMA_FREED is clear, then
15026                                          * this is a failure to allocate a
15027                                          * scsi_pkt, and we must fail the
15028                                          * command.
15029                                          */
15030                                         if ((xp->xb_pkt_flags &
15031                                             SD_XB_DMA_FREED) == 0) {
15032                                                 break;
15033                                         }
15034 
15035                                         /*
15036                                          * If this immediate command is NOT our
15037                                          * un_retry_bp, then we must fail it.
15038                                          */
15039                                         if (bp != un->un_retry_bp) {
15040                                                 break;
15041                                         }
15042 
15043                                         /*
15044                                          * We get here if this cmd is our
15045                                          * un_retry_bp that was DMAFREED, but
15046                                          * scsi_init_pkt() failed to reallocate
15047                                          * DMA resources when we attempted to
15048                                          * retry it. This can happen when an
15049                                          * mpxio failover is in progress, but
15050                                          * we don't want to just fail the
15051                                          * command in this case.
15052                                          *
15053                                          * Use timeout(9F) to restart it after
15054                                          * a 100ms delay.  We don't want to
15055                                          * let sdrunout() restart it, because
15056                                          * sdrunout() is just supposed to start
15057                                          * commands that are sitting on the
15058                                          * wait queue.  The un_retry_bp stays
15059                                          * set until the command completes, but
15060                                          * sdrunout can be called many times
15061                                          * before that happens.  Since sdrunout
15062                                          * cannot tell if the un_retry_bp is
15063                                          * already in the transport, it could
15064                                          * end up calling scsi_transport() for
15065                                          * the un_retry_bp multiple times.
15066                                          *
15067                                          * Also: don't schedule the callback
15068                                          * if some other callback is already
15069                                          * pending.
15070                                          */
15071                                         if (un->un_retry_statp == NULL) {
15072                                                 /*
15073                                                  * restore the kstat pointer to
15074                                                  * keep kstat counts coherent
15075                                                  * when we do retry the command.
15076                                                  */
15077                                                 un->un_retry_statp =
15078                                                     saved_statp;
15079                                         }
15080 
15081                                         if ((un->un_startstop_timeid == NULL) &&
15082                                             (un->un_retry_timeid == NULL) &&
15083                                             (un->un_direct_priority_timeid ==
15084                                             NULL)) {
15085 
15086                                                 un->un_retry_timeid =
15087                                                     timeout(
15088                                                     sd_start_retry_command,
15089                                                     un, SD_RESTART_TIMEOUT);
15090                                         }
15091                                         goto exit;
15092                                 }
15093 
15094 #else
15095                                 if (bp == immed_bp) {
15096                                         break;  /* Just fail the command */
15097                                 }
15098 #endif
15099 
15100                                 /* Add the buf back to the head of the waitq */
15101                                 bp->av_forw = un->un_waitq_headp;
15102                                 un->un_waitq_headp = bp;
15103                                 if (un->un_waitq_tailp == NULL) {
15104                                         un->un_waitq_tailp = bp;
15105                                 }
15106                                 goto exit;
15107 
15108                         case SD_PKT_ALLOC_FAILURE_NO_DMA:
15109                                 /*
15110                                  * HBA DMA resource failure. Fail the command
15111                                  * and continue processing of the queues.
15112                                  */
15113                                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15114                                     "sd_start_cmds: "
15115                                     "SD_PKT_ALLOC_FAILURE_NO_DMA\n");
15116                                 break;
15117 
15118                         case SD_PKT_ALLOC_FAILURE_PKT_TOO_SMALL:
15119                                 /*
15120                                  * Note:x86: Partial DMA mapping not supported
15121                                  * for USCSI commands, and all the needed DMA
15122                                  * resources were not allocated.
15123                                  */
15124                                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15125                                     "sd_start_cmds: "
15126                                     "SD_PKT_ALLOC_FAILURE_PKT_TOO_SMALL\n");
15127                                 break;
15128 
15129                         case SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL:
15130                                 /*
15131                                  * Note:x86: Request cannot fit into CDB based
15132                                  * on lba and len.
15133                                  */
15134                                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15135                                     "sd_start_cmds: "
15136                                     "SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL\n");
15137                                 break;
15138 
15139                         default:
15140                                 /* Should NEVER get here! */
15141                                 panic("scsi_initpkt error");
15142                                 /*NOTREACHED*/
15143                         }
15144 
15145                         /*
15146                          * Fatal error in allocating a scsi_pkt for this buf.
15147                          * Update kstats & return the buf with an error code.
15148                          * We must use sd_return_failed_command_no_restart() to
15149                          * avoid a recursive call back into sd_start_cmds().
15150                          * However this also means that we must keep processing
15151                          * the waitq here in order to avoid stalling.
15152                          */
15153                         if (statp == kstat_waitq_to_runq) {
15154                                 SD_UPDATE_KSTATS(un, kstat_waitq_exit, bp);
15155                         }
15156                         sd_return_failed_command_no_restart(un, bp, EIO);
15157                         if (bp == immed_bp) {
15158                                 /* immed_bp is gone by now, so clear this */
15159                                 immed_bp = NULL;
15160                         }
15161                         continue;
15162                 }
15163 got_pkt:
15164                 if (bp == immed_bp) {
15165                         /* goto the head of the class.... */
15166                         xp->xb_pktp->pkt_flags |= FLAG_HEAD;
15167                 }
15168 
15169                 un->un_ncmds_in_transport++;
15170                 SD_UPDATE_KSTATS(un, statp, bp);
15171 
15172                 /*
15173                  * Call scsi_transport() to send the command to the target.
15174                  * According to SCSA architecture, we must drop the mutex here
15175                  * before calling scsi_transport() in order to avoid deadlock.
15176                  * Note that the scsi_pkt's completion routine can be executed
15177                  * (from interrupt context) even before the call to
15178                  * scsi_transport() returns.
15179                  */
15180                 SD_TRACE(SD_LOG_IO_CORE, un,
15181                     "sd_start_cmds: calling scsi_transport()\n");
15182                 DTRACE_PROBE1(scsi__transport__dispatch, struct buf *, bp);
15183 
15184                 mutex_exit(SD_MUTEX(un));
15185                 rval = scsi_transport(xp->xb_pktp);
15186                 mutex_enter(SD_MUTEX(un));
15187 
15188                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15189                     "sd_start_cmds: scsi_transport() returned %d\n", rval);
15190 
15191                 switch (rval) {
15192                 case TRAN_ACCEPT:
15193                         /* Clear this with every pkt accepted by the HBA */
15194                         un->un_tran_fatal_count = 0;
15195                         break;  /* Success; try the next cmd (if any) */
15196 
15197                 case TRAN_BUSY:
15198                         un->un_ncmds_in_transport--;
15199                         ASSERT(un->un_ncmds_in_transport >= 0);
15200 
15201                         /*
15202                          * Don't retry request sense, the sense data
15203                          * is lost when another request is sent.
15204                          * Free up the rqs buf and retry
15205                          * the original failed cmd.  Update kstat.
15206                          */
15207                         if (bp == un->un_rqs_bp) {
15208                                 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp);
15209                                 bp = sd_mark_rqs_idle(un, xp);
15210                                 sd_retry_command(un, bp, SD_RETRIES_STANDARD,
15211                                     NULL, NULL, EIO, un->un_busy_timeout / 500,
15212                                     kstat_waitq_enter);
15213                                 goto exit;
15214                         }
15215 
15216 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */
15217                         /*
15218                          * Free the DMA resources for the  scsi_pkt. This will
15219                          * allow mpxio to select another path the next time
15220                          * we call scsi_transport() with this scsi_pkt.
15221                          * See sdintr() for the rationalization behind this.
15222                          */
15223                         if ((un->un_f_is_fibre == TRUE) &&
15224                             ((xp->xb_pkt_flags & SD_XB_USCSICMD) == 0) &&
15225                             ((xp->xb_pktp->pkt_flags & FLAG_SENSING) == 0)) {
15226                                 scsi_dmafree(xp->xb_pktp);
15227                                 xp->xb_pkt_flags |= SD_XB_DMA_FREED;
15228                         }
15229 #endif
15230 
15231                         if (SD_IS_DIRECT_PRIORITY(SD_GET_XBUF(bp))) {
15232                                 /*
15233                                  * Commands that are SD_PATH_DIRECT_PRIORITY
15234                                  * are for error recovery situations. These do
15235                                  * not use the normal command waitq, so if they
15236                                  * get a TRAN_BUSY we cannot put them back onto
15237                                  * the waitq for later retry. One possible
15238                                  * problem is that there could already be some
15239                                  * other command on un_retry_bp that is waiting
15240                                  * for this one to complete, so we would be
15241                                  * deadlocked if we put this command back onto
15242                                  * the waitq for later retry (since un_retry_bp
15243                                  * must complete before the driver gets back to
15244                                  * commands on the waitq).
15245                                  *
15246                                  * To avoid deadlock we must schedule a callback
15247                                  * that will restart this command after a set
15248                                  * interval.  This should keep retrying for as
15249                                  * long as the underlying transport keeps
15250                                  * returning TRAN_BUSY (just like for other
15251                                  * commands).  Use the same timeout interval as
15252                                  * for the ordinary TRAN_BUSY retry.
15253                                  */
15254                                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15255                                     "sd_start_cmds: scsi_transport() returned "
15256                                     "TRAN_BUSY for DIRECT_PRIORITY cmd!\n");
15257 
15258                                 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp);
15259                                 un->un_direct_priority_timeid =
15260                                     timeout(sd_start_direct_priority_command,
15261                                     bp, un->un_busy_timeout / 500);
15262 
15263                                 goto exit;
15264                         }
15265 
15266                         /*
15267                          * For TRAN_BUSY, we want to reduce the throttle value,
15268                          * unless we are retrying a command.
15269                          */
15270                         if (bp != un->un_retry_bp) {
15271                                 sd_reduce_throttle(un, SD_THROTTLE_TRAN_BUSY);
15272                         }
15273 
15274                         /*
15275                          * Set up the bp to be tried again 10 ms later.
15276                          * Note:x86: Is there a timeout value in the sd_lun
15277                          * for this condition?
15278                          */
15279                         sd_set_retry_bp(un, bp, un->un_busy_timeout / 500,
15280                             kstat_runq_back_to_waitq);
15281                         goto exit;
15282 
15283                 case TRAN_FATAL_ERROR:
15284                         un->un_tran_fatal_count++;
15285                         /* FALLTHRU */
15286 
15287                 case TRAN_BADPKT:
15288                 default:
15289                         un->un_ncmds_in_transport--;
15290                         ASSERT(un->un_ncmds_in_transport >= 0);
15291 
15292                         /*
15293                          * If this is our REQUEST SENSE command with a
15294                          * transport error, we must get back the pointers
15295                          * to the original buf, and mark the REQUEST
15296                          * SENSE command as "available".
15297                          */
15298                         if (bp == un->un_rqs_bp) {
15299                                 bp = sd_mark_rqs_idle(un, xp);
15300                                 xp = SD_GET_XBUF(bp);
15301                         } else {
15302                                 /*
15303                                  * Legacy behavior: do not update transport
15304                                  * error count for request sense commands.
15305                                  */
15306                                 SD_UPDATE_ERRSTATS(un, sd_transerrs);
15307                         }
15308 
15309                         SD_UPDATE_KSTATS(un, kstat_runq_exit, bp);
15310                         sd_print_transport_rejected_message(un, xp, rval);
15311 
15312                         /*
15313                          * This command will be terminated by SD driver due
15314                          * to a fatal transport error. We should post
15315                          * ereport.io.scsi.cmd.disk.tran with driver-assessment
15316                          * of "fail" for any command to indicate this
15317                          * situation.
15318                          */
15319                         if (xp->xb_ena > 0) {
15320                                 ASSERT(un->un_fm_private != NULL);
15321                                 sfip = un->un_fm_private;
15322                                 sfip->fm_ssc.ssc_flags |= SSC_FLAGS_TRAN_ABORT;
15323                                 sd_ssc_extract_info(&sfip->fm_ssc, un,
15324                                     xp->xb_pktp, bp, xp);
15325                                 sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_FATAL);
15326                         }
15327 
15328                         /*
15329                          * We must use sd_return_failed_command_no_restart() to
15330                          * avoid a recursive call back into sd_start_cmds().
15331                          * However this also means that we must keep processing
15332                          * the waitq here in order to avoid stalling.
15333                          */
15334                         sd_return_failed_command_no_restart(un, bp, EIO);
15335 
15336                         /*
15337                          * Notify any threads waiting in sd_ddi_suspend() that
15338                          * a command completion has occurred.
15339                          */
15340                         if (un->un_state == SD_STATE_SUSPENDED) {
15341                                 cv_broadcast(&un->un_disk_busy_cv);
15342                         }
15343 
15344                         if (bp == immed_bp) {
15345                                 /* immed_bp is gone by now, so clear this */
15346                                 immed_bp = NULL;
15347                         }
15348                         break;
15349                 }
15350 
15351         } while (immed_bp == NULL);
15352 
15353 exit:
15354         ASSERT(mutex_owned(SD_MUTEX(un)));
15355         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_start_cmds: exit\n");
15356 }
15357 
15358 
15359 /*
15360  *    Function: sd_return_command
15361  *
15362  * Description: Returns a command to its originator (with or without an
15363  *              error).  Also starts commands waiting to be transported
15364  *              to the target.
15365  *
15366  *     Context: May be called from interrupt, kernel, or timeout context
15367  */
15368 
15369 static void
15370 sd_return_command(struct sd_lun *un, struct buf *bp)
15371 {
15372         struct sd_xbuf *xp;
15373         struct scsi_pkt *pktp;
15374         struct sd_fm_internal *sfip;
15375 
15376         ASSERT(bp != NULL);
15377         ASSERT(un != NULL);
15378         ASSERT(mutex_owned(SD_MUTEX(un)));
15379         ASSERT(bp != un->un_rqs_bp);
15380         xp = SD_GET_XBUF(bp);
15381         ASSERT(xp != NULL);
15382 
15383         pktp = SD_GET_PKTP(bp);
15384         sfip = (struct sd_fm_internal *)un->un_fm_private;
15385         ASSERT(sfip != NULL);
15386 
15387         SD_TRACE(SD_LOG_IO_CORE, un, "sd_return_command: entry\n");
15388 
15389         /*
15390          * Note: check for the "sdrestart failed" case.
15391          */
15392         if ((un->un_partial_dma_supported == 1) &&
15393             ((xp->xb_pkt_flags & SD_XB_USCSICMD) != SD_XB_USCSICMD) &&
15394             (geterror(bp) == 0) && (xp->xb_dma_resid != 0) &&
15395             (xp->xb_pktp->pkt_resid == 0)) {
15396 
15397                 if (sd_setup_next_xfer(un, bp, pktp, xp) != 0) {
15398                         /*
15399                          * Successfully set up next portion of cmd
15400                          * transfer, try sending it
15401                          */
15402                         sd_retry_command(un, bp, SD_RETRIES_NOCHECK,
15403                             NULL, NULL, 0, (clock_t)0, NULL);
15404                         sd_start_cmds(un, NULL);
15405                         return; /* Note:x86: need a return here? */
15406                 }
15407         }
15408 
15409         /*
15410          * If this is the failfast bp, clear it from un_failfast_bp. This
15411          * can happen if upon being re-tried the failfast bp either
15412          * succeeded or encountered another error (possibly even a different
15413          * error than the one that precipitated the failfast state, but in
15414          * that case it would have had to exhaust retries as well). Regardless,
15415          * this should not occur whenever the instance is in the active
15416          * failfast state.
15417          */
15418         if (bp == un->un_failfast_bp) {
15419                 ASSERT(un->un_failfast_state == SD_FAILFAST_INACTIVE);
15420                 un->un_failfast_bp = NULL;
15421         }
15422 
15423         /*
15424          * Clear the failfast state upon successful completion of ANY cmd.
15425          */
15426         if (bp->b_error == 0) {
15427                 un->un_failfast_state = SD_FAILFAST_INACTIVE;
15428                 /*
15429                  * If this is a successful command, but used to be retried,
15430                  * we will take it as a recovered command and post an
15431                  * ereport with driver-assessment of "recovered".
15432                  */
15433                 if (xp->xb_ena > 0) {
15434                         sd_ssc_extract_info(&sfip->fm_ssc, un, pktp, bp, xp);
15435                         sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_RECOVERY);
15436                 }
15437         } else {
15438                 /*
15439                  * If this is a failed non-USCSI command we will post an
15440                  * ereport with driver-assessment set accordingly("fail" or
15441                  * "fatal").
15442                  */
15443                 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
15444                         sd_ssc_extract_info(&sfip->fm_ssc, un, pktp, bp, xp);
15445                         sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_FATAL);
15446                 }
15447         }
15448 
15449         /*
15450          * This is used if the command was retried one or more times. Show that
15451          * we are done with it, and allow processing of the waitq to resume.
15452          */
15453         if (bp == un->un_retry_bp) {
15454                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15455                     "sd_return_command: un:0x%p: "
15456                     "RETURNING retry_bp:0x%p\n", un, un->un_retry_bp);
15457                 un->un_retry_bp = NULL;
15458                 un->un_retry_statp = NULL;
15459         }
15460 
15461         SD_UPDATE_RDWR_STATS(un, bp);
15462         SD_UPDATE_PARTITION_STATS(un, bp);
15463 
15464         switch (un->un_state) {
15465         case SD_STATE_SUSPENDED:
15466                 /*
15467                  * Notify any threads waiting in sd_ddi_suspend() that
15468                  * a command completion has occurred.
15469                  */
15470                 cv_broadcast(&un->un_disk_busy_cv);
15471                 break;
15472         default:
15473                 sd_start_cmds(un, NULL);
15474                 break;
15475         }
15476 
15477         /* Return this command up the iodone chain to its originator. */
15478         mutex_exit(SD_MUTEX(un));
15479 
15480         (*(sd_destroypkt_map[xp->xb_chain_iodone]))(bp);
15481         xp->xb_pktp = NULL;
15482 
15483         SD_BEGIN_IODONE(xp->xb_chain_iodone, un, bp);
15484 
15485         ASSERT(!mutex_owned(SD_MUTEX(un)));
15486         mutex_enter(SD_MUTEX(un));
15487 
15488         SD_TRACE(SD_LOG_IO_CORE, un, "sd_return_command: exit\n");
15489 }
15490 
15491 
15492 /*
15493  *    Function: sd_return_failed_command
15494  *
15495  * Description: Command completion when an error occurred.
15496  *
15497  *     Context: May be called from interrupt context
15498  */
15499 
15500 static void
15501 sd_return_failed_command(struct sd_lun *un, struct buf *bp, int errcode)
15502 {
15503         ASSERT(bp != NULL);
15504         ASSERT(un != NULL);
15505         ASSERT(mutex_owned(SD_MUTEX(un)));
15506 
15507         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15508             "sd_return_failed_command: entry\n");
15509 
15510         /*
15511          * b_resid could already be nonzero due to a partial data
15512          * transfer, so do not change it here.
15513          */
15514         SD_BIOERROR(bp, errcode);
15515 
15516         sd_return_command(un, bp);
15517         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15518             "sd_return_failed_command: exit\n");
15519 }
15520 
15521 
15522 /*
15523  *    Function: sd_return_failed_command_no_restart
15524  *
15525  * Description: Same as sd_return_failed_command, but ensures that no
15526  *              call back into sd_start_cmds will be issued.
15527  *
15528  *     Context: May be called from interrupt context
15529  */
15530 
15531 static void
15532 sd_return_failed_command_no_restart(struct sd_lun *un, struct buf *bp,
15533         int errcode)
15534 {
15535         struct sd_xbuf *xp;
15536 
15537         ASSERT(bp != NULL);
15538         ASSERT(un != NULL);
15539         ASSERT(mutex_owned(SD_MUTEX(un)));
15540         xp = SD_GET_XBUF(bp);
15541         ASSERT(xp != NULL);
15542         ASSERT(errcode != 0);
15543 
15544         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15545             "sd_return_failed_command_no_restart: entry\n");
15546 
15547         /*
15548          * b_resid could already be nonzero due to a partial data
15549          * transfer, so do not change it here.
15550          */
15551         SD_BIOERROR(bp, errcode);
15552 
15553         /*
15554          * If this is the failfast bp, clear it. This can happen if the
15555          * failfast bp encounterd a fatal error when we attempted to
15556          * re-try it (such as a scsi_transport(9F) failure).  However
15557          * we should NOT be in an active failfast state if the failfast
15558          * bp is not NULL.
15559          */
15560         if (bp == un->un_failfast_bp) {
15561                 ASSERT(un->un_failfast_state == SD_FAILFAST_INACTIVE);
15562                 un->un_failfast_bp = NULL;
15563         }
15564 
15565         if (bp == un->un_retry_bp) {
15566                 /*
15567                  * This command was retried one or more times. Show that we are
15568                  * done with it, and allow processing of the waitq to resume.
15569                  */
15570                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15571                     "sd_return_failed_command_no_restart: "
15572                     " un:0x%p: RETURNING retry_bp:0x%p\n", un, un->un_retry_bp);
15573                 un->un_retry_bp = NULL;
15574                 un->un_retry_statp = NULL;
15575         }
15576 
15577         SD_UPDATE_RDWR_STATS(un, bp);
15578         SD_UPDATE_PARTITION_STATS(un, bp);
15579 
15580         mutex_exit(SD_MUTEX(un));
15581 
15582         if (xp->xb_pktp != NULL) {
15583                 (*(sd_destroypkt_map[xp->xb_chain_iodone]))(bp);
15584                 xp->xb_pktp = NULL;
15585         }
15586 
15587         SD_BEGIN_IODONE(xp->xb_chain_iodone, un, bp);
15588 
15589         mutex_enter(SD_MUTEX(un));
15590 
15591         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15592             "sd_return_failed_command_no_restart: exit\n");
15593 }
15594 
15595 
15596 /*
15597  *    Function: sd_retry_command
15598  *
15599  * Description: queue up a command for retry, or (optionally) fail it
15600  *              if retry counts are exhausted.
15601  *
15602  *   Arguments: un - Pointer to the sd_lun struct for the target.
15603  *
15604  *              bp - Pointer to the buf for the command to be retried.
15605  *
15606  *              retry_check_flag - Flag to see which (if any) of the retry
15607  *                 counts should be decremented/checked. If the indicated
15608  *                 retry count is exhausted, then the command will not be
15609  *                 retried; it will be failed instead. This should use a
15610  *                 value equal to one of the following:
15611  *
15612  *                      SD_RETRIES_NOCHECK
15613  *                      SD_RESD_RETRIES_STANDARD
15614  *                      SD_RETRIES_VICTIM
15615  *
15616  *                 Optionally may be bitwise-OR'ed with SD_RETRIES_ISOLATE
15617  *                 if the check should be made to see of FLAG_ISOLATE is set
15618  *                 in the pkt. If FLAG_ISOLATE is set, then the command is
15619  *                 not retried, it is simply failed.
15620  *
15621  *              user_funcp - Ptr to function to call before dispatching the
15622  *                 command. May be NULL if no action needs to be performed.
15623  *                 (Primarily intended for printing messages.)
15624  *
15625  *              user_arg - Optional argument to be passed along to
15626  *                 the user_funcp call.
15627  *
15628  *              failure_code - errno return code to set in the bp if the
15629  *                 command is going to be failed.
15630  *
15631  *              retry_delay - Retry delay interval in (clock_t) units. May
15632  *                 be zero which indicates that the retry should be retried
15633  *                 immediately (ie, without an intervening delay).
15634  *
15635  *              statp - Ptr to kstat function to be updated if the command
15636  *                 is queued for a delayed retry. May be NULL if no kstat
15637  *                 update is desired.
15638  *
15639  *     Context: May be called from interrupt context.
15640  */
15641 
15642 static void
15643 sd_retry_command(struct sd_lun *un, struct buf *bp, int retry_check_flag,
15644         void (*user_funcp)(struct sd_lun *un, struct buf *bp, void *argp, int
15645         code), void *user_arg, int failure_code,  clock_t retry_delay,
15646         void (*statp)(kstat_io_t *))
15647 {
15648         struct sd_xbuf  *xp;
15649         struct scsi_pkt *pktp;
15650         struct sd_fm_internal *sfip;
15651 
15652         ASSERT(un != NULL);
15653         ASSERT(mutex_owned(SD_MUTEX(un)));
15654         ASSERT(bp != NULL);
15655         xp = SD_GET_XBUF(bp);
15656         ASSERT(xp != NULL);
15657         pktp = SD_GET_PKTP(bp);
15658         ASSERT(pktp != NULL);
15659 
15660         sfip = (struct sd_fm_internal *)un->un_fm_private;
15661         ASSERT(sfip != NULL);
15662 
15663         SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
15664             "sd_retry_command: entry: bp:0x%p xp:0x%p\n", bp, xp);
15665 
15666         /*
15667          * If we are syncing or dumping, fail the command to avoid
15668          * recursively calling back into scsi_transport().
15669          */
15670         if (ddi_in_panic()) {
15671                 goto fail_command_no_log;
15672         }
15673 
15674         /*
15675          * We should never be be retrying a command with FLAG_DIAGNOSE set, so
15676          * log an error and fail the command.
15677          */
15678         if ((pktp->pkt_flags & FLAG_DIAGNOSE) != 0) {
15679                 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE,
15680                     "ERROR, retrying FLAG_DIAGNOSE command.\n");
15681                 sd_dump_memory(un, SD_LOG_IO, "CDB",
15682                     (uchar_t *)pktp->pkt_cdbp, CDB_SIZE, SD_LOG_HEX);
15683                 sd_dump_memory(un, SD_LOG_IO, "Sense Data",
15684                     (uchar_t *)xp->xb_sense_data, SENSE_LENGTH, SD_LOG_HEX);
15685                 goto fail_command;
15686         }
15687 
15688         /*
15689          * If we are suspended, then put the command onto head of the
15690          * wait queue since we don't want to start more commands, and
15691          * clear the un_retry_bp. Next time when we are resumed, will
15692          * handle the command in the wait queue.
15693          */
15694         switch (un->un_state) {
15695         case SD_STATE_SUSPENDED:
15696         case SD_STATE_DUMPING:
15697                 bp->av_forw = un->un_waitq_headp;
15698                 un->un_waitq_headp = bp;
15699                 if (un->un_waitq_tailp == NULL) {
15700                         un->un_waitq_tailp = bp;
15701                 }
15702                 if (bp == un->un_retry_bp) {
15703                         un->un_retry_bp = NULL;
15704                         un->un_retry_statp = NULL;
15705                 }
15706                 SD_UPDATE_KSTATS(un, kstat_waitq_enter, bp);
15707                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_retry_command: "
15708                     "exiting; cmd bp:0x%p requeued for SUSPEND/DUMP\n", bp);
15709                 return;
15710         default:
15711                 break;
15712         }
15713 
15714         /*
15715          * If the caller wants us to check FLAG_ISOLATE, then see if that
15716          * is set; if it is then we do not want to retry the command.
15717          * Normally, FLAG_ISOLATE is only used with USCSI cmds.
15718          */
15719         if ((retry_check_flag & SD_RETRIES_ISOLATE) != 0) {
15720                 if ((pktp->pkt_flags & FLAG_ISOLATE) != 0) {
15721                         goto fail_command;
15722                 }
15723         }
15724 
15725 
15726         /*
15727          * If SD_RETRIES_FAILFAST is set, it indicates that either a
15728          * command timeout or a selection timeout has occurred. This means
15729          * that we were unable to establish an kind of communication with
15730          * the target, and subsequent retries and/or commands are likely
15731          * to encounter similar results and take a long time to complete.
15732          *
15733          * If this is a failfast error condition, we need to update the
15734          * failfast state, even if this bp does not have B_FAILFAST set.
15735          */
15736         if (retry_check_flag & SD_RETRIES_FAILFAST) {
15737                 if (un->un_failfast_state == SD_FAILFAST_ACTIVE) {
15738                         ASSERT(un->un_failfast_bp == NULL);
15739                         /*
15740                          * If we are already in the active failfast state, and
15741                          * another failfast error condition has been detected,
15742                          * then fail this command if it has B_FAILFAST set.
15743                          * If B_FAILFAST is clear, then maintain the legacy
15744                          * behavior of retrying heroically, even tho this will
15745                          * take a lot more time to fail the command.
15746                          */
15747                         if (bp->b_flags & B_FAILFAST) {
15748                                 goto fail_command;
15749                         }
15750                 } else {
15751                         /*
15752                          * We're not in the active failfast state, but we
15753                          * have a failfast error condition, so we must begin
15754                          * transition to the next state. We do this regardless
15755                          * of whether or not this bp has B_FAILFAST set.
15756                          */
15757                         if (un->un_failfast_bp == NULL) {
15758                                 /*
15759                                  * This is the first bp to meet a failfast
15760                                  * condition so save it on un_failfast_bp &
15761                                  * do normal retry processing. Do not enter
15762                                  * active failfast state yet. This marks
15763                                  * entry into the "failfast pending" state.
15764                                  */
15765                                 un->un_failfast_bp = bp;
15766 
15767                         } else if (un->un_failfast_bp == bp) {
15768                                 /*
15769                                  * This is the second time *this* bp has
15770                                  * encountered a failfast error condition,
15771                                  * so enter active failfast state & flush
15772                                  * queues as appropriate.
15773                                  */
15774                                 un->un_failfast_state = SD_FAILFAST_ACTIVE;
15775                                 un->un_failfast_bp = NULL;
15776                                 sd_failfast_flushq(un);
15777 
15778                                 /*
15779                                  * Fail this bp now if B_FAILFAST set;
15780                                  * otherwise continue with retries. (It would
15781                                  * be pretty ironic if this bp succeeded on a
15782                                  * subsequent retry after we just flushed all
15783                                  * the queues).
15784                                  */
15785                                 if (bp->b_flags & B_FAILFAST) {
15786                                         goto fail_command;
15787                                 }
15788 
15789 #if !defined(lint) && !defined(__lint)
15790                         } else {
15791                                 /*
15792                                  * If neither of the preceeding conditionals
15793                                  * was true, it means that there is some
15794                                  * *other* bp that has met an inital failfast
15795                                  * condition and is currently either being
15796                                  * retried or is waiting to be retried. In
15797                                  * that case we should perform normal retry
15798                                  * processing on *this* bp, since there is a
15799                                  * chance that the current failfast condition
15800                                  * is transient and recoverable. If that does
15801                                  * not turn out to be the case, then retries
15802                                  * will be cleared when the wait queue is
15803                                  * flushed anyway.
15804                                  */
15805 #endif
15806                         }
15807                 }
15808         } else {
15809                 /*
15810                  * SD_RETRIES_FAILFAST is clear, which indicates that we
15811                  * likely were able to at least establish some level of
15812                  * communication with the target and subsequent commands
15813                  * and/or retries are likely to get through to the target,
15814                  * In this case we want to be aggressive about clearing
15815                  * the failfast state. Note that this does not affect
15816                  * the "failfast pending" condition.
15817                  */
15818                 un->un_failfast_state = SD_FAILFAST_INACTIVE;
15819         }
15820 
15821 
15822         /*
15823          * Check the specified retry count to see if we can still do
15824          * any retries with this pkt before we should fail it.
15825          */
15826         switch (retry_check_flag & SD_RETRIES_MASK) {
15827         case SD_RETRIES_VICTIM:
15828                 /*
15829                  * Check the victim retry count. If exhausted, then fall
15830                  * thru & check against the standard retry count.
15831                  */
15832                 if (xp->xb_victim_retry_count < un->un_victim_retry_count) {
15833                         /* Increment count & proceed with the retry */
15834                         xp->xb_victim_retry_count++;
15835                         break;
15836                 }
15837                 /* Victim retries exhausted, fall back to std. retries... */
15838                 /* FALLTHRU */
15839 
15840         case SD_RETRIES_STANDARD:
15841                 if (xp->xb_retry_count >= un->un_retry_count) {
15842                         /* Retries exhausted, fail the command */
15843                         SD_TRACE(SD_LOG_IO_CORE, un,
15844                             "sd_retry_command: retries exhausted!\n");
15845                         /*
15846                          * update b_resid for failed SCMD_READ & SCMD_WRITE
15847                          * commands with nonzero pkt_resid.
15848                          */
15849                         if ((pktp->pkt_reason == CMD_CMPLT) &&
15850                             (SD_GET_PKT_STATUS(pktp) == STATUS_GOOD) &&
15851                             (pktp->pkt_resid != 0)) {
15852                                 uchar_t op = SD_GET_PKT_OPCODE(pktp) & 0x1F;
15853                                 if ((op == SCMD_READ) || (op == SCMD_WRITE)) {
15854                                         SD_UPDATE_B_RESID(bp, pktp);
15855                                 }
15856                         }
15857                         goto fail_command;
15858                 }
15859                 xp->xb_retry_count++;
15860                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15861                     "sd_retry_command: retry count:%d\n", xp->xb_retry_count);
15862                 break;
15863 
15864         case SD_RETRIES_UA:
15865                 if (xp->xb_ua_retry_count >= sd_ua_retry_count) {
15866                         /* Retries exhausted, fail the command */
15867                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
15868                             "Unit Attention retries exhausted. "
15869                             "Check the target.\n");
15870                         goto fail_command;
15871                 }
15872                 xp->xb_ua_retry_count++;
15873                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15874                     "sd_retry_command: retry count:%d\n",
15875                     xp->xb_ua_retry_count);
15876                 break;
15877 
15878         case SD_RETRIES_BUSY:
15879                 if (xp->xb_retry_count >= un->un_busy_retry_count) {
15880                         /* Retries exhausted, fail the command */
15881                         SD_TRACE(SD_LOG_IO_CORE, un,
15882                             "sd_retry_command: retries exhausted!\n");
15883                         goto fail_command;
15884                 }
15885                 xp->xb_retry_count++;
15886                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15887                     "sd_retry_command: retry count:%d\n", xp->xb_retry_count);
15888                 break;
15889 
15890         case SD_RETRIES_NOCHECK:
15891         default:
15892                 /* No retry count to check. Just proceed with the retry */
15893                 break;
15894         }
15895 
15896         xp->xb_pktp->pkt_flags |= FLAG_HEAD;
15897 
15898         /*
15899          * If this is a non-USCSI command being retried
15900          * during execution last time, we should post an ereport with
15901          * driver-assessment of the value "retry".
15902          * For partial DMA, request sense and STATUS_QFULL, there are no
15903          * hardware errors, we bypass ereport posting.
15904          */
15905         if (failure_code != 0) {
15906                 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
15907                         sd_ssc_extract_info(&sfip->fm_ssc, un, pktp, bp, xp);
15908                         sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_RETRY);
15909                 }
15910         }
15911 
15912         /*
15913          * If we were given a zero timeout, we must attempt to retry the
15914          * command immediately (ie, without a delay).
15915          */
15916         if (retry_delay == 0) {
15917                 /*
15918                  * Check some limiting conditions to see if we can actually
15919                  * do the immediate retry.  If we cannot, then we must
15920                  * fall back to queueing up a delayed retry.
15921                  */
15922                 if (un->un_ncmds_in_transport >= un->un_throttle) {
15923                         /*
15924                          * We are at the throttle limit for the target,
15925                          * fall back to delayed retry.
15926                          */
15927                         retry_delay = un->un_busy_timeout;
15928                         statp = kstat_waitq_enter;
15929                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15930                             "sd_retry_command: immed. retry hit "
15931                             "throttle!\n");
15932                 } else {
15933                         /*
15934                          * We're clear to proceed with the immediate retry.
15935                          * First call the user-provided function (if any)
15936                          */
15937                         if (user_funcp != NULL) {
15938                                 (*user_funcp)(un, bp, user_arg,
15939                                     SD_IMMEDIATE_RETRY_ISSUED);
15940 #ifdef __lock_lint
15941                                 sd_print_incomplete_msg(un, bp, user_arg,
15942                                     SD_IMMEDIATE_RETRY_ISSUED);
15943                                 sd_print_cmd_incomplete_msg(un, bp, user_arg,
15944                                     SD_IMMEDIATE_RETRY_ISSUED);
15945                                 sd_print_sense_failed_msg(un, bp, user_arg,
15946                                     SD_IMMEDIATE_RETRY_ISSUED);
15947 #endif
15948                         }
15949 
15950                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15951                             "sd_retry_command: issuing immediate retry\n");
15952 
15953                         /*
15954                          * Call sd_start_cmds() to transport the command to
15955                          * the target.
15956                          */
15957                         sd_start_cmds(un, bp);
15958 
15959                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15960                             "sd_retry_command exit\n");
15961                         return;
15962                 }
15963         }
15964 
15965         /*
15966          * Set up to retry the command after a delay.
15967          * First call the user-provided function (if any)
15968          */
15969         if (user_funcp != NULL) {
15970                 (*user_funcp)(un, bp, user_arg, SD_DELAYED_RETRY_ISSUED);
15971         }
15972 
15973         sd_set_retry_bp(un, bp, retry_delay, statp);
15974 
15975         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_retry_command: exit\n");
15976         return;
15977 
15978 fail_command:
15979 
15980         if (user_funcp != NULL) {
15981                 (*user_funcp)(un, bp, user_arg, SD_NO_RETRY_ISSUED);
15982         }
15983 
15984 fail_command_no_log:
15985 
15986         SD_INFO(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
15987             "sd_retry_command: returning failed command\n");
15988 
15989         sd_return_failed_command(un, bp, failure_code);
15990 
15991         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_retry_command: exit\n");
15992 }
15993 
15994 
15995 /*
15996  *    Function: sd_set_retry_bp
15997  *
15998  * Description: Set up the given bp for retry.
15999  *
16000  *   Arguments: un - ptr to associated softstate
16001  *              bp - ptr to buf(9S) for the command
16002  *              retry_delay - time interval before issuing retry (may be 0)
16003  *              statp - optional pointer to kstat function
16004  *
16005  *     Context: May be called under interrupt context
16006  */
16007 
16008 static void
16009 sd_set_retry_bp(struct sd_lun *un, struct buf *bp, clock_t retry_delay,
16010         void (*statp)(kstat_io_t *))
16011 {
16012         ASSERT(un != NULL);
16013         ASSERT(mutex_owned(SD_MUTEX(un)));
16014         ASSERT(bp != NULL);
16015 
16016         SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
16017             "sd_set_retry_bp: entry: un:0x%p bp:0x%p\n", un, bp);
16018 
16019         /*
16020          * Indicate that the command is being retried. This will not allow any
16021          * other commands on the wait queue to be transported to the target
16022          * until this command has been completed (success or failure). The
16023          * "retry command" is not transported to the target until the given
16024          * time delay expires, unless the user specified a 0 retry_delay.
16025          *
16026          * Note: the timeout(9F) callback routine is what actually calls
16027          * sd_start_cmds() to transport the command, with the exception of a
16028          * zero retry_delay. The only current implementor of a zero retry delay
16029          * is the case where a START_STOP_UNIT is sent to spin-up a device.
16030          */
16031         if (un->un_retry_bp == NULL) {
16032                 ASSERT(un->un_retry_statp == NULL);
16033                 un->un_retry_bp = bp;
16034 
16035                 /*
16036                  * If the user has not specified a delay the command should
16037                  * be queued and no timeout should be scheduled.
16038                  */
16039                 if (retry_delay == 0) {
16040                         /*
16041                          * Save the kstat pointer that will be used in the
16042                          * call to SD_UPDATE_KSTATS() below, so that
16043                          * sd_start_cmds() can correctly decrement the waitq
16044                          * count when it is time to transport this command.
16045                          */
16046                         un->un_retry_statp = statp;
16047                         goto done;
16048                 }
16049         }
16050 
16051         if (un->un_retry_bp == bp) {
16052                 /*
16053                  * Save the kstat pointer that will be used in the call to
16054                  * SD_UPDATE_KSTATS() below, so that sd_start_cmds() can
16055                  * correctly decrement the waitq count when it is time to
16056                  * transport this command.
16057                  */
16058                 un->un_retry_statp = statp;
16059 
16060                 /*
16061                  * Schedule a timeout if:
16062                  *   1) The user has specified a delay.
16063                  *   2) There is not a START_STOP_UNIT callback pending.
16064                  *
16065                  * If no delay has been specified, then it is up to the caller
16066                  * to ensure that IO processing continues without stalling.
16067                  * Effectively, this means that the caller will issue the
16068                  * required call to sd_start_cmds(). The START_STOP_UNIT
16069                  * callback does this after the START STOP UNIT command has
16070                  * completed. In either of these cases we should not schedule
16071                  * a timeout callback here.  Also don't schedule the timeout if
16072                  * an SD_PATH_DIRECT_PRIORITY command is waiting to restart.
16073                  */
16074                 if ((retry_delay != 0) && (un->un_startstop_timeid == NULL) &&
16075                     (un->un_direct_priority_timeid == NULL)) {
16076                         un->un_retry_timeid =
16077                             timeout(sd_start_retry_command, un, retry_delay);
16078                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16079                             "sd_set_retry_bp: setting timeout: un: 0x%p"
16080                             " bp:0x%p un_retry_timeid:0x%p\n",
16081                             un, bp, un->un_retry_timeid);
16082                 }
16083         } else {
16084                 /*
16085                  * We only get in here if there is already another command
16086                  * waiting to be retried.  In this case, we just put the
16087                  * given command onto the wait queue, so it can be transported
16088                  * after the current retry command has completed.
16089                  *
16090                  * Also we have to make sure that if the command at the head
16091                  * of the wait queue is the un_failfast_bp, that we do not
16092                  * put ahead of it any other commands that are to be retried.
16093                  */
16094                 if ((un->un_failfast_bp != NULL) &&
16095                     (un->un_failfast_bp == un->un_waitq_headp)) {
16096                         /*
16097                          * Enqueue this command AFTER the first command on
16098                          * the wait queue (which is also un_failfast_bp).
16099                          */
16100                         bp->av_forw = un->un_waitq_headp->av_forw;
16101                         un->un_waitq_headp->av_forw = bp;
16102                         if (un->un_waitq_headp == un->un_waitq_tailp) {
16103                                 un->un_waitq_tailp = bp;
16104                         }
16105                 } else {
16106                         /* Enqueue this command at the head of the waitq. */
16107                         bp->av_forw = un->un_waitq_headp;
16108                         un->un_waitq_headp = bp;
16109                         if (un->un_waitq_tailp == NULL) {
16110                                 un->un_waitq_tailp = bp;
16111                         }
16112                 }
16113 
16114                 if (statp == NULL) {
16115                         statp = kstat_waitq_enter;
16116                 }
16117                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16118                     "sd_set_retry_bp: un:0x%p already delayed retry\n", un);
16119         }
16120 
16121 done:
16122         if (statp != NULL) {
16123                 SD_UPDATE_KSTATS(un, statp, bp);
16124         }
16125 
16126         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16127             "sd_set_retry_bp: exit un:0x%p\n", un);
16128 }
16129 
16130 
16131 /*
16132  *    Function: sd_start_retry_command
16133  *
16134  * Description: Start the command that has been waiting on the target's
16135  *              retry queue.  Called from timeout(9F) context after the
16136  *              retry delay interval has expired.
16137  *
16138  *   Arguments: arg - pointer to associated softstate for the device.
16139  *
16140  *     Context: timeout(9F) thread context.  May not sleep.
16141  */
16142 
16143 static void
16144 sd_start_retry_command(void *arg)
16145 {
16146         struct sd_lun *un = arg;
16147 
16148         ASSERT(un != NULL);
16149         ASSERT(!mutex_owned(SD_MUTEX(un)));
16150 
16151         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16152             "sd_start_retry_command: entry\n");
16153 
16154         mutex_enter(SD_MUTEX(un));
16155 
16156         un->un_retry_timeid = NULL;
16157 
16158         if (un->un_retry_bp != NULL) {
16159                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16160                     "sd_start_retry_command: un:0x%p STARTING bp:0x%p\n",
16161                     un, un->un_retry_bp);
16162                 sd_start_cmds(un, un->un_retry_bp);
16163         }
16164 
16165         mutex_exit(SD_MUTEX(un));
16166 
16167         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16168             "sd_start_retry_command: exit\n");
16169 }
16170 
16171 /*
16172  *    Function: sd_rmw_msg_print_handler
16173  *
16174  * Description: If RMW mode is enabled and warning message is triggered
16175  *              print I/O count during a fixed interval.
16176  *
16177  *   Arguments: arg - pointer to associated softstate for the device.
16178  *
16179  *     Context: timeout(9F) thread context. May not sleep.
16180  */
16181 static void
16182 sd_rmw_msg_print_handler(void *arg)
16183 {
16184         struct sd_lun *un = arg;
16185 
16186         ASSERT(un != NULL);
16187         ASSERT(!mutex_owned(SD_MUTEX(un)));
16188 
16189         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16190             "sd_rmw_msg_print_handler: entry\n");
16191 
16192         mutex_enter(SD_MUTEX(un));
16193 
16194         if (un->un_rmw_incre_count > 0) {
16195                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
16196                     "%"PRIu64" I/O requests are not aligned with %d disk "
16197                     "sector size in %ld seconds. They are handled through "
16198                     "Read Modify Write but the performance is very low!\n",
16199                     un->un_rmw_incre_count, un->un_tgt_blocksize,
16200                     drv_hztousec(SD_RMW_MSG_PRINT_TIMEOUT) / 1000000);
16201                 un->un_rmw_incre_count = 0;
16202                 un->un_rmw_msg_timeid = timeout(sd_rmw_msg_print_handler,
16203                     un, SD_RMW_MSG_PRINT_TIMEOUT);
16204         } else {
16205                 un->un_rmw_msg_timeid = NULL;
16206         }
16207 
16208         mutex_exit(SD_MUTEX(un));
16209 
16210         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16211             "sd_rmw_msg_print_handler: exit\n");
16212 }
16213 
16214 /*
16215  *    Function: sd_start_direct_priority_command
16216  *
16217  * Description: Used to re-start an SD_PATH_DIRECT_PRIORITY command that had
16218  *              received TRAN_BUSY when we called scsi_transport() to send it
16219  *              to the underlying HBA. This function is called from timeout(9F)
16220  *              context after the delay interval has expired.
16221  *
16222  *   Arguments: arg - pointer to associated buf(9S) to be restarted.
16223  *
16224  *     Context: timeout(9F) thread context.  May not sleep.
16225  */
16226 
16227 static void
16228 sd_start_direct_priority_command(void *arg)
16229 {
16230         struct buf      *priority_bp = arg;
16231         struct sd_lun   *un;
16232 
16233         ASSERT(priority_bp != NULL);
16234         un = SD_GET_UN(priority_bp);
16235         ASSERT(un != NULL);
16236         ASSERT(!mutex_owned(SD_MUTEX(un)));
16237 
16238         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16239             "sd_start_direct_priority_command: entry\n");
16240 
16241         mutex_enter(SD_MUTEX(un));
16242         un->un_direct_priority_timeid = NULL;
16243         sd_start_cmds(un, priority_bp);
16244         mutex_exit(SD_MUTEX(un));
16245 
16246         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16247             "sd_start_direct_priority_command: exit\n");
16248 }
16249 
16250 
16251 /*
16252  *    Function: sd_send_request_sense_command
16253  *
16254  * Description: Sends a REQUEST SENSE command to the target
16255  *
16256  *     Context: May be called from interrupt context.
16257  */
16258 
16259 static void
16260 sd_send_request_sense_command(struct sd_lun *un, struct buf *bp,
16261         struct scsi_pkt *pktp)
16262 {
16263         ASSERT(bp != NULL);
16264         ASSERT(un != NULL);
16265         ASSERT(mutex_owned(SD_MUTEX(un)));
16266 
16267         SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_send_request_sense_command: "
16268             "entry: buf:0x%p\n", bp);
16269 
16270         /*
16271          * If we are syncing or dumping, then fail the command to avoid a
16272          * recursive callback into scsi_transport(). Also fail the command
16273          * if we are suspended (legacy behavior).
16274          */
16275         if (ddi_in_panic() || (un->un_state == SD_STATE_SUSPENDED) ||
16276             (un->un_state == SD_STATE_DUMPING)) {
16277                 sd_return_failed_command(un, bp, EIO);
16278                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16279                     "sd_send_request_sense_command: syncing/dumping, exit\n");
16280                 return;
16281         }
16282 
16283         /*
16284          * Retry the failed command and don't issue the request sense if:
16285          *    1) the sense buf is busy
16286          *    2) we have 1 or more outstanding commands on the target
16287          *    (the sense data will be cleared or invalidated any way)
16288          *
16289          * Note: There could be an issue with not checking a retry limit here,
16290          * the problem is determining which retry limit to check.
16291          */
16292         if ((un->un_sense_isbusy != 0) || (un->un_ncmds_in_transport > 0)) {
16293                 /* Don't retry if the command is flagged as non-retryable */
16294                 if ((pktp->pkt_flags & FLAG_DIAGNOSE) == 0) {
16295                         sd_retry_command(un, bp, SD_RETRIES_NOCHECK,
16296                             NULL, NULL, 0, un->un_busy_timeout,
16297                             kstat_waitq_enter);
16298                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16299                             "sd_send_request_sense_command: "
16300                             "at full throttle, retrying exit\n");
16301                 } else {
16302                         sd_return_failed_command(un, bp, EIO);
16303                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16304                             "sd_send_request_sense_command: "
16305                             "at full throttle, non-retryable exit\n");
16306                 }
16307                 return;
16308         }
16309 
16310         sd_mark_rqs_busy(un, bp);
16311         sd_start_cmds(un, un->un_rqs_bp);
16312 
16313         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16314             "sd_send_request_sense_command: exit\n");
16315 }
16316 
16317 
16318 /*
16319  *    Function: sd_mark_rqs_busy
16320  *
16321  * Description: Indicate that the request sense bp for this instance is
16322  *              in use.
16323  *
16324  *     Context: May be called under interrupt context
16325  */
16326 
16327 static void
16328 sd_mark_rqs_busy(struct sd_lun *un, struct buf *bp)
16329 {
16330         struct sd_xbuf  *sense_xp;
16331 
16332         ASSERT(un != NULL);
16333         ASSERT(bp != NULL);
16334         ASSERT(mutex_owned(SD_MUTEX(un)));
16335         ASSERT(un->un_sense_isbusy == 0);
16336 
16337         SD_TRACE(SD_LOG_IO_CORE, un, "sd_mark_rqs_busy: entry: "
16338             "buf:0x%p xp:0x%p un:0x%p\n", bp, SD_GET_XBUF(bp), un);
16339 
16340         sense_xp = SD_GET_XBUF(un->un_rqs_bp);
16341         ASSERT(sense_xp != NULL);
16342 
16343         SD_INFO(SD_LOG_IO, un,
16344             "sd_mark_rqs_busy: entry: sense_xp:0x%p\n", sense_xp);
16345 
16346         ASSERT(sense_xp->xb_pktp != NULL);
16347         ASSERT((sense_xp->xb_pktp->pkt_flags & (FLAG_SENSING | FLAG_HEAD))
16348             == (FLAG_SENSING | FLAG_HEAD));
16349 
16350         un->un_sense_isbusy = 1;
16351         un->un_rqs_bp->b_resid = 0;
16352         sense_xp->xb_pktp->pkt_resid  = 0;
16353         sense_xp->xb_pktp->pkt_reason = 0;
16354 
16355         /* So we can get back the bp at interrupt time! */
16356         sense_xp->xb_sense_bp = bp;
16357 
16358         bzero(un->un_rqs_bp->b_un.b_addr, SENSE_LENGTH);
16359 
16360         /*
16361          * Mark this buf as awaiting sense data. (This is already set in
16362          * the pkt_flags for the RQS packet.)
16363          */
16364         ((SD_GET_XBUF(bp))->xb_pktp)->pkt_flags |= FLAG_SENSING;
16365 
16366         /* Request sense down same path */
16367         if (scsi_pkt_allocated_correctly((SD_GET_XBUF(bp))->xb_pktp) &&
16368             ((SD_GET_XBUF(bp))->xb_pktp)->pkt_path_instance)
16369                 sense_xp->xb_pktp->pkt_path_instance =
16370                     ((SD_GET_XBUF(bp))->xb_pktp)->pkt_path_instance;
16371 
16372         sense_xp->xb_retry_count     = 0;
16373         sense_xp->xb_victim_retry_count = 0;
16374         sense_xp->xb_ua_retry_count  = 0;
16375         sense_xp->xb_nr_retry_count  = 0;
16376         sense_xp->xb_dma_resid  = 0;
16377 
16378         /* Clean up the fields for auto-request sense */
16379         sense_xp->xb_sense_status = 0;
16380         sense_xp->xb_sense_state  = 0;
16381         sense_xp->xb_sense_resid  = 0;
16382         bzero(sense_xp->xb_sense_data, sizeof (sense_xp->xb_sense_data));
16383 
16384         SD_TRACE(SD_LOG_IO_CORE, un, "sd_mark_rqs_busy: exit\n");
16385 }
16386 
16387 
16388 /*
16389  *    Function: sd_mark_rqs_idle
16390  *
16391  * Description: SD_MUTEX must be held continuously through this routine
16392  *              to prevent reuse of the rqs struct before the caller can
16393  *              complete it's processing.
16394  *
16395  * Return Code: Pointer to the RQS buf
16396  *
16397  *     Context: May be called under interrupt context
16398  */
16399 
16400 static struct buf *
16401 sd_mark_rqs_idle(struct sd_lun *un, struct sd_xbuf *sense_xp)
16402 {
16403         struct buf *bp;
16404         ASSERT(un != NULL);
16405         ASSERT(sense_xp != NULL);
16406         ASSERT(mutex_owned(SD_MUTEX(un)));
16407         ASSERT(un->un_sense_isbusy != 0);
16408 
16409         un->un_sense_isbusy = 0;
16410         bp = sense_xp->xb_sense_bp;
16411         sense_xp->xb_sense_bp = NULL;
16412 
16413         /* This pkt is no longer interested in getting sense data */
16414         ((SD_GET_XBUF(bp))->xb_pktp)->pkt_flags &= ~FLAG_SENSING;
16415 
16416         return (bp);
16417 }
16418 
16419 
16420 
16421 /*
16422  *    Function: sd_alloc_rqs
16423  *
16424  * Description: Set up the unit to receive auto request sense data
16425  *
16426  * Return Code: DDI_SUCCESS or DDI_FAILURE
16427  *
16428  *     Context: Called under attach(9E) context
16429  */
16430 
16431 static int
16432 sd_alloc_rqs(struct scsi_device *devp, struct sd_lun *un)
16433 {
16434         struct sd_xbuf *xp;
16435 
16436         ASSERT(un != NULL);
16437         ASSERT(!mutex_owned(SD_MUTEX(un)));
16438         ASSERT(un->un_rqs_bp == NULL);
16439         ASSERT(un->un_rqs_pktp == NULL);
16440 
16441         /*
16442          * First allocate the required buf and scsi_pkt structs, then set up
16443          * the CDB in the scsi_pkt for a REQUEST SENSE command.
16444          */
16445         un->un_rqs_bp = scsi_alloc_consistent_buf(&devp->sd_address, NULL,
16446             MAX_SENSE_LENGTH, B_READ, SLEEP_FUNC, NULL);
16447         if (un->un_rqs_bp == NULL) {
16448                 return (DDI_FAILURE);
16449         }
16450 
16451         un->un_rqs_pktp = scsi_init_pkt(&devp->sd_address, NULL, un->un_rqs_bp,
16452             CDB_GROUP0, 1, 0, PKT_CONSISTENT, SLEEP_FUNC, NULL);
16453 
16454         if (un->un_rqs_pktp == NULL) {
16455                 sd_free_rqs(un);
16456                 return (DDI_FAILURE);
16457         }
16458 
16459         /* Set up the CDB in the scsi_pkt for a REQUEST SENSE command. */
16460         (void) scsi_setup_cdb((union scsi_cdb *)un->un_rqs_pktp->pkt_cdbp,
16461             SCMD_REQUEST_SENSE, 0, MAX_SENSE_LENGTH, 0);
16462 
16463         SD_FILL_SCSI1_LUN(un, un->un_rqs_pktp);
16464 
16465         /* Set up the other needed members in the ARQ scsi_pkt. */
16466         un->un_rqs_pktp->pkt_comp   = sdintr;
16467         un->un_rqs_pktp->pkt_time   = sd_io_time;
16468         un->un_rqs_pktp->pkt_flags |=
16469             (FLAG_SENSING | FLAG_HEAD); /* (1222170) */
16470 
16471         /*
16472          * Allocate  & init the sd_xbuf struct for the RQS command. Do not
16473          * provide any intpkt, destroypkt routines as we take care of
16474          * scsi_pkt allocation/freeing here and in sd_free_rqs().
16475          */
16476         xp = kmem_alloc(sizeof (struct sd_xbuf), KM_SLEEP);
16477         sd_xbuf_init(un, un->un_rqs_bp, xp, SD_CHAIN_NULL, NULL);
16478         xp->xb_pktp = un->un_rqs_pktp;
16479         SD_INFO(SD_LOG_ATTACH_DETACH, un,
16480             "sd_alloc_rqs: un 0x%p, rqs  xp 0x%p,  pkt 0x%p,  buf 0x%p\n",
16481             un, xp, un->un_rqs_pktp, un->un_rqs_bp);
16482 
16483         /*
16484          * Save the pointer to the request sense private bp so it can
16485          * be retrieved in sdintr.
16486          */
16487         un->un_rqs_pktp->pkt_private = un->un_rqs_bp;
16488         ASSERT(un->un_rqs_bp->b_private == xp);
16489 
16490         /*
16491          * See if the HBA supports auto-request sense for the specified
16492          * target/lun. If it does, then try to enable it (if not already
16493          * enabled).
16494          *
16495          * Note: For some HBAs (ifp & sf), scsi_ifsetcap will always return
16496          * failure, while for other HBAs (pln) scsi_ifsetcap will always
16497          * return success.  However, in both of these cases ARQ is always
16498          * enabled and scsi_ifgetcap will always return true. The best approach
16499          * is to issue the scsi_ifgetcap() first, then try the scsi_ifsetcap().
16500          *
16501          * The 3rd case is the HBA (adp) always return enabled on
16502          * scsi_ifgetgetcap even when it's not enable, the best approach
16503          * is issue a scsi_ifsetcap then a scsi_ifgetcap
16504          * Note: this case is to circumvent the Adaptec bug. (x86 only)
16505          */
16506 
16507         if (un->un_f_is_fibre == TRUE) {
16508                 un->un_f_arq_enabled = TRUE;
16509         } else {
16510 #if defined(__i386) || defined(__amd64)
16511                 /*
16512                  * Circumvent the Adaptec bug, remove this code when
16513                  * the bug is fixed
16514                  */
16515                 (void) scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 1, 1);
16516 #endif
16517                 switch (scsi_ifgetcap(SD_ADDRESS(un), "auto-rqsense", 1)) {
16518                 case 0:
16519                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
16520                             "sd_alloc_rqs: HBA supports ARQ\n");
16521                         /*
16522                          * ARQ is supported by this HBA but currently is not
16523                          * enabled. Attempt to enable it and if successful then
16524                          * mark this instance as ARQ enabled.
16525                          */
16526                         if (scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 1, 1)
16527                             == 1) {
16528                                 /* Successfully enabled ARQ in the HBA */
16529                                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16530                                     "sd_alloc_rqs: ARQ enabled\n");
16531                                 un->un_f_arq_enabled = TRUE;
16532                         } else {
16533                                 /* Could not enable ARQ in the HBA */
16534                                 SD_INFO(SD_LOG_ATTACH_DETACH, un,
16535                                     "sd_alloc_rqs: failed ARQ enable\n");
16536                                 un->un_f_arq_enabled = FALSE;
16537                         }
16538                         break;
16539                 case 1:
16540                         /*
16541                          * ARQ is supported by this HBA and is already enabled.
16542                          * Just mark ARQ as enabled for this instance.
16543                          */
16544                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
16545                             "sd_alloc_rqs: ARQ already enabled\n");
16546                         un->un_f_arq_enabled = TRUE;
16547                         break;
16548                 default:
16549                         /*
16550                          * ARQ is not supported by this HBA; disable it for this
16551                          * instance.
16552                          */
16553                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
16554                             "sd_alloc_rqs: HBA does not support ARQ\n");
16555                         un->un_f_arq_enabled = FALSE;
16556                         break;
16557                 }
16558         }
16559 
16560         return (DDI_SUCCESS);
16561 }
16562 
16563 
16564 /*
16565  *    Function: sd_free_rqs
16566  *
16567  * Description: Cleanup for the pre-instance RQS command.
16568  *
16569  *     Context: Kernel thread context
16570  */
16571 
16572 static void
16573 sd_free_rqs(struct sd_lun *un)
16574 {
16575         ASSERT(un != NULL);
16576 
16577         SD_TRACE(SD_LOG_IO_CORE, un, "sd_free_rqs: entry\n");
16578 
16579         /*
16580          * If consistent memory is bound to a scsi_pkt, the pkt
16581          * has to be destroyed *before* freeing the consistent memory.
16582          * Don't change the sequence of this operations.
16583          * scsi_destroy_pkt() might access memory, which isn't allowed,
16584          * after it was freed in scsi_free_consistent_buf().
16585          */
16586         if (un->un_rqs_pktp != NULL) {
16587                 scsi_destroy_pkt(un->un_rqs_pktp);
16588                 un->un_rqs_pktp = NULL;
16589         }
16590 
16591         if (un->un_rqs_bp != NULL) {
16592                 struct sd_xbuf *xp = SD_GET_XBUF(un->un_rqs_bp);
16593                 if (xp != NULL) {
16594                         kmem_free(xp, sizeof (struct sd_xbuf));
16595                 }
16596                 scsi_free_consistent_buf(un->un_rqs_bp);
16597                 un->un_rqs_bp = NULL;
16598         }
16599         SD_TRACE(SD_LOG_IO_CORE, un, "sd_free_rqs: exit\n");
16600 }
16601 
16602 
16603 
16604 /*
16605  *    Function: sd_reduce_throttle
16606  *
16607  * Description: Reduces the maximum # of outstanding commands on a
16608  *              target to the current number of outstanding commands.
16609  *              Queues a tiemout(9F) callback to restore the limit
16610  *              after a specified interval has elapsed.
16611  *              Typically used when we get a TRAN_BUSY return code
16612  *              back from scsi_transport().
16613  *
16614  *   Arguments: un - ptr to the sd_lun softstate struct
16615  *              throttle_type: SD_THROTTLE_TRAN_BUSY or SD_THROTTLE_QFULL
16616  *
16617  *     Context: May be called from interrupt context
16618  */
16619 
16620 static void
16621 sd_reduce_throttle(struct sd_lun *un, int throttle_type)
16622 {
16623         ASSERT(un != NULL);
16624         ASSERT(mutex_owned(SD_MUTEX(un)));
16625         ASSERT(un->un_ncmds_in_transport >= 0);
16626 
16627         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reduce_throttle: "
16628             "entry: un:0x%p un_throttle:%d un_ncmds_in_transport:%d\n",
16629             un, un->un_throttle, un->un_ncmds_in_transport);
16630 
16631         if (un->un_throttle > 1) {
16632                 if (un->un_f_use_adaptive_throttle == TRUE) {
16633                         switch (throttle_type) {
16634                         case SD_THROTTLE_TRAN_BUSY:
16635                                 if (un->un_busy_throttle == 0) {
16636                                         un->un_busy_throttle = un->un_throttle;
16637                                 }
16638                                 break;
16639                         case SD_THROTTLE_QFULL:
16640                                 un->un_busy_throttle = 0;
16641                                 break;
16642                         default:
16643                                 ASSERT(FALSE);
16644                         }
16645 
16646                         if (un->un_ncmds_in_transport > 0) {
16647                                 un->un_throttle = un->un_ncmds_in_transport;
16648                         }
16649 
16650                 } else {
16651                         if (un->un_ncmds_in_transport == 0) {
16652                                 un->un_throttle = 1;
16653                         } else {
16654                                 un->un_throttle = un->un_ncmds_in_transport;
16655                         }
16656                 }
16657         }
16658 
16659         /* Reschedule the timeout if none is currently active */
16660         if (un->un_reset_throttle_timeid == NULL) {
16661                 un->un_reset_throttle_timeid = timeout(sd_restore_throttle,
16662                     un, SD_THROTTLE_RESET_INTERVAL);
16663                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16664                     "sd_reduce_throttle: timeout scheduled!\n");
16665         }
16666 
16667         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reduce_throttle: "
16668             "exit: un:0x%p un_throttle:%d\n", un, un->un_throttle);
16669 }
16670 
16671 
16672 
16673 /*
16674  *    Function: sd_restore_throttle
16675  *
16676  * Description: Callback function for timeout(9F).  Resets the current
16677  *              value of un->un_throttle to its default.
16678  *
16679  *   Arguments: arg - pointer to associated softstate for the device.
16680  *
16681  *     Context: May be called from interrupt context
16682  */
16683 
16684 static void
16685 sd_restore_throttle(void *arg)
16686 {
16687         struct sd_lun   *un = arg;
16688 
16689         ASSERT(un != NULL);
16690         ASSERT(!mutex_owned(SD_MUTEX(un)));
16691 
16692         mutex_enter(SD_MUTEX(un));
16693 
16694         SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_restore_throttle: "
16695             "entry: un:0x%p un_throttle:%d\n", un, un->un_throttle);
16696 
16697         un->un_reset_throttle_timeid = NULL;
16698 
16699         if (un->un_f_use_adaptive_throttle == TRUE) {
16700                 /*
16701                  * If un_busy_throttle is nonzero, then it contains the
16702                  * value that un_throttle was when we got a TRAN_BUSY back
16703                  * from scsi_transport(). We want to revert back to this
16704                  * value.
16705                  *
16706                  * In the QFULL case, the throttle limit will incrementally
16707                  * increase until it reaches max throttle.
16708                  */
16709                 if (un->un_busy_throttle > 0) {
16710                         un->un_throttle = un->un_busy_throttle;
16711                         un->un_busy_throttle = 0;
16712                 } else {
16713                         /*
16714                          * increase throttle by 10% open gate slowly, schedule
16715                          * another restore if saved throttle has not been
16716                          * reached
16717                          */
16718                         short throttle;
16719                         if (sd_qfull_throttle_enable) {
16720                                 throttle = un->un_throttle +
16721                                     max((un->un_throttle / 10), 1);
16722                                 un->un_throttle =
16723                                     (throttle < un->un_saved_throttle) ?
16724                                     throttle : un->un_saved_throttle;
16725                                 if (un->un_throttle < un->un_saved_throttle) {
16726                                         un->un_reset_throttle_timeid =
16727                                             timeout(sd_restore_throttle,
16728                                             un,
16729                                             SD_QFULL_THROTTLE_RESET_INTERVAL);
16730                                 }
16731                         }
16732                 }
16733 
16734                 /*
16735                  * If un_throttle has fallen below the low-water mark, we
16736                  * restore the maximum value here (and allow it to ratchet
16737                  * down again if necessary).
16738                  */
16739                 if (un->un_throttle < un->un_min_throttle) {
16740                         un->un_throttle = un->un_saved_throttle;
16741                 }
16742         } else {
16743                 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_restore_throttle: "
16744                     "restoring limit from 0x%x to 0x%x\n",
16745                     un->un_throttle, un->un_saved_throttle);
16746                 un->un_throttle = un->un_saved_throttle;
16747         }
16748 
16749         SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
16750             "sd_restore_throttle: calling sd_start_cmds!\n");
16751 
16752         sd_start_cmds(un, NULL);
16753 
16754         SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un,
16755             "sd_restore_throttle: exit: un:0x%p un_throttle:%d\n",
16756             un, un->un_throttle);
16757 
16758         mutex_exit(SD_MUTEX(un));
16759 
16760         SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_restore_throttle: exit\n");
16761 }
16762 
16763 /*
16764  *    Function: sdrunout
16765  *
16766  * Description: Callback routine for scsi_init_pkt when a resource allocation
16767  *              fails.
16768  *
16769  *   Arguments: arg - a pointer to the sd_lun unit struct for the particular
16770  *              soft state instance.
16771  *
16772  * Return Code: The scsi_init_pkt routine allows for the callback function to
16773  *              return a 0 indicating the callback should be rescheduled or a 1
16774  *              indicating not to reschedule. This routine always returns 1
16775  *              because the driver always provides a callback function to
16776  *              scsi_init_pkt. This results in a callback always being scheduled
16777  *              (via the scsi_init_pkt callback implementation) if a resource
16778  *              failure occurs.
16779  *
16780  *     Context: This callback function may not block or call routines that block
16781  *
16782  *        Note: Using the scsi_init_pkt callback facility can result in an I/O
16783  *              request persisting at the head of the list which cannot be
16784  *              satisfied even after multiple retries. In the future the driver
16785  *              may implement some time of maximum runout count before failing
16786  *              an I/O.
16787  */
16788 
16789 static int
16790 sdrunout(caddr_t arg)
16791 {
16792         struct sd_lun   *un = (struct sd_lun *)arg;
16793 
16794         ASSERT(un != NULL);
16795         ASSERT(!mutex_owned(SD_MUTEX(un)));
16796 
16797         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdrunout: entry\n");
16798 
16799         mutex_enter(SD_MUTEX(un));
16800         sd_start_cmds(un, NULL);
16801         mutex_exit(SD_MUTEX(un));
16802         /*
16803          * This callback routine always returns 1 (i.e. do not reschedule)
16804          * because we always specify sdrunout as the callback handler for
16805          * scsi_init_pkt inside the call to sd_start_cmds.
16806          */
16807         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdrunout: exit\n");
16808         return (1);
16809 }
16810 
16811 
16812 /*
16813  *    Function: sdintr
16814  *
16815  * Description: Completion callback routine for scsi_pkt(9S) structs
16816  *              sent to the HBA driver via scsi_transport(9F).
16817  *
16818  *     Context: Interrupt context
16819  */
16820 
16821 static void
16822 sdintr(struct scsi_pkt *pktp)
16823 {
16824         struct buf      *bp;
16825         struct sd_xbuf  *xp;
16826         struct sd_lun   *un;
16827         size_t          actual_len;
16828         sd_ssc_t        *sscp;
16829 
16830         ASSERT(pktp != NULL);
16831         bp = (struct buf *)pktp->pkt_private;
16832         ASSERT(bp != NULL);
16833         xp = SD_GET_XBUF(bp);
16834         ASSERT(xp != NULL);
16835         ASSERT(xp->xb_pktp != NULL);
16836         un = SD_GET_UN(bp);
16837         ASSERT(un != NULL);
16838         ASSERT(!mutex_owned(SD_MUTEX(un)));
16839 
16840 #ifdef SD_FAULT_INJECTION
16841 
16842         SD_INFO(SD_LOG_IOERR, un, "sdintr: sdintr calling Fault injection\n");
16843         /* SD FaultInjection */
16844         sd_faultinjection(pktp);
16845 
16846 #endif /* SD_FAULT_INJECTION */
16847 
16848         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdintr: entry: buf:0x%p,"
16849             " xp:0x%p, un:0x%p\n", bp, xp, un);
16850 
16851         mutex_enter(SD_MUTEX(un));
16852 
16853         ASSERT(un->un_fm_private != NULL);
16854         sscp = &((struct sd_fm_internal *)(un->un_fm_private))->fm_ssc;
16855         ASSERT(sscp != NULL);
16856 
16857         /* Reduce the count of the #commands currently in transport */
16858         un->un_ncmds_in_transport--;
16859         ASSERT(un->un_ncmds_in_transport >= 0);
16860 
16861         /* Increment counter to indicate that the callback routine is active */
16862         un->un_in_callback++;
16863 
16864         SD_UPDATE_KSTATS(un, kstat_runq_exit, bp);
16865 
16866 #ifdef  SDDEBUG
16867         if (bp == un->un_retry_bp) {
16868                 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sdintr: "
16869                     "un:0x%p: GOT retry_bp:0x%p un_ncmds_in_transport:%d\n",
16870                     un, un->un_retry_bp, un->un_ncmds_in_transport);
16871         }
16872 #endif
16873 
16874         /*
16875          * If pkt_reason is CMD_DEV_GONE, fail the command, and update the media
16876          * state if needed.
16877          */
16878         if (pktp->pkt_reason == CMD_DEV_GONE) {
16879                 /* Prevent multiple console messages for the same failure. */
16880                 if (un->un_last_pkt_reason != CMD_DEV_GONE) {
16881                         un->un_last_pkt_reason = CMD_DEV_GONE;
16882                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
16883                             "Command failed to complete...Device is gone\n");
16884                 }
16885                 if (un->un_mediastate != DKIO_DEV_GONE) {
16886                         un->un_mediastate = DKIO_DEV_GONE;
16887                         cv_broadcast(&un->un_state_cv);
16888                 }
16889                 /*
16890                  * If the command happens to be the REQUEST SENSE command,
16891                  * free up the rqs buf and fail the original command.
16892                  */
16893                 if (bp == un->un_rqs_bp) {
16894                         bp = sd_mark_rqs_idle(un, xp);
16895                 }
16896                 sd_return_failed_command(un, bp, EIO);
16897                 goto exit;
16898         }
16899 
16900         if (pktp->pkt_state & STATE_XARQ_DONE) {
16901                 SD_TRACE(SD_LOG_COMMON, un,
16902                     "sdintr: extra sense data received. pkt=%p\n", pktp);
16903         }
16904 
16905         /*
16906          * First see if the pkt has auto-request sense data with it....
16907          * Look at the packet state first so we don't take a performance
16908          * hit looking at the arq enabled flag unless absolutely necessary.
16909          */
16910         if ((pktp->pkt_state & STATE_ARQ_DONE) &&
16911             (un->un_f_arq_enabled == TRUE)) {
16912                 /*
16913                  * The HBA did an auto request sense for this command so check
16914                  * for FLAG_DIAGNOSE. If set this indicates a uscsi or internal
16915                  * driver command that should not be retried.
16916                  */
16917                 if ((pktp->pkt_flags & FLAG_DIAGNOSE) != 0) {
16918                         /*
16919                          * Save the relevant sense info into the xp for the
16920                          * original cmd.
16921                          */
16922                         struct scsi_arq_status *asp;
16923                         asp = (struct scsi_arq_status *)(pktp->pkt_scbp);
16924                         xp->xb_sense_status =
16925                             *((uchar_t *)(&(asp->sts_rqpkt_status)));
16926                         xp->xb_sense_state  = asp->sts_rqpkt_state;
16927                         xp->xb_sense_resid  = asp->sts_rqpkt_resid;
16928                         if (pktp->pkt_state & STATE_XARQ_DONE) {
16929                                 actual_len = MAX_SENSE_LENGTH -
16930                                     xp->xb_sense_resid;
16931                                 bcopy(&asp->sts_sensedata, xp->xb_sense_data,
16932                                     MAX_SENSE_LENGTH);
16933                         } else {
16934                                 if (xp->xb_sense_resid > SENSE_LENGTH) {
16935                                         actual_len = MAX_SENSE_LENGTH -
16936                                             xp->xb_sense_resid;
16937                                 } else {
16938                                         actual_len = SENSE_LENGTH -
16939                                             xp->xb_sense_resid;
16940                                 }
16941                                 if (xp->xb_pkt_flags & SD_XB_USCSICMD) {
16942                                         if ((((struct uscsi_cmd *)
16943                                             (xp->xb_pktinfo))->uscsi_rqlen) >
16944                                             actual_len) {
16945                                                 xp->xb_sense_resid =
16946                                                     (((struct uscsi_cmd *)
16947                                                     (xp->xb_pktinfo))->
16948                                                     uscsi_rqlen) - actual_len;
16949                                         } else {
16950                                                 xp->xb_sense_resid = 0;
16951                                         }
16952                                 }
16953                                 bcopy(&asp->sts_sensedata, xp->xb_sense_data,
16954                                     SENSE_LENGTH);
16955                         }
16956 
16957                         /* fail the command */
16958                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16959                             "sdintr: arq done and FLAG_DIAGNOSE set\n");
16960                         sd_return_failed_command(un, bp, EIO);
16961                         goto exit;
16962                 }
16963 
16964 #if (defined(__i386) || defined(__amd64))       /* DMAFREE for x86 only */
16965                 /*
16966                  * We want to either retry or fail this command, so free
16967                  * the DMA resources here.  If we retry the command then
16968                  * the DMA resources will be reallocated in sd_start_cmds().
16969                  * Note that when PKT_DMA_PARTIAL is used, this reallocation
16970                  * causes the *entire* transfer to start over again from the
16971                  * beginning of the request, even for PARTIAL chunks that
16972                  * have already transferred successfully.
16973                  */
16974                 if ((un->un_f_is_fibre == TRUE) &&
16975                     ((xp->xb_pkt_flags & SD_XB_USCSICMD) == 0) &&
16976                     ((pktp->pkt_flags & FLAG_SENSING) == 0))  {
16977                         scsi_dmafree(pktp);
16978                         xp->xb_pkt_flags |= SD_XB_DMA_FREED;
16979                 }
16980 #endif
16981 
16982                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16983                     "sdintr: arq done, sd_handle_auto_request_sense\n");
16984 
16985                 sd_handle_auto_request_sense(un, bp, xp, pktp);
16986                 goto exit;
16987         }
16988 
16989         /* Next see if this is the REQUEST SENSE pkt for the instance */
16990         if (pktp->pkt_flags & FLAG_SENSING)  {
16991                 /* This pktp is from the unit's REQUEST_SENSE command */
16992                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
16993                     "sdintr: sd_handle_request_sense\n");
16994                 sd_handle_request_sense(un, bp, xp, pktp);
16995                 goto exit;
16996         }
16997 
16998         /*
16999          * Check to see if the command successfully completed as requested;
17000          * this is the most common case (and also the hot performance path).
17001          *
17002          * Requirements for successful completion are:
17003          * pkt_reason is CMD_CMPLT and packet status is status good.
17004          * In addition:
17005          * - A residual of zero indicates successful completion no matter what
17006          *   the command is.
17007          * - If the residual is not zero and the command is not a read or
17008          *   write, then it's still defined as successful completion. In other
17009          *   words, if the command is a read or write the residual must be
17010          *   zero for successful completion.
17011          * - If the residual is not zero and the command is a read or
17012          *   write, and it's a USCSICMD, then it's still defined as
17013          *   successful completion.
17014          */
17015         if ((pktp->pkt_reason == CMD_CMPLT) &&
17016             (SD_GET_PKT_STATUS(pktp) == STATUS_GOOD)) {
17017 
17018                 /*
17019                  * Since this command is returned with a good status, we
17020                  * can reset the count for Sonoma failover.
17021                  */
17022                 un->un_sonoma_failure_count = 0;
17023 
17024                 /*
17025                  * Return all USCSI commands on good status
17026                  */
17027                 if (pktp->pkt_resid == 0) {
17028                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17029                             "sdintr: returning command for resid == 0\n");
17030                 } else if (((SD_GET_PKT_OPCODE(pktp) & 0x1F) != SCMD_READ) &&
17031                     ((SD_GET_PKT_OPCODE(pktp) & 0x1F) != SCMD_WRITE)) {
17032                         SD_UPDATE_B_RESID(bp, pktp);
17033                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17034                             "sdintr: returning command for resid != 0\n");
17035                 } else if (xp->xb_pkt_flags & SD_XB_USCSICMD) {
17036                         SD_UPDATE_B_RESID(bp, pktp);
17037                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17038                             "sdintr: returning uscsi command\n");
17039                 } else {
17040                         goto not_successful;
17041                 }
17042                 sd_return_command(un, bp);
17043 
17044                 /*
17045                  * Decrement counter to indicate that the callback routine
17046                  * is done.
17047                  */
17048                 un->un_in_callback--;
17049                 ASSERT(un->un_in_callback >= 0);
17050                 mutex_exit(SD_MUTEX(un));
17051 
17052                 return;
17053         }
17054 
17055 not_successful:
17056 
17057 #if (defined(__i386) || defined(__amd64))       /* DMAFREE for x86 only */
17058         /*
17059          * The following is based upon knowledge of the underlying transport
17060          * and its use of DMA resources.  This code should be removed when
17061          * PKT_DMA_PARTIAL support is taken out of the disk driver in favor
17062          * of the new PKT_CMD_BREAKUP protocol. See also sd_initpkt_for_buf()
17063          * and sd_start_cmds().
17064          *
17065          * Free any DMA resources associated with this command if there
17066          * is a chance it could be retried or enqueued for later retry.
17067          * If we keep the DMA binding then mpxio cannot reissue the
17068          * command on another path whenever a path failure occurs.
17069          *
17070          * Note that when PKT_DMA_PARTIAL is used, free/reallocation
17071          * causes the *entire* transfer to start over again from the
17072          * beginning of the request, even for PARTIAL chunks that
17073          * have already transferred successfully.
17074          *
17075          * This is only done for non-uscsi commands (and also skipped for the
17076          * driver's internal RQS command). Also just do this for Fibre Channel
17077          * devices as these are the only ones that support mpxio.
17078          */
17079         if ((un->un_f_is_fibre == TRUE) &&
17080             ((xp->xb_pkt_flags & SD_XB_USCSICMD) == 0) &&
17081             ((pktp->pkt_flags & FLAG_SENSING) == 0))  {
17082                 scsi_dmafree(pktp);
17083                 xp->xb_pkt_flags |= SD_XB_DMA_FREED;
17084         }
17085 #endif
17086 
17087         /*
17088          * The command did not successfully complete as requested so check
17089          * for FLAG_DIAGNOSE. If set this indicates a uscsi or internal
17090          * driver command that should not be retried so just return. If
17091          * FLAG_DIAGNOSE is not set the error will be processed below.
17092          */
17093         if ((pktp->pkt_flags & FLAG_DIAGNOSE) != 0) {
17094                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17095                     "sdintr: FLAG_DIAGNOSE: sd_return_failed_command\n");
17096                 /*
17097                  * Issue a request sense if a check condition caused the error
17098                  * (we handle the auto request sense case above), otherwise
17099                  * just fail the command.
17100                  */
17101                 if ((pktp->pkt_reason == CMD_CMPLT) &&
17102                     (SD_GET_PKT_STATUS(pktp) == STATUS_CHECK)) {
17103                         sd_send_request_sense_command(un, bp, pktp);
17104                 } else {
17105                         sd_return_failed_command(un, bp, EIO);
17106                 }
17107                 goto exit;
17108         }
17109 
17110         /*
17111          * The command did not successfully complete as requested so process
17112          * the error, retry, and/or attempt recovery.
17113          */
17114         switch (pktp->pkt_reason) {
17115         case CMD_CMPLT:
17116                 switch (SD_GET_PKT_STATUS(pktp)) {
17117                 case STATUS_GOOD:
17118                         /*
17119                          * The command completed successfully with a non-zero
17120                          * residual
17121                          */
17122                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17123                             "sdintr: STATUS_GOOD \n");
17124                         sd_pkt_status_good(un, bp, xp, pktp);
17125                         break;
17126 
17127                 case STATUS_CHECK:
17128                 case STATUS_TERMINATED:
17129                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17130                             "sdintr: STATUS_TERMINATED | STATUS_CHECK\n");
17131                         sd_pkt_status_check_condition(un, bp, xp, pktp);
17132                         break;
17133 
17134                 case STATUS_BUSY:
17135                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17136                             "sdintr: STATUS_BUSY\n");
17137                         sd_pkt_status_busy(un, bp, xp, pktp);
17138                         break;
17139 
17140                 case STATUS_RESERVATION_CONFLICT:
17141                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17142                             "sdintr: STATUS_RESERVATION_CONFLICT\n");
17143                         sd_pkt_status_reservation_conflict(un, bp, xp, pktp);
17144                         break;
17145 
17146                 case STATUS_QFULL:
17147                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17148                             "sdintr: STATUS_QFULL\n");
17149                         sd_pkt_status_qfull(un, bp, xp, pktp);
17150                         break;
17151 
17152                 case STATUS_MET:
17153                 case STATUS_INTERMEDIATE:
17154                 case STATUS_SCSI2:
17155                 case STATUS_INTERMEDIATE_MET:
17156                 case STATUS_ACA_ACTIVE:
17157                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17158                             "Unexpected SCSI status received: 0x%x\n",
17159                             SD_GET_PKT_STATUS(pktp));
17160                         /*
17161                          * Mark the ssc_flags when detected invalid status
17162                          * code for non-USCSI command.
17163                          */
17164                         if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17165                                 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_STATUS,
17166                                     0, "stat-code");
17167                         }
17168                         sd_return_failed_command(un, bp, EIO);
17169                         break;
17170 
17171                 default:
17172                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17173                             "Invalid SCSI status received: 0x%x\n",
17174                             SD_GET_PKT_STATUS(pktp));
17175                         if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17176                                 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_STATUS,
17177                                     0, "stat-code");
17178                         }
17179                         sd_return_failed_command(un, bp, EIO);
17180                         break;
17181 
17182                 }
17183                 break;
17184 
17185         case CMD_INCOMPLETE:
17186                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17187                     "sdintr:  CMD_INCOMPLETE\n");
17188                 sd_pkt_reason_cmd_incomplete(un, bp, xp, pktp);
17189                 break;
17190         case CMD_TRAN_ERR:
17191                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17192                     "sdintr: CMD_TRAN_ERR\n");
17193                 sd_pkt_reason_cmd_tran_err(un, bp, xp, pktp);
17194                 break;
17195         case CMD_RESET:
17196                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17197                     "sdintr: CMD_RESET \n");
17198                 sd_pkt_reason_cmd_reset(un, bp, xp, pktp);
17199                 break;
17200         case CMD_ABORTED:
17201                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17202                     "sdintr: CMD_ABORTED \n");
17203                 sd_pkt_reason_cmd_aborted(un, bp, xp, pktp);
17204                 break;
17205         case CMD_TIMEOUT:
17206                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17207                     "sdintr: CMD_TIMEOUT\n");
17208                 sd_pkt_reason_cmd_timeout(un, bp, xp, pktp);
17209                 break;
17210         case CMD_UNX_BUS_FREE:
17211                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17212                     "sdintr: CMD_UNX_BUS_FREE \n");
17213                 sd_pkt_reason_cmd_unx_bus_free(un, bp, xp, pktp);
17214                 break;
17215         case CMD_TAG_REJECT:
17216                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17217                     "sdintr: CMD_TAG_REJECT\n");
17218                 sd_pkt_reason_cmd_tag_reject(un, bp, xp, pktp);
17219                 break;
17220         default:
17221                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
17222                     "sdintr: default\n");
17223                 /*
17224                  * Mark the ssc_flags for detecting invliad pkt_reason.
17225                  */
17226                 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17227                         sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_PKT_REASON,
17228                             0, "pkt-reason");
17229                 }
17230                 sd_pkt_reason_default(un, bp, xp, pktp);
17231                 break;
17232         }
17233 
17234 exit:
17235         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdintr: exit\n");
17236 
17237         /* Decrement counter to indicate that the callback routine is done. */
17238         un->un_in_callback--;
17239         ASSERT(un->un_in_callback >= 0);
17240 
17241         /*
17242          * At this point, the pkt has been dispatched, ie, it is either
17243          * being re-tried or has been returned to its caller and should
17244          * not be referenced.
17245          */
17246 
17247         mutex_exit(SD_MUTEX(un));
17248 }
17249 
17250 
17251 /*
17252  *    Function: sd_print_incomplete_msg
17253  *
17254  * Description: Prints the error message for a CMD_INCOMPLETE error.
17255  *
17256  *   Arguments: un - ptr to associated softstate for the device.
17257  *              bp - ptr to the buf(9S) for the command.
17258  *              arg - message string ptr
17259  *              code - SD_DELAYED_RETRY_ISSUED, SD_IMMEDIATE_RETRY_ISSUED,
17260  *                      or SD_NO_RETRY_ISSUED.
17261  *
17262  *     Context: May be called under interrupt context
17263  */
17264 
17265 static void
17266 sd_print_incomplete_msg(struct sd_lun *un, struct buf *bp, void *arg, int code)
17267 {
17268         struct scsi_pkt *pktp;
17269         char    *msgp;
17270         char    *cmdp = arg;
17271 
17272         ASSERT(un != NULL);
17273         ASSERT(mutex_owned(SD_MUTEX(un)));
17274         ASSERT(bp != NULL);
17275         ASSERT(arg != NULL);
17276         pktp = SD_GET_PKTP(bp);
17277         ASSERT(pktp != NULL);
17278 
17279         switch (code) {
17280         case SD_DELAYED_RETRY_ISSUED:
17281         case SD_IMMEDIATE_RETRY_ISSUED:
17282                 msgp = "retrying";
17283                 break;
17284         case SD_NO_RETRY_ISSUED:
17285         default:
17286                 msgp = "giving up";
17287                 break;
17288         }
17289 
17290         if ((pktp->pkt_flags & FLAG_SILENT) == 0) {
17291                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17292                     "incomplete %s- %s\n", cmdp, msgp);
17293         }
17294 }
17295 
17296 
17297 
17298 /*
17299  *    Function: sd_pkt_status_good
17300  *
17301  * Description: Processing for a STATUS_GOOD code in pkt_status.
17302  *
17303  *     Context: May be called under interrupt context
17304  */
17305 
17306 static void
17307 sd_pkt_status_good(struct sd_lun *un, struct buf *bp,
17308         struct sd_xbuf *xp, struct scsi_pkt *pktp)
17309 {
17310         char    *cmdp;
17311 
17312         ASSERT(un != NULL);
17313         ASSERT(mutex_owned(SD_MUTEX(un)));
17314         ASSERT(bp != NULL);
17315         ASSERT(xp != NULL);
17316         ASSERT(pktp != NULL);
17317         ASSERT(pktp->pkt_reason == CMD_CMPLT);
17318         ASSERT(SD_GET_PKT_STATUS(pktp) == STATUS_GOOD);
17319         ASSERT(pktp->pkt_resid != 0);
17320 
17321         SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_good: entry\n");
17322 
17323         SD_UPDATE_ERRSTATS(un, sd_harderrs);
17324         switch (SD_GET_PKT_OPCODE(pktp) & 0x1F) {
17325         case SCMD_READ:
17326                 cmdp = "read";
17327                 break;
17328         case SCMD_WRITE:
17329                 cmdp = "write";
17330                 break;
17331         default:
17332                 SD_UPDATE_B_RESID(bp, pktp);
17333                 sd_return_command(un, bp);
17334                 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_good: exit\n");
17335                 return;
17336         }
17337 
17338         /*
17339          * See if we can retry the read/write, preferrably immediately.
17340          * If retries are exhaused, then sd_retry_command() will update
17341          * the b_resid count.
17342          */
17343         sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_incomplete_msg,
17344             cmdp, EIO, (clock_t)0, NULL);
17345 
17346         SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_good: exit\n");
17347 }
17348 
17349 
17350 
17351 
17352 
17353 /*
17354  *    Function: sd_handle_request_sense
17355  *
17356  * Description: Processing for non-auto Request Sense command.
17357  *
17358  *   Arguments: un - ptr to associated softstate
17359  *              sense_bp - ptr to buf(9S) for the RQS command
17360  *              sense_xp - ptr to the sd_xbuf for the RQS command
17361  *              sense_pktp - ptr to the scsi_pkt(9S) for the RQS command
17362  *
17363  *     Context: May be called under interrupt context
17364  */
17365 
17366 static void
17367 sd_handle_request_sense(struct sd_lun *un, struct buf *sense_bp,
17368         struct sd_xbuf *sense_xp, struct scsi_pkt *sense_pktp)
17369 {
17370         struct buf      *cmd_bp;        /* buf for the original command */
17371         struct sd_xbuf  *cmd_xp;        /* sd_xbuf for the original command */
17372         struct scsi_pkt *cmd_pktp;      /* pkt for the original command */
17373         size_t          actual_len;     /* actual sense data length */
17374 
17375         ASSERT(un != NULL);
17376         ASSERT(mutex_owned(SD_MUTEX(un)));
17377         ASSERT(sense_bp != NULL);
17378         ASSERT(sense_xp != NULL);
17379         ASSERT(sense_pktp != NULL);
17380 
17381         /*
17382          * Note the sense_bp, sense_xp, and sense_pktp here are for the
17383          * RQS command and not the original command.
17384          */
17385         ASSERT(sense_pktp == un->un_rqs_pktp);
17386         ASSERT(sense_bp   == un->un_rqs_bp);
17387         ASSERT((sense_pktp->pkt_flags & (FLAG_SENSING | FLAG_HEAD)) ==
17388             (FLAG_SENSING | FLAG_HEAD));
17389         ASSERT((((SD_GET_XBUF(sense_xp->xb_sense_bp))->xb_pktp->pkt_flags) &
17390             FLAG_SENSING) == FLAG_SENSING);
17391 
17392         /* These are the bp, xp, and pktp for the original command */
17393         cmd_bp = sense_xp->xb_sense_bp;
17394         cmd_xp = SD_GET_XBUF(cmd_bp);
17395         cmd_pktp = SD_GET_PKTP(cmd_bp);
17396 
17397         if (sense_pktp->pkt_reason != CMD_CMPLT) {
17398                 /*
17399                  * The REQUEST SENSE command failed.  Release the REQUEST
17400                  * SENSE command for re-use, get back the bp for the original
17401                  * command, and attempt to re-try the original command if
17402                  * FLAG_DIAGNOSE is not set in the original packet.
17403                  */
17404                 SD_UPDATE_ERRSTATS(un, sd_harderrs);
17405                 if ((cmd_pktp->pkt_flags & FLAG_DIAGNOSE) == 0) {
17406                         cmd_bp = sd_mark_rqs_idle(un, sense_xp);
17407                         sd_retry_command(un, cmd_bp, SD_RETRIES_STANDARD,
17408                             NULL, NULL, EIO, (clock_t)0, NULL);
17409                         return;
17410                 }
17411         }
17412 
17413         /*
17414          * Save the relevant sense info into the xp for the original cmd.
17415          *
17416          * Note: if the request sense failed the state info will be zero
17417          * as set in sd_mark_rqs_busy()
17418          */
17419         cmd_xp->xb_sense_status = *(sense_pktp->pkt_scbp);
17420         cmd_xp->xb_sense_state  = sense_pktp->pkt_state;
17421         actual_len = MAX_SENSE_LENGTH - sense_pktp->pkt_resid;
17422         if ((cmd_xp->xb_pkt_flags & SD_XB_USCSICMD) &&
17423             (((struct uscsi_cmd *)cmd_xp->xb_pktinfo)->uscsi_rqlen >
17424             SENSE_LENGTH)) {
17425                 bcopy(sense_bp->b_un.b_addr, cmd_xp->xb_sense_data,
17426                     MAX_SENSE_LENGTH);
17427                 cmd_xp->xb_sense_resid = sense_pktp->pkt_resid;
17428         } else {
17429                 bcopy(sense_bp->b_un.b_addr, cmd_xp->xb_sense_data,
17430                     SENSE_LENGTH);
17431                 if (actual_len < SENSE_LENGTH) {
17432                         cmd_xp->xb_sense_resid = SENSE_LENGTH - actual_len;
17433                 } else {
17434                         cmd_xp->xb_sense_resid = 0;
17435                 }
17436         }
17437 
17438         /*
17439          *  Free up the RQS command....
17440          *  NOTE:
17441          *      Must do this BEFORE calling sd_validate_sense_data!
17442          *      sd_validate_sense_data may return the original command in
17443          *      which case the pkt will be freed and the flags can no
17444          *      longer be touched.
17445          *      SD_MUTEX is held through this process until the command
17446          *      is dispatched based upon the sense data, so there are
17447          *      no race conditions.
17448          */
17449         (void) sd_mark_rqs_idle(un, sense_xp);
17450 
17451         /*
17452          * For a retryable command see if we have valid sense data, if so then
17453          * turn it over to sd_decode_sense() to figure out the right course of
17454          * action. Just fail a non-retryable command.
17455          */
17456         if ((cmd_pktp->pkt_flags & FLAG_DIAGNOSE) == 0) {
17457                 if (sd_validate_sense_data(un, cmd_bp, cmd_xp, actual_len) ==
17458                     SD_SENSE_DATA_IS_VALID) {
17459                         sd_decode_sense(un, cmd_bp, cmd_xp, cmd_pktp);
17460                 }
17461         } else {
17462                 SD_DUMP_MEMORY(un, SD_LOG_IO_CORE, "Failed CDB",
17463                     (uchar_t *)cmd_pktp->pkt_cdbp, CDB_SIZE, SD_LOG_HEX);
17464                 SD_DUMP_MEMORY(un, SD_LOG_IO_CORE, "Sense Data",
17465                     (uchar_t *)cmd_xp->xb_sense_data, SENSE_LENGTH, SD_LOG_HEX);
17466                 sd_return_failed_command(un, cmd_bp, EIO);
17467         }
17468 }
17469 
17470 
17471 
17472 
17473 /*
17474  *    Function: sd_handle_auto_request_sense
17475  *
17476  * Description: Processing for auto-request sense information.
17477  *
17478  *   Arguments: un - ptr to associated softstate
17479  *              bp - ptr to buf(9S) for the command
17480  *              xp - ptr to the sd_xbuf for the command
17481  *              pktp - ptr to the scsi_pkt(9S) for the command
17482  *
17483  *     Context: May be called under interrupt context
17484  */
17485 
17486 static void
17487 sd_handle_auto_request_sense(struct sd_lun *un, struct buf *bp,
17488         struct sd_xbuf *xp, struct scsi_pkt *pktp)
17489 {
17490         struct scsi_arq_status *asp;
17491         size_t actual_len;
17492 
17493         ASSERT(un != NULL);
17494         ASSERT(mutex_owned(SD_MUTEX(un)));
17495         ASSERT(bp != NULL);
17496         ASSERT(xp != NULL);
17497         ASSERT(pktp != NULL);
17498         ASSERT(pktp != un->un_rqs_pktp);
17499         ASSERT(bp   != un->un_rqs_bp);
17500 
17501         /*
17502          * For auto-request sense, we get a scsi_arq_status back from
17503          * the HBA, with the sense data in the sts_sensedata member.
17504          * The pkt_scbp of the packet points to this scsi_arq_status.
17505          */
17506         asp = (struct scsi_arq_status *)(pktp->pkt_scbp);
17507 
17508         if (asp->sts_rqpkt_reason != CMD_CMPLT) {
17509                 /*
17510                  * The auto REQUEST SENSE failed; see if we can re-try
17511                  * the original command.
17512                  */
17513                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17514                     "auto request sense failed (reason=%s)\n",
17515                     scsi_rname(asp->sts_rqpkt_reason));
17516 
17517                 sd_reset_target(un, pktp);
17518 
17519                 sd_retry_command(un, bp, SD_RETRIES_STANDARD,
17520                     NULL, NULL, EIO, (clock_t)0, NULL);
17521                 return;
17522         }
17523 
17524         /* Save the relevant sense info into the xp for the original cmd. */
17525         xp->xb_sense_status = *((uchar_t *)(&(asp->sts_rqpkt_status)));
17526         xp->xb_sense_state  = asp->sts_rqpkt_state;
17527         xp->xb_sense_resid  = asp->sts_rqpkt_resid;
17528         if (xp->xb_sense_state & STATE_XARQ_DONE) {
17529                 actual_len = MAX_SENSE_LENGTH - xp->xb_sense_resid;
17530                 bcopy(&asp->sts_sensedata, xp->xb_sense_data,
17531                     MAX_SENSE_LENGTH);
17532         } else {
17533                 if (xp->xb_sense_resid > SENSE_LENGTH) {
17534                         actual_len = MAX_SENSE_LENGTH - xp->xb_sense_resid;
17535                 } else {
17536                         actual_len = SENSE_LENGTH - xp->xb_sense_resid;
17537                 }
17538                 if (xp->xb_pkt_flags & SD_XB_USCSICMD) {
17539                         if ((((struct uscsi_cmd *)
17540                             (xp->xb_pktinfo))->uscsi_rqlen) > actual_len) {
17541                                 xp->xb_sense_resid = (((struct uscsi_cmd *)
17542                                     (xp->xb_pktinfo))->uscsi_rqlen) -
17543                                     actual_len;
17544                         } else {
17545                                 xp->xb_sense_resid = 0;
17546                         }
17547                 }
17548                 bcopy(&asp->sts_sensedata, xp->xb_sense_data, SENSE_LENGTH);
17549         }
17550 
17551         /*
17552          * See if we have valid sense data, if so then turn it over to
17553          * sd_decode_sense() to figure out the right course of action.
17554          */
17555         if (sd_validate_sense_data(un, bp, xp, actual_len) ==
17556             SD_SENSE_DATA_IS_VALID) {
17557                 sd_decode_sense(un, bp, xp, pktp);
17558         }
17559 }
17560 
17561 
17562 /*
17563  *    Function: sd_print_sense_failed_msg
17564  *
17565  * Description: Print log message when RQS has failed.
17566  *
17567  *   Arguments: un - ptr to associated softstate
17568  *              bp - ptr to buf(9S) for the command
17569  *              arg - generic message string ptr
17570  *              code - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED,
17571  *                      or SD_NO_RETRY_ISSUED
17572  *
17573  *     Context: May be called from interrupt context
17574  */
17575 
17576 static void
17577 sd_print_sense_failed_msg(struct sd_lun *un, struct buf *bp, void *arg,
17578         int code)
17579 {
17580         char    *msgp = arg;
17581 
17582         ASSERT(un != NULL);
17583         ASSERT(mutex_owned(SD_MUTEX(un)));
17584         ASSERT(bp != NULL);
17585 
17586         if ((code == SD_NO_RETRY_ISSUED) && (msgp != NULL)) {
17587                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, msgp);
17588         }
17589 }
17590 
17591 
17592 /*
17593  *    Function: sd_validate_sense_data
17594  *
17595  * Description: Check the given sense data for validity.
17596  *              If the sense data is not valid, the command will
17597  *              be either failed or retried!
17598  *
17599  * Return Code: SD_SENSE_DATA_IS_INVALID
17600  *              SD_SENSE_DATA_IS_VALID
17601  *
17602  *     Context: May be called from interrupt context
17603  */
17604 
17605 static int
17606 sd_validate_sense_data(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
17607         size_t actual_len)
17608 {
17609         struct scsi_extended_sense *esp;
17610         struct  scsi_pkt *pktp;
17611         char    *msgp = NULL;
17612         sd_ssc_t *sscp;
17613 
17614         ASSERT(un != NULL);
17615         ASSERT(mutex_owned(SD_MUTEX(un)));
17616         ASSERT(bp != NULL);
17617         ASSERT(bp != un->un_rqs_bp);
17618         ASSERT(xp != NULL);
17619         ASSERT(un->un_fm_private != NULL);
17620 
17621         pktp = SD_GET_PKTP(bp);
17622         ASSERT(pktp != NULL);
17623 
17624         sscp = &((struct sd_fm_internal *)(un->un_fm_private))->fm_ssc;
17625         ASSERT(sscp != NULL);
17626 
17627         /*
17628          * Check the status of the RQS command (auto or manual).
17629          */
17630         switch (xp->xb_sense_status & STATUS_MASK) {
17631         case STATUS_GOOD:
17632                 break;
17633 
17634         case STATUS_RESERVATION_CONFLICT:
17635                 sd_pkt_status_reservation_conflict(un, bp, xp, pktp);
17636                 return (SD_SENSE_DATA_IS_INVALID);
17637 
17638         case STATUS_BUSY:
17639                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17640                     "Busy Status on REQUEST SENSE\n");
17641                 sd_retry_command(un, bp, SD_RETRIES_BUSY, NULL,
17642                     NULL, EIO, un->un_busy_timeout / 500, kstat_waitq_enter);
17643                 return (SD_SENSE_DATA_IS_INVALID);
17644 
17645         case STATUS_QFULL:
17646                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
17647                     "QFULL Status on REQUEST SENSE\n");
17648                 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL,
17649                     NULL, EIO, un->un_busy_timeout / 500, kstat_waitq_enter);
17650                 return (SD_SENSE_DATA_IS_INVALID);
17651 
17652         case STATUS_CHECK:
17653         case STATUS_TERMINATED:
17654                 msgp = "Check Condition on REQUEST SENSE\n";
17655                 goto sense_failed;
17656 
17657         default:
17658                 msgp = "Not STATUS_GOOD on REQUEST_SENSE\n";
17659                 goto sense_failed;
17660         }
17661 
17662         /*
17663          * See if we got the minimum required amount of sense data.
17664          * Note: We are assuming the returned sense data is SENSE_LENGTH bytes
17665          * or less.
17666          */
17667         if (((xp->xb_sense_state & STATE_XFERRED_DATA) == 0) ||
17668             (actual_len == 0)) {
17669                 msgp = "Request Sense couldn't get sense data\n";
17670                 goto sense_failed;
17671         }
17672 
17673         if (actual_len < SUN_MIN_SENSE_LENGTH) {
17674                 msgp = "Not enough sense information\n";
17675                 /* Mark the ssc_flags for detecting invalid sense data */
17676                 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17677                         sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_SENSE, 0,
17678                             "sense-data");
17679                 }
17680                 goto sense_failed;
17681         }
17682 
17683         /*
17684          * We require the extended sense data
17685          */
17686         esp = (struct scsi_extended_sense *)xp->xb_sense_data;
17687         if (esp->es_class != CLASS_EXTENDED_SENSE) {
17688                 if ((pktp->pkt_flags & FLAG_SILENT) == 0) {
17689                         static char tmp[8];
17690                         static char buf[148];
17691                         char *p = (char *)(xp->xb_sense_data);
17692                         int i;
17693 
17694                         mutex_enter(&sd_sense_mutex);
17695                         (void) strcpy(buf, "undecodable sense information:");
17696                         for (i = 0; i < actual_len; i++) {
17697                                 (void) sprintf(tmp, " 0x%x", *(p++)&0xff);
17698                                 (void) strcpy(&buf[strlen(buf)], tmp);
17699                         }
17700                         i = strlen(buf);
17701                         (void) strcpy(&buf[i], "-(assumed fatal)\n");
17702 
17703                         if (SD_FM_LOG(un) == SD_FM_LOG_NSUP) {
17704                                 scsi_log(SD_DEVINFO(un), sd_label,
17705                                     CE_WARN, buf);
17706                         }
17707                         mutex_exit(&sd_sense_mutex);
17708                 }
17709 
17710                 /* Mark the ssc_flags for detecting invalid sense data */
17711                 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17712                         sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_SENSE, 0,
17713                             "sense-data");
17714                 }
17715 
17716                 /* Note: Legacy behavior, fail the command with no retry */
17717                 sd_return_failed_command(un, bp, EIO);
17718                 return (SD_SENSE_DATA_IS_INVALID);
17719         }
17720 
17721         /*
17722          * Check that es_code is valid (es_class concatenated with es_code
17723          * make up the "response code" field.  es_class will always be 7, so
17724          * make sure es_code is 0, 1, 2, 3 or 0xf.  es_code will indicate the
17725          * format.
17726          */
17727         if ((esp->es_code != CODE_FMT_FIXED_CURRENT) &&
17728             (esp->es_code != CODE_FMT_FIXED_DEFERRED) &&
17729             (esp->es_code != CODE_FMT_DESCR_CURRENT) &&
17730             (esp->es_code != CODE_FMT_DESCR_DEFERRED) &&
17731             (esp->es_code != CODE_FMT_VENDOR_SPECIFIC)) {
17732                 /* Mark the ssc_flags for detecting invalid sense data */
17733                 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) {
17734                         sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_SENSE, 0,
17735                             "sense-data");
17736                 }
17737                 goto sense_failed;
17738         }
17739 
17740         return (SD_SENSE_DATA_IS_VALID);
17741 
17742 sense_failed:
17743         /*
17744          * If the request sense failed (for whatever reason), attempt
17745          * to retry the original command.
17746          */
17747 #if defined(__i386) || defined(__amd64)
17748         /*
17749          * SD_RETRY_DELAY is conditionally compile (#if fibre) in
17750          * sddef.h for Sparc platform, and x86 uses 1 binary
17751          * for both SCSI/FC.
17752          * The SD_RETRY_DELAY value need to be adjusted here
17753          * when SD_RETRY_DELAY change in sddef.h
17754          */
17755         sd_retry_command(un, bp, SD_RETRIES_STANDARD,
17756             sd_print_sense_failed_msg, msgp, EIO,
17757             un->un_f_is_fibre?drv_usectohz(100000):(clock_t)0, NULL);
17758 #else
17759         sd_retry_command(un, bp, SD_RETRIES_STANDARD,
17760             sd_print_sense_failed_msg, msgp, EIO, SD_RETRY_DELAY, NULL);
17761 #endif
17762 
17763         return (SD_SENSE_DATA_IS_INVALID);
17764 }
17765 
17766 /*
17767  *    Function: sd_decode_sense
17768  *
17769  * Description: Take recovery action(s) when SCSI Sense Data is received.
17770  *
17771  *     Context: Interrupt context.
17772  */
17773 
17774 static void
17775 sd_decode_sense(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
17776         struct scsi_pkt *pktp)
17777 {
17778         uint8_t sense_key;
17779 
17780         ASSERT(un != NULL);
17781         ASSERT(mutex_owned(SD_MUTEX(un)));
17782         ASSERT(bp != NULL);
17783         ASSERT(bp != un->un_rqs_bp);
17784         ASSERT(xp != NULL);
17785         ASSERT(pktp != NULL);
17786 
17787         sense_key = scsi_sense_key(xp->xb_sense_data);
17788 
17789         switch (sense_key) {
17790         case KEY_NO_SENSE:
17791                 sd_sense_key_no_sense(un, bp, xp, pktp);
17792                 break;
17793         case KEY_RECOVERABLE_ERROR:
17794                 sd_sense_key_recoverable_error(un, xp->xb_sense_data,
17795                     bp, xp, pktp);
17796                 break;
17797         case KEY_NOT_READY:
17798                 sd_sense_key_not_ready(un, xp->xb_sense_data,
17799                     bp, xp, pktp);
17800                 break;
17801         case KEY_MEDIUM_ERROR:
17802         case KEY_HARDWARE_ERROR:
17803                 sd_sense_key_medium_or_hardware_error(un,
17804                     xp->xb_sense_data, bp, xp, pktp);
17805                 break;
17806         case KEY_ILLEGAL_REQUEST:
17807                 sd_sense_key_illegal_request(un, bp, xp, pktp);
17808                 break;
17809         case KEY_UNIT_ATTENTION:
17810                 sd_sense_key_unit_attention(un, xp->xb_sense_data,
17811                     bp, xp, pktp);
17812                 break;
17813         case KEY_WRITE_PROTECT:
17814         case KEY_VOLUME_OVERFLOW:
17815         case KEY_MISCOMPARE:
17816                 sd_sense_key_fail_command(un, bp, xp, pktp);
17817                 break;
17818         case KEY_BLANK_CHECK:
17819                 sd_sense_key_blank_check(un, bp, xp, pktp);
17820                 break;
17821         case KEY_ABORTED_COMMAND:
17822                 sd_sense_key_aborted_command(un, bp, xp, pktp);
17823                 break;
17824         case KEY_VENDOR_UNIQUE:
17825         case KEY_COPY_ABORTED:
17826         case KEY_EQUAL:
17827         case KEY_RESERVED:
17828         default:
17829                 sd_sense_key_default(un, xp->xb_sense_data,
17830                     bp, xp, pktp);
17831                 break;
17832         }
17833 }
17834 
17835 
17836 /*
17837  *    Function: sd_dump_memory
17838  *
17839  * Description: Debug logging routine to print the contents of a user provided
17840  *              buffer. The output of the buffer is broken up into 256 byte
17841  *              segments due to a size constraint of the scsi_log.
17842  *              implementation.
17843  *
17844  *   Arguments: un - ptr to softstate
17845  *              comp - component mask
17846  *              title - "title" string to preceed data when printed
17847  *              data - ptr to data block to be printed
17848  *              len - size of data block to be printed
17849  *              fmt - SD_LOG_HEX (use 0x%02x format) or SD_LOG_CHAR (use %c)
17850  *
17851  *     Context: May be called from interrupt context
17852  */
17853 
17854 #define SD_DUMP_MEMORY_BUF_SIZE 256
17855 
17856 static char *sd_dump_format_string[] = {
17857                 " 0x%02x",
17858                 " %c"
17859 };
17860 
17861 static void
17862 sd_dump_memory(struct sd_lun *un, uint_t comp, char *title, uchar_t *data,
17863     int len, int fmt)
17864 {
17865         int     i, j;
17866         int     avail_count;
17867         int     start_offset;
17868         int     end_offset;
17869         size_t  entry_len;
17870         char    *bufp;
17871         char    *local_buf;
17872         char    *format_string;
17873 
17874         ASSERT((fmt == SD_LOG_HEX) || (fmt == SD_LOG_CHAR));
17875 
17876         /*
17877          * In the debug version of the driver, this function is called from a
17878          * number of places which are NOPs in the release driver.
17879          * The debug driver therefore has additional methods of filtering
17880          * debug output.
17881          */
17882 #ifdef SDDEBUG
17883         /*
17884          * In the debug version of the driver we can reduce the amount of debug
17885          * messages by setting sd_error_level to something other than
17886          * SCSI_ERR_ALL and clearing bits in sd_level_mask and
17887          * sd_component_mask.
17888          */
17889         if (((sd_level_mask & (SD_LOGMASK_DUMP_MEM | SD_LOGMASK_DIAG)) == 0) ||
17890             (sd_error_level != SCSI_ERR_ALL)) {
17891                 return;
17892         }
17893         if (((sd_component_mask & comp) == 0) ||
17894             (sd_error_level != SCSI_ERR_ALL)) {
17895                 return;
17896         }
17897 #else
17898         if (sd_error_level != SCSI_ERR_ALL) {
17899                 return;
17900         }
17901 #endif
17902 
17903         local_buf = kmem_zalloc(SD_DUMP_MEMORY_BUF_SIZE, KM_SLEEP);
17904         bufp = local_buf;
17905         /*
17906          * Available length is the length of local_buf[], minus the
17907          * length of the title string, minus one for the ":", minus
17908          * one for the newline, minus one for the NULL terminator.
17909          * This gives the #bytes available for holding the printed
17910          * values from the given data buffer.
17911          */
17912         if (fmt == SD_LOG_HEX) {
17913                 format_string = sd_dump_format_string[0];
17914         } else /* SD_LOG_CHAR */ {
17915                 format_string = sd_dump_format_string[1];
17916         }
17917         /*
17918          * Available count is the number of elements from the given
17919          * data buffer that we can fit into the available length.
17920          * This is based upon the size of the format string used.
17921          * Make one entry and find it's size.
17922          */
17923         (void) sprintf(bufp, format_string, data[0]);
17924         entry_len = strlen(bufp);
17925         avail_count = (SD_DUMP_MEMORY_BUF_SIZE - strlen(title) - 3) / entry_len;
17926 
17927         j = 0;
17928         while (j < len) {
17929                 bufp = local_buf;
17930                 bzero(bufp, SD_DUMP_MEMORY_BUF_SIZE);
17931                 start_offset = j;
17932 
17933                 end_offset = start_offset + avail_count;
17934 
17935                 (void) sprintf(bufp, "%s:", title);
17936                 bufp += strlen(bufp);
17937                 for (i = start_offset; ((i < end_offset) && (j < len));
17938                     i++, j++) {
17939                         (void) sprintf(bufp, format_string, data[i]);
17940                         bufp += entry_len;
17941                 }
17942                 (void) sprintf(bufp, "\n");
17943 
17944                 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE, "%s", local_buf);
17945         }
17946         kmem_free(local_buf, SD_DUMP_MEMORY_BUF_SIZE);
17947 }
17948 
17949 /*
17950  *    Function: sd_print_sense_msg
17951  *
17952  * Description: Log a message based upon the given sense data.
17953  *
17954  *   Arguments: un - ptr to associated softstate
17955  *              bp - ptr to buf(9S) for the command
17956  *              arg - ptr to associate sd_sense_info struct
17957  *              code - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED,
17958  *                      or SD_NO_RETRY_ISSUED
17959  *
17960  *     Context: May be called from interrupt context
17961  */
17962 
17963 static void
17964 sd_print_sense_msg(struct sd_lun *un, struct buf *bp, void *arg, int code)
17965 {
17966         struct sd_xbuf  *xp;
17967         struct scsi_pkt *pktp;
17968         uint8_t *sensep;
17969         daddr_t request_blkno;
17970         diskaddr_t err_blkno;
17971         int severity;
17972         int pfa_flag;
17973         extern struct scsi_key_strings scsi_cmds[];
17974 
17975         ASSERT(un != NULL);
17976         ASSERT(mutex_owned(SD_MUTEX(un)));
17977         ASSERT(bp != NULL);
17978         xp = SD_GET_XBUF(bp);
17979         ASSERT(xp != NULL);
17980         pktp = SD_GET_PKTP(bp);
17981         ASSERT(pktp != NULL);
17982         ASSERT(arg != NULL);
17983 
17984         severity = ((struct sd_sense_info *)(arg))->ssi_severity;
17985         pfa_flag = ((struct sd_sense_info *)(arg))->ssi_pfa_flag;
17986 
17987         if ((code == SD_DELAYED_RETRY_ISSUED) ||
17988             (code == SD_IMMEDIATE_RETRY_ISSUED)) {
17989                 severity = SCSI_ERR_RETRYABLE;
17990         }
17991 
17992         /* Use absolute block number for the request block number */
17993         request_blkno = xp->xb_blkno;
17994 
17995         /*
17996          * Now try to get the error block number from the sense data
17997          */
17998         sensep = xp->xb_sense_data;
17999 
18000         if (scsi_sense_info_uint64(sensep, SENSE_LENGTH,
18001             (uint64_t *)&err_blkno)) {
18002                 /*
18003                  * We retrieved the error block number from the information
18004                  * portion of the sense data.
18005                  *
18006                  * For USCSI commands we are better off using the error
18007                  * block no. as the requested block no. (This is the best
18008                  * we can estimate.)
18009                  */
18010                 if ((SD_IS_BUFIO(xp) == FALSE) &&
18011                     ((pktp->pkt_flags & FLAG_SILENT) == 0)) {
18012                         request_blkno = err_blkno;
18013                 }
18014         } else {
18015                 /*
18016                  * Without the es_valid bit set (for fixed format) or an
18017                  * information descriptor (for descriptor format) we cannot
18018                  * be certain of the error blkno, so just use the
18019                  * request_blkno.
18020                  */
18021                 err_blkno = (diskaddr_t)request_blkno;
18022         }
18023 
18024         /*
18025          * The following will log the buffer contents for the release driver
18026          * if the SD_LOGMASK_DIAG bit of sd_level_mask is set, or the error
18027          * level is set to verbose.
18028          */
18029         sd_dump_memory(un, SD_LOG_IO, "Failed CDB",
18030             (uchar_t *)pktp->pkt_cdbp, CDB_SIZE, SD_LOG_HEX);
18031         sd_dump_memory(un, SD_LOG_IO, "Sense Data",
18032             (uchar_t *)sensep, SENSE_LENGTH, SD_LOG_HEX);
18033 
18034         if (pfa_flag == FALSE) {
18035                 /* This is normally only set for USCSI */
18036                 if ((pktp->pkt_flags & FLAG_SILENT) != 0) {
18037                         return;
18038                 }
18039 
18040                 if ((SD_IS_BUFIO(xp) == TRUE) &&
18041                     (((sd_level_mask & SD_LOGMASK_DIAG) == 0) &&
18042                     (severity < sd_error_level))) {
18043                         return;
18044                 }
18045         }
18046         /*
18047          * Check for Sonoma Failover and keep a count of how many failed I/O's
18048          */
18049         if ((SD_IS_LSI(un)) &&
18050             (scsi_sense_key(sensep) == KEY_ILLEGAL_REQUEST) &&
18051             (scsi_sense_asc(sensep) == 0x94) &&
18052             (scsi_sense_ascq(sensep) == 0x01)) {
18053                 un->un_sonoma_failure_count++;
18054                 if (un->un_sonoma_failure_count > 1) {
18055                         return;
18056                 }
18057         }
18058 
18059         if (SD_FM_LOG(un) == SD_FM_LOG_NSUP ||
18060             ((scsi_sense_key(sensep) == KEY_RECOVERABLE_ERROR) &&
18061             (pktp->pkt_resid == 0))) {
18062                 scsi_vu_errmsg(SD_SCSI_DEVP(un), pktp, sd_label, severity,
18063                     request_blkno, err_blkno, scsi_cmds,
18064                     (struct scsi_extended_sense *)sensep,
18065                     un->un_additional_codes, NULL);
18066         }
18067 }
18068 
18069 /*
18070  *    Function: sd_sense_key_no_sense
18071  *
18072  * Description: Recovery action when sense data was not received.
18073  *
18074  *     Context: May be called from interrupt context
18075  */
18076 
18077 static void
18078 sd_sense_key_no_sense(struct sd_lun *un, struct buf *bp,
18079         struct sd_xbuf *xp, struct scsi_pkt *pktp)
18080 {
18081         struct sd_sense_info    si;
18082 
18083         ASSERT(un != NULL);
18084         ASSERT(mutex_owned(SD_MUTEX(un)));
18085         ASSERT(bp != NULL);
18086         ASSERT(xp != NULL);
18087         ASSERT(pktp != NULL);
18088 
18089         si.ssi_severity = SCSI_ERR_FATAL;
18090         si.ssi_pfa_flag = FALSE;
18091 
18092         SD_UPDATE_ERRSTATS(un, sd_softerrs);
18093 
18094         sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18095             &si, EIO, (clock_t)0, NULL);
18096 }
18097 
18098 
18099 /*
18100  *    Function: sd_sense_key_recoverable_error
18101  *
18102  * Description: Recovery actions for a SCSI "Recovered Error" sense key.
18103  *
18104  *     Context: May be called from interrupt context
18105  */
18106 
18107 static void
18108 sd_sense_key_recoverable_error(struct sd_lun *un,
18109         uint8_t *sense_datap,
18110         struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp)
18111 {
18112         struct sd_sense_info    si;
18113         uint8_t asc = scsi_sense_asc(sense_datap);
18114 
18115         ASSERT(un != NULL);
18116         ASSERT(mutex_owned(SD_MUTEX(un)));
18117         ASSERT(bp != NULL);
18118         ASSERT(xp != NULL);
18119         ASSERT(pktp != NULL);
18120 
18121         /*
18122          * 0x5D: FAILURE PREDICTION THRESHOLD EXCEEDED
18123          */
18124         if ((asc == 0x5D) && (sd_report_pfa != 0)) {
18125                 SD_UPDATE_ERRSTATS(un, sd_rq_pfa_err);
18126                 si.ssi_severity = SCSI_ERR_INFO;
18127                 si.ssi_pfa_flag = TRUE;
18128         } else {
18129                 SD_UPDATE_ERRSTATS(un, sd_softerrs);
18130                 SD_UPDATE_ERRSTATS(un, sd_rq_recov_err);
18131                 si.ssi_severity = SCSI_ERR_RECOVERED;
18132                 si.ssi_pfa_flag = FALSE;
18133         }
18134 
18135         if (pktp->pkt_resid == 0) {
18136                 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18137                 sd_return_command(un, bp);
18138                 return;
18139         }
18140 
18141         sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18142             &si, EIO, (clock_t)0, NULL);
18143 }
18144 
18145 
18146 
18147 
18148 /*
18149  *    Function: sd_sense_key_not_ready
18150  *
18151  * Description: Recovery actions for a SCSI "Not Ready" sense key.
18152  *
18153  *     Context: May be called from interrupt context
18154  */
18155 
18156 static void
18157 sd_sense_key_not_ready(struct sd_lun *un,
18158         uint8_t *sense_datap,
18159         struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp)
18160 {
18161         struct sd_sense_info    si;
18162         uint8_t asc = scsi_sense_asc(sense_datap);
18163         uint8_t ascq = scsi_sense_ascq(sense_datap);
18164 
18165         ASSERT(un != NULL);
18166         ASSERT(mutex_owned(SD_MUTEX(un)));
18167         ASSERT(bp != NULL);
18168         ASSERT(xp != NULL);
18169         ASSERT(pktp != NULL);
18170 
18171         si.ssi_severity = SCSI_ERR_FATAL;
18172         si.ssi_pfa_flag = FALSE;
18173 
18174         /*
18175          * Update error stats after first NOT READY error. Disks may have
18176          * been powered down and may need to be restarted.  For CDROMs,
18177          * report NOT READY errors only if media is present.
18178          */
18179         if ((ISCD(un) && (asc == 0x3A)) ||
18180             (xp->xb_nr_retry_count > 0)) {
18181                 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18182                 SD_UPDATE_ERRSTATS(un, sd_rq_ntrdy_err);
18183         }
18184 
18185         /*
18186          * Just fail if the "not ready" retry limit has been reached.
18187          */
18188         if (xp->xb_nr_retry_count >= un->un_notready_retry_count) {
18189                 /* Special check for error message printing for removables. */
18190                 if (un->un_f_has_removable_media && (asc == 0x04) &&
18191                     (ascq >= 0x04)) {
18192                         si.ssi_severity = SCSI_ERR_ALL;
18193                 }
18194                 goto fail_command;
18195         }
18196 
18197         /*
18198          * Check the ASC and ASCQ in the sense data as needed, to determine
18199          * what to do.
18200          */
18201         switch (asc) {
18202         case 0x04:      /* LOGICAL UNIT NOT READY */
18203                 /*
18204                  * disk drives that don't spin up result in a very long delay
18205                  * in format without warning messages. We will log a message
18206                  * if the error level is set to verbose.
18207                  */
18208                 if (sd_error_level < SCSI_ERR_RETRYABLE) {
18209                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18210                             "logical unit not ready, resetting disk\n");
18211                 }
18212 
18213                 /*
18214                  * There are different requirements for CDROMs and disks for
18215                  * the number of retries.  If a CD-ROM is giving this, it is
18216                  * probably reading TOC and is in the process of getting
18217                  * ready, so we should keep on trying for a long time to make
18218                  * sure that all types of media are taken in account (for
18219                  * some media the drive takes a long time to read TOC).  For
18220                  * disks we do not want to retry this too many times as this
18221                  * can cause a long hang in format when the drive refuses to
18222                  * spin up (a very common failure).
18223                  */
18224                 switch (ascq) {
18225                 case 0x00:  /* LUN NOT READY, CAUSE NOT REPORTABLE */
18226                         /*
18227                          * Disk drives frequently refuse to spin up which
18228                          * results in a very long hang in format without
18229                          * warning messages.
18230                          *
18231                          * Note: This code preserves the legacy behavior of
18232                          * comparing xb_nr_retry_count against zero for fibre
18233                          * channel targets instead of comparing against the
18234                          * un_reset_retry_count value.  The reason for this
18235                          * discrepancy has been so utterly lost beneath the
18236                          * Sands of Time that even Indiana Jones could not
18237                          * find it.
18238                          */
18239                         if (un->un_f_is_fibre == TRUE) {
18240                                 if (((sd_level_mask & SD_LOGMASK_DIAG) ||
18241                                     (xp->xb_nr_retry_count > 0)) &&
18242                                     (un->un_startstop_timeid == NULL)) {
18243                                         scsi_log(SD_DEVINFO(un), sd_label,
18244                                             CE_WARN, "logical unit not ready, "
18245                                             "resetting disk\n");
18246                                         sd_reset_target(un, pktp);
18247                                 }
18248                         } else {
18249                                 if (((sd_level_mask & SD_LOGMASK_DIAG) ||
18250                                     (xp->xb_nr_retry_count >
18251                                     un->un_reset_retry_count)) &&
18252                                     (un->un_startstop_timeid == NULL)) {
18253                                         scsi_log(SD_DEVINFO(un), sd_label,
18254                                             CE_WARN, "logical unit not ready, "
18255                                             "resetting disk\n");
18256                                         sd_reset_target(un, pktp);
18257                                 }
18258                         }
18259                         break;
18260 
18261                 case 0x01:  /* LUN IS IN PROCESS OF BECOMING READY */
18262                         /*
18263                          * If the target is in the process of becoming
18264                          * ready, just proceed with the retry. This can
18265                          * happen with CD-ROMs that take a long time to
18266                          * read TOC after a power cycle or reset.
18267                          */
18268                         goto do_retry;
18269 
18270                 case 0x02:  /* LUN NOT READY, INITITIALIZING CMD REQUIRED */
18271                         break;
18272 
18273                 case 0x03:  /* LUN NOT READY, MANUAL INTERVENTION REQUIRED */
18274                         /*
18275                          * Retries cannot help here so just fail right away.
18276                          */
18277                         goto fail_command;
18278 
18279                 case 0x88:
18280                         /*
18281                          * Vendor-unique code for T3/T4: it indicates a
18282                          * path problem in a mutipathed config, but as far as
18283                          * the target driver is concerned it equates to a fatal
18284                          * error, so we should just fail the command right away
18285                          * (without printing anything to the console). If this
18286                          * is not a T3/T4, fall thru to the default recovery
18287                          * action.
18288                          * T3/T4 is FC only, don't need to check is_fibre
18289                          */
18290                         if (SD_IS_T3(un) || SD_IS_T4(un)) {
18291                                 sd_return_failed_command(un, bp, EIO);
18292                                 return;
18293                         }
18294                         /* FALLTHRU */
18295 
18296                 case 0x04:  /* LUN NOT READY, FORMAT IN PROGRESS */
18297                 case 0x05:  /* LUN NOT READY, REBUILD IN PROGRESS */
18298                 case 0x06:  /* LUN NOT READY, RECALCULATION IN PROGRESS */
18299                 case 0x07:  /* LUN NOT READY, OPERATION IN PROGRESS */
18300                 case 0x08:  /* LUN NOT READY, LONG WRITE IN PROGRESS */
18301                 default:    /* Possible future codes in SCSI spec? */
18302                         /*
18303                          * For removable-media devices, do not retry if
18304                          * ASCQ > 2 as these result mostly from USCSI commands
18305                          * on MMC devices issued to check status of an
18306                          * operation initiated in immediate mode.  Also for
18307                          * ASCQ >= 4 do not print console messages as these
18308                          * mainly represent a user-initiated operation
18309                          * instead of a system failure.
18310                          */
18311                         if (un->un_f_has_removable_media) {
18312                                 si.ssi_severity = SCSI_ERR_ALL;
18313                                 goto fail_command;
18314                         }
18315                         break;
18316                 }
18317 
18318                 /*
18319                  * As part of our recovery attempt for the NOT READY
18320                  * condition, we issue a START STOP UNIT command. However
18321                  * we want to wait for a short delay before attempting this
18322                  * as there may still be more commands coming back from the
18323                  * target with the check condition. To do this we use
18324                  * timeout(9F) to call sd_start_stop_unit_callback() after
18325                  * the delay interval expires. (sd_start_stop_unit_callback()
18326                  * dispatches sd_start_stop_unit_task(), which will issue
18327                  * the actual START STOP UNIT command. The delay interval
18328                  * is one-half of the delay that we will use to retry the
18329                  * command that generated the NOT READY condition.
18330                  *
18331                  * Note that we could just dispatch sd_start_stop_unit_task()
18332                  * from here and allow it to sleep for the delay interval,
18333                  * but then we would be tying up the taskq thread
18334                  * uncesessarily for the duration of the delay.
18335                  *
18336                  * Do not issue the START STOP UNIT if the current command
18337                  * is already a START STOP UNIT.
18338                  */
18339                 if (pktp->pkt_cdbp[0] == SCMD_START_STOP) {
18340                         break;
18341                 }
18342 
18343                 /*
18344                  * Do not schedule the timeout if one is already pending.
18345                  */
18346                 if (un->un_startstop_timeid != NULL) {
18347                         SD_INFO(SD_LOG_ERROR, un,
18348                             "sd_sense_key_not_ready: restart already issued to"
18349                             " %s%d\n", ddi_driver_name(SD_DEVINFO(un)),
18350                             ddi_get_instance(SD_DEVINFO(un)));
18351                         break;
18352                 }
18353 
18354                 /*
18355                  * Schedule the START STOP UNIT command, then queue the command
18356                  * for a retry.
18357                  *
18358                  * Note: A timeout is not scheduled for this retry because we
18359                  * want the retry to be serial with the START_STOP_UNIT. The
18360                  * retry will be started when the START_STOP_UNIT is completed
18361                  * in sd_start_stop_unit_task.
18362                  */
18363                 un->un_startstop_timeid = timeout(sd_start_stop_unit_callback,
18364                     un, un->un_busy_timeout / 2);
18365                 xp->xb_nr_retry_count++;
18366                 sd_set_retry_bp(un, bp, 0, kstat_waitq_enter);
18367                 return;
18368 
18369         case 0x05:      /* LOGICAL UNIT DOES NOT RESPOND TO SELECTION */
18370                 if (sd_error_level < SCSI_ERR_RETRYABLE) {
18371                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18372                             "unit does not respond to selection\n");
18373                 }
18374                 break;
18375 
18376         case 0x3A:      /* MEDIUM NOT PRESENT */
18377                 if (sd_error_level >= SCSI_ERR_FATAL) {
18378                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18379                             "Caddy not inserted in drive\n");
18380                 }
18381 
18382                 sr_ejected(un);
18383                 un->un_mediastate = DKIO_EJECTED;
18384                 /* The state has changed, inform the media watch routines */
18385                 cv_broadcast(&un->un_state_cv);
18386                 /* Just fail if no media is present in the drive. */
18387                 goto fail_command;
18388 
18389         default:
18390                 if (sd_error_level < SCSI_ERR_RETRYABLE) {
18391                         scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE,
18392                             "Unit not Ready. Additional sense code 0x%x\n",
18393                             asc);
18394                 }
18395                 break;
18396         }
18397 
18398 do_retry:
18399 
18400         /*
18401          * Retry the command, as some targets may report NOT READY for
18402          * several seconds after being reset.
18403          */
18404         xp->xb_nr_retry_count++;
18405         si.ssi_severity = SCSI_ERR_RETRYABLE;
18406         sd_retry_command(un, bp, SD_RETRIES_NOCHECK, sd_print_sense_msg,
18407             &si, EIO, un->un_busy_timeout, NULL);
18408 
18409         return;
18410 
18411 fail_command:
18412         sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18413         sd_return_failed_command(un, bp, EIO);
18414 }
18415 
18416 
18417 
18418 /*
18419  *    Function: sd_sense_key_medium_or_hardware_error
18420  *
18421  * Description: Recovery actions for a SCSI "Medium Error" or "Hardware Error"
18422  *              sense key.
18423  *
18424  *     Context: May be called from interrupt context
18425  */
18426 
18427 static void
18428 sd_sense_key_medium_or_hardware_error(struct sd_lun *un,
18429         uint8_t *sense_datap,
18430         struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp)
18431 {
18432         struct sd_sense_info    si;
18433         uint8_t sense_key = scsi_sense_key(sense_datap);
18434         uint8_t asc = scsi_sense_asc(sense_datap);
18435 
18436         ASSERT(un != NULL);
18437         ASSERT(mutex_owned(SD_MUTEX(un)));
18438         ASSERT(bp != NULL);
18439         ASSERT(xp != NULL);
18440         ASSERT(pktp != NULL);
18441 
18442         si.ssi_severity = SCSI_ERR_FATAL;
18443         si.ssi_pfa_flag = FALSE;
18444 
18445         if (sense_key == KEY_MEDIUM_ERROR) {
18446                 SD_UPDATE_ERRSTATS(un, sd_rq_media_err);
18447         }
18448 
18449         SD_UPDATE_ERRSTATS(un, sd_harderrs);
18450 
18451         if ((un->un_reset_retry_count != 0) &&
18452             (xp->xb_retry_count == un->un_reset_retry_count)) {
18453                 mutex_exit(SD_MUTEX(un));
18454                 /* Do NOT do a RESET_ALL here: too intrusive. (4112858) */
18455                 if (un->un_f_allow_bus_device_reset == TRUE) {
18456 
18457                         boolean_t try_resetting_target = B_TRUE;
18458 
18459                         /*
18460                          * We need to be able to handle specific ASC when we are
18461                          * handling a KEY_HARDWARE_ERROR. In particular
18462                          * taking the default action of resetting the target may
18463                          * not be the appropriate way to attempt recovery.
18464                          * Resetting a target because of a single LUN failure
18465                          * victimizes all LUNs on that target.
18466                          *
18467                          * This is true for the LSI arrays, if an LSI
18468                          * array controller returns an ASC of 0x84 (LUN Dead) we
18469                          * should trust it.
18470                          */
18471 
18472                         if (sense_key == KEY_HARDWARE_ERROR) {
18473                                 switch (asc) {
18474                                 case 0x84:
18475                                         if (SD_IS_LSI(un)) {
18476                                                 try_resetting_target = B_FALSE;
18477                                         }
18478                                         break;
18479                                 default:
18480                                         break;
18481                                 }
18482                         }
18483 
18484                         if (try_resetting_target == B_TRUE) {
18485                                 int reset_retval = 0;
18486                                 if (un->un_f_lun_reset_enabled == TRUE) {
18487                                         SD_TRACE(SD_LOG_IO_CORE, un,
18488                                             "sd_sense_key_medium_or_hardware_"
18489                                             "error: issuing RESET_LUN\n");
18490                                         reset_retval =
18491                                             scsi_reset(SD_ADDRESS(un),
18492                                             RESET_LUN);
18493                                 }
18494                                 if (reset_retval == 0) {
18495                                         SD_TRACE(SD_LOG_IO_CORE, un,
18496                                             "sd_sense_key_medium_or_hardware_"
18497                                             "error: issuing RESET_TARGET\n");
18498                                         (void) scsi_reset(SD_ADDRESS(un),
18499                                             RESET_TARGET);
18500                                 }
18501                         }
18502                 }
18503                 mutex_enter(SD_MUTEX(un));
18504         }
18505 
18506         /*
18507          * This really ought to be a fatal error, but we will retry anyway
18508          * as some drives report this as a spurious error.
18509          */
18510         sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18511             &si, EIO, (clock_t)0, NULL);
18512 }
18513 
18514 
18515 
18516 /*
18517  *    Function: sd_sense_key_illegal_request
18518  *
18519  * Description: Recovery actions for a SCSI "Illegal Request" sense key.
18520  *
18521  *     Context: May be called from interrupt context
18522  */
18523 
18524 static void
18525 sd_sense_key_illegal_request(struct sd_lun *un, struct buf *bp,
18526         struct sd_xbuf *xp, struct scsi_pkt *pktp)
18527 {
18528         struct sd_sense_info    si;
18529 
18530         ASSERT(un != NULL);
18531         ASSERT(mutex_owned(SD_MUTEX(un)));
18532         ASSERT(bp != NULL);
18533         ASSERT(xp != NULL);
18534         ASSERT(pktp != NULL);
18535 
18536         SD_UPDATE_ERRSTATS(un, sd_rq_illrq_err);
18537 
18538         si.ssi_severity = SCSI_ERR_INFO;
18539         si.ssi_pfa_flag = FALSE;
18540 
18541         /* Pointless to retry if the target thinks it's an illegal request */
18542         sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18543         sd_return_failed_command(un, bp, EIO);
18544 }
18545 
18546 
18547 
18548 
18549 /*
18550  *    Function: sd_sense_key_unit_attention
18551  *
18552  * Description: Recovery actions for a SCSI "Unit Attention" sense key.
18553  *
18554  *     Context: May be called from interrupt context
18555  */
18556 
18557 static void
18558 sd_sense_key_unit_attention(struct sd_lun *un,
18559         uint8_t *sense_datap,
18560         struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp)
18561 {
18562         /*
18563          * For UNIT ATTENTION we allow retries for one minute. Devices
18564          * like Sonoma can return UNIT ATTENTION close to a minute
18565          * under certain conditions.
18566          */
18567         int     retry_check_flag = SD_RETRIES_UA;
18568         boolean_t       kstat_updated = B_FALSE;
18569         struct  sd_sense_info           si;
18570         uint8_t asc = scsi_sense_asc(sense_datap);
18571         uint8_t ascq = scsi_sense_ascq(sense_datap);
18572 
18573         ASSERT(un != NULL);
18574         ASSERT(mutex_owned(SD_MUTEX(un)));
18575         ASSERT(bp != NULL);
18576         ASSERT(xp != NULL);
18577         ASSERT(pktp != NULL);
18578 
18579         si.ssi_severity = SCSI_ERR_INFO;
18580         si.ssi_pfa_flag = FALSE;
18581 
18582 
18583         switch (asc) {
18584         case 0x5D:  /* FAILURE PREDICTION THRESHOLD EXCEEDED */
18585                 if (sd_report_pfa != 0) {
18586                         SD_UPDATE_ERRSTATS(un, sd_rq_pfa_err);
18587                         si.ssi_pfa_flag = TRUE;
18588                         retry_check_flag = SD_RETRIES_STANDARD;
18589                         goto do_retry;
18590                 }
18591 
18592                 break;
18593 
18594         case 0x29:  /* POWER ON, RESET, OR BUS DEVICE RESET OCCURRED */
18595                 if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) {
18596                         un->un_resvd_status |=
18597                             (SD_LOST_RESERVE | SD_WANT_RESERVE);
18598                 }
18599 #ifdef _LP64
18600                 if (un->un_blockcount + 1 > SD_GROUP1_MAX_ADDRESS) {
18601                         if (taskq_dispatch(sd_tq, sd_reenable_dsense_task,
18602                             un, KM_NOSLEEP) == 0) {
18603                                 /*
18604                                  * If we can't dispatch the task we'll just
18605                                  * live without descriptor sense.  We can
18606                                  * try again on the next "unit attention"
18607                                  */
18608                                 SD_ERROR(SD_LOG_ERROR, un,
18609                                     "sd_sense_key_unit_attention: "
18610                                     "Could not dispatch "
18611                                     "sd_reenable_dsense_task\n");
18612                         }
18613                 }
18614 #endif /* _LP64 */
18615                 /* FALLTHRU */
18616 
18617         case 0x28: /* NOT READY TO READY CHANGE, MEDIUM MAY HAVE CHANGED */
18618                 if (!un->un_f_has_removable_media) {
18619                         break;
18620                 }
18621 
18622                 /*
18623                  * When we get a unit attention from a removable-media device,
18624                  * it may be in a state that will take a long time to recover
18625                  * (e.g., from a reset).  Since we are executing in interrupt
18626                  * context here, we cannot wait around for the device to come
18627                  * back. So hand this command off to sd_media_change_task()
18628                  * for deferred processing under taskq thread context. (Note
18629                  * that the command still may be failed if a problem is
18630                  * encountered at a later time.)
18631                  */
18632                 if (taskq_dispatch(sd_tq, sd_media_change_task, pktp,
18633                     KM_NOSLEEP) == 0) {
18634                         /*
18635                          * Cannot dispatch the request so fail the command.
18636                          */
18637                         SD_UPDATE_ERRSTATS(un, sd_harderrs);
18638                         SD_UPDATE_ERRSTATS(un, sd_rq_nodev_err);
18639                         si.ssi_severity = SCSI_ERR_FATAL;
18640                         sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18641                         sd_return_failed_command(un, bp, EIO);
18642                 }
18643 
18644                 /*
18645                  * If failed to dispatch sd_media_change_task(), we already
18646                  * updated kstat. If succeed to dispatch sd_media_change_task(),
18647                  * we should update kstat later if it encounters an error. So,
18648                  * we update kstat_updated flag here.
18649                  */
18650                 kstat_updated = B_TRUE;
18651 
18652                 /*
18653                  * Either the command has been successfully dispatched to a
18654                  * task Q for retrying, or the dispatch failed. In either case
18655                  * do NOT retry again by calling sd_retry_command. This sets up
18656                  * two retries of the same command and when one completes and
18657                  * frees the resources the other will access freed memory,
18658                  * a bad thing.
18659                  */
18660                 return;
18661 
18662         default:
18663                 break;
18664         }
18665 
18666         /*
18667          * ASC  ASCQ
18668          *  2A   09     Capacity data has changed
18669          *  2A   01     Mode parameters changed
18670          *  3F   0E     Reported luns data has changed
18671          * Arrays that support logical unit expansion should report
18672          * capacity changes(2Ah/09). Mode parameters changed and
18673          * reported luns data has changed are the approximation.
18674          */
18675         if (((asc == 0x2a) && (ascq == 0x09)) ||
18676             ((asc == 0x2a) && (ascq == 0x01)) ||
18677             ((asc == 0x3f) && (ascq == 0x0e))) {
18678                 if (taskq_dispatch(sd_tq, sd_target_change_task, un,
18679                     KM_NOSLEEP) == 0) {
18680                         SD_ERROR(SD_LOG_ERROR, un,
18681                             "sd_sense_key_unit_attention: "
18682                             "Could not dispatch sd_target_change_task\n");
18683                 }
18684         }
18685 
18686         /*
18687          * Update kstat if we haven't done that.
18688          */
18689         if (!kstat_updated) {
18690                 SD_UPDATE_ERRSTATS(un, sd_harderrs);
18691                 SD_UPDATE_ERRSTATS(un, sd_rq_nodev_err);
18692         }
18693 
18694 do_retry:
18695         sd_retry_command(un, bp, retry_check_flag, sd_print_sense_msg, &si,
18696             EIO, SD_UA_RETRY_DELAY, NULL);
18697 }
18698 
18699 
18700 
18701 /*
18702  *    Function: sd_sense_key_fail_command
18703  *
18704  * Description: Use to fail a command when we don't like the sense key that
18705  *              was returned.
18706  *
18707  *     Context: May be called from interrupt context
18708  */
18709 
18710 static void
18711 sd_sense_key_fail_command(struct sd_lun *un, struct buf *bp,
18712         struct sd_xbuf *xp, struct scsi_pkt *pktp)
18713 {
18714         struct sd_sense_info    si;
18715 
18716         ASSERT(un != NULL);
18717         ASSERT(mutex_owned(SD_MUTEX(un)));
18718         ASSERT(bp != NULL);
18719         ASSERT(xp != NULL);
18720         ASSERT(pktp != NULL);
18721 
18722         si.ssi_severity = SCSI_ERR_FATAL;
18723         si.ssi_pfa_flag = FALSE;
18724 
18725         sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18726         sd_return_failed_command(un, bp, EIO);
18727 }
18728 
18729 
18730 
18731 /*
18732  *    Function: sd_sense_key_blank_check
18733  *
18734  * Description: Recovery actions for a SCSI "Blank Check" sense key.
18735  *              Has no monetary connotation.
18736  *
18737  *     Context: May be called from interrupt context
18738  */
18739 
18740 static void
18741 sd_sense_key_blank_check(struct sd_lun *un, struct buf *bp,
18742         struct sd_xbuf *xp, struct scsi_pkt *pktp)
18743 {
18744         struct sd_sense_info    si;
18745 
18746         ASSERT(un != NULL);
18747         ASSERT(mutex_owned(SD_MUTEX(un)));
18748         ASSERT(bp != NULL);
18749         ASSERT(xp != NULL);
18750         ASSERT(pktp != NULL);
18751 
18752         /*
18753          * Blank check is not fatal for removable devices, therefore
18754          * it does not require a console message.
18755          */
18756         si.ssi_severity = (un->un_f_has_removable_media) ? SCSI_ERR_ALL :
18757             SCSI_ERR_FATAL;
18758         si.ssi_pfa_flag = FALSE;
18759 
18760         sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
18761         sd_return_failed_command(un, bp, EIO);
18762 }
18763 
18764 
18765 
18766 
18767 /*
18768  *    Function: sd_sense_key_aborted_command
18769  *
18770  * Description: Recovery actions for a SCSI "Aborted Command" sense key.
18771  *
18772  *     Context: May be called from interrupt context
18773  */
18774 
18775 static void
18776 sd_sense_key_aborted_command(struct sd_lun *un, struct buf *bp,
18777         struct sd_xbuf *xp, struct scsi_pkt *pktp)
18778 {
18779         struct sd_sense_info    si;
18780 
18781         ASSERT(un != NULL);
18782         ASSERT(mutex_owned(SD_MUTEX(un)));
18783         ASSERT(bp != NULL);
18784         ASSERT(xp != NULL);
18785         ASSERT(pktp != NULL);
18786 
18787         si.ssi_severity = SCSI_ERR_FATAL;
18788         si.ssi_pfa_flag = FALSE;
18789 
18790         SD_UPDATE_ERRSTATS(un, sd_harderrs);
18791 
18792         /*
18793          * This really ought to be a fatal error, but we will retry anyway
18794          * as some drives report this as a spurious error.
18795          */
18796         sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18797             &si, EIO, drv_usectohz(100000), NULL);
18798 }
18799 
18800 
18801 
18802 /*
18803  *    Function: sd_sense_key_default
18804  *
18805  * Description: Default recovery action for several SCSI sense keys (basically
18806  *              attempts a retry).
18807  *
18808  *     Context: May be called from interrupt context
18809  */
18810 
18811 static void
18812 sd_sense_key_default(struct sd_lun *un,
18813         uint8_t *sense_datap,
18814         struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp)
18815 {
18816         struct sd_sense_info    si;
18817         uint8_t sense_key = scsi_sense_key(sense_datap);
18818 
18819         ASSERT(un != NULL);
18820         ASSERT(mutex_owned(SD_MUTEX(un)));
18821         ASSERT(bp != NULL);
18822         ASSERT(xp != NULL);
18823         ASSERT(pktp != NULL);
18824 
18825         SD_UPDATE_ERRSTATS(un, sd_harderrs);
18826 
18827         /*
18828          * Undecoded sense key. Attempt retries and hope that will fix
18829          * the problem.  Otherwise, we're dead.
18830          */
18831         if ((pktp->pkt_flags & FLAG_SILENT) == 0) {
18832                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18833                     "Unhandled Sense Key '%s'\n", sense_keys[sense_key]);
18834         }
18835 
18836         si.ssi_severity = SCSI_ERR_FATAL;
18837         si.ssi_pfa_flag = FALSE;
18838 
18839         sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg,
18840             &si, EIO, (clock_t)0, NULL);
18841 }
18842 
18843 
18844 
18845 /*
18846  *    Function: sd_print_retry_msg
18847  *
18848  * Description: Print a message indicating the retry action being taken.
18849  *
18850  *   Arguments: un - ptr to associated softstate
18851  *              bp - ptr to buf(9S) for the command
18852  *              arg - not used.
18853  *              flag - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED,
18854  *                      or SD_NO_RETRY_ISSUED
18855  *
18856  *     Context: May be called from interrupt context
18857  */
18858 /* ARGSUSED */
18859 static void
18860 sd_print_retry_msg(struct sd_lun *un, struct buf *bp, void *arg, int flag)
18861 {
18862         struct sd_xbuf  *xp;
18863         struct scsi_pkt *pktp;
18864         char *reasonp;
18865         char *msgp;
18866 
18867         ASSERT(un != NULL);
18868         ASSERT(mutex_owned(SD_MUTEX(un)));
18869         ASSERT(bp != NULL);
18870         pktp = SD_GET_PKTP(bp);
18871         ASSERT(pktp != NULL);
18872         xp = SD_GET_XBUF(bp);
18873         ASSERT(xp != NULL);
18874 
18875         ASSERT(!mutex_owned(&un->un_pm_mutex));
18876         mutex_enter(&un->un_pm_mutex);
18877         if ((un->un_state == SD_STATE_SUSPENDED) ||
18878             (SD_DEVICE_IS_IN_LOW_POWER(un)) ||
18879             (pktp->pkt_flags & FLAG_SILENT)) {
18880                 mutex_exit(&un->un_pm_mutex);
18881                 goto update_pkt_reason;
18882         }
18883         mutex_exit(&un->un_pm_mutex);
18884 
18885         /*
18886          * Suppress messages if they are all the same pkt_reason; with
18887          * TQ, many (up to 256) are returned with the same pkt_reason.
18888          * If we are in panic, then suppress the retry messages.
18889          */
18890         switch (flag) {
18891         case SD_NO_RETRY_ISSUED:
18892                 msgp = "giving up";
18893                 break;
18894         case SD_IMMEDIATE_RETRY_ISSUED:
18895         case SD_DELAYED_RETRY_ISSUED:
18896                 if (ddi_in_panic() || (un->un_state == SD_STATE_OFFLINE) ||
18897                     ((pktp->pkt_reason == un->un_last_pkt_reason) &&
18898                     (sd_error_level != SCSI_ERR_ALL))) {
18899                         return;
18900                 }
18901                 msgp = "retrying command";
18902                 break;
18903         default:
18904                 goto update_pkt_reason;
18905         }
18906 
18907         reasonp = (((pktp->pkt_statistics & STAT_PERR) != 0) ? "parity error" :
18908             scsi_rname(pktp->pkt_reason));
18909 
18910         if (SD_FM_LOG(un) == SD_FM_LOG_NSUP) {
18911                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18912                     "SCSI transport failed: reason '%s': %s\n", reasonp, msgp);
18913         }
18914 
18915 update_pkt_reason:
18916         /*
18917          * Update un->un_last_pkt_reason with the value in pktp->pkt_reason.
18918          * This is to prevent multiple console messages for the same failure
18919          * condition.  Note that un->un_last_pkt_reason is NOT restored if &
18920          * when the command is retried successfully because there still may be
18921          * more commands coming back with the same value of pktp->pkt_reason.
18922          */
18923         if ((pktp->pkt_reason != CMD_CMPLT) || (xp->xb_retry_count == 0)) {
18924                 un->un_last_pkt_reason = pktp->pkt_reason;
18925         }
18926 }
18927 
18928 
18929 /*
18930  *    Function: sd_print_cmd_incomplete_msg
18931  *
18932  * Description: Message logging fn. for a SCSA "CMD_INCOMPLETE" pkt_reason.
18933  *
18934  *   Arguments: un - ptr to associated softstate
18935  *              bp - ptr to buf(9S) for the command
18936  *              arg - passed to sd_print_retry_msg()
18937  *              code - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED,
18938  *                      or SD_NO_RETRY_ISSUED
18939  *
18940  *     Context: May be called from interrupt context
18941  */
18942 
18943 static void
18944 sd_print_cmd_incomplete_msg(struct sd_lun *un, struct buf *bp, void *arg,
18945         int code)
18946 {
18947         dev_info_t      *dip;
18948 
18949         ASSERT(un != NULL);
18950         ASSERT(mutex_owned(SD_MUTEX(un)));
18951         ASSERT(bp != NULL);
18952 
18953         switch (code) {
18954         case SD_NO_RETRY_ISSUED:
18955                 /* Command was failed. Someone turned off this target? */
18956                 if (un->un_state != SD_STATE_OFFLINE) {
18957                         /*
18958                          * Suppress message if we are detaching and
18959                          * device has been disconnected
18960                          * Note that DEVI_IS_DEVICE_REMOVED is a consolidation
18961                          * private interface and not part of the DDI
18962                          */
18963                         dip = un->un_sd->sd_dev;
18964                         if (!(DEVI_IS_DETACHING(dip) &&
18965                             DEVI_IS_DEVICE_REMOVED(dip))) {
18966                                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
18967                                 "disk not responding to selection\n");
18968                         }
18969                         New_state(un, SD_STATE_OFFLINE);
18970                 }
18971                 break;
18972 
18973         case SD_DELAYED_RETRY_ISSUED:
18974         case SD_IMMEDIATE_RETRY_ISSUED:
18975         default:
18976                 /* Command was successfully queued for retry */
18977                 sd_print_retry_msg(un, bp, arg, code);
18978                 break;
18979         }
18980 }
18981 
18982 
18983 /*
18984  *    Function: sd_pkt_reason_cmd_incomplete
18985  *
18986  * Description: Recovery actions for a SCSA "CMD_INCOMPLETE" pkt_reason.
18987  *
18988  *     Context: May be called from interrupt context
18989  */
18990 
18991 static void
18992 sd_pkt_reason_cmd_incomplete(struct sd_lun *un, struct buf *bp,
18993         struct sd_xbuf *xp, struct scsi_pkt *pktp)
18994 {
18995         int flag = SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE;
18996 
18997         ASSERT(un != NULL);
18998         ASSERT(mutex_owned(SD_MUTEX(un)));
18999         ASSERT(bp != NULL);
19000         ASSERT(xp != NULL);
19001         ASSERT(pktp != NULL);
19002 
19003         /* Do not do a reset if selection did not complete */
19004         /* Note: Should this not just check the bit? */
19005         if (pktp->pkt_state != STATE_GOT_BUS) {
19006                 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19007                 sd_reset_target(un, pktp);
19008         }
19009 
19010         /*
19011          * If the target was not successfully selected, then set
19012          * SD_RETRIES_FAILFAST to indicate that we lost communication
19013          * with the target, and further retries and/or commands are
19014          * likely to take a long time.
19015          */
19016         if ((pktp->pkt_state & STATE_GOT_TARGET) == 0) {
19017                 flag |= SD_RETRIES_FAILFAST;
19018         }
19019 
19020         SD_UPDATE_RESERVATION_STATUS(un, pktp);
19021 
19022         sd_retry_command(un, bp, flag,
19023             sd_print_cmd_incomplete_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19024 }
19025 
19026 
19027 
19028 /*
19029  *    Function: sd_pkt_reason_cmd_tran_err
19030  *
19031  * Description: Recovery actions for a SCSA "CMD_TRAN_ERR" pkt_reason.
19032  *
19033  *     Context: May be called from interrupt context
19034  */
19035 
19036 static void
19037 sd_pkt_reason_cmd_tran_err(struct sd_lun *un, struct buf *bp,
19038         struct sd_xbuf *xp, struct scsi_pkt *pktp)
19039 {
19040         ASSERT(un != NULL);
19041         ASSERT(mutex_owned(SD_MUTEX(un)));
19042         ASSERT(bp != NULL);
19043         ASSERT(xp != NULL);
19044         ASSERT(pktp != NULL);
19045 
19046         /*
19047          * Do not reset if we got a parity error, or if
19048          * selection did not complete.
19049          */
19050         SD_UPDATE_ERRSTATS(un, sd_harderrs);
19051         /* Note: Should this not just check the bit for pkt_state? */
19052         if (((pktp->pkt_statistics & STAT_PERR) == 0) &&
19053             (pktp->pkt_state != STATE_GOT_BUS)) {
19054                 SD_UPDATE_ERRSTATS(un, sd_transerrs);
19055                 sd_reset_target(un, pktp);
19056         }
19057 
19058         SD_UPDATE_RESERVATION_STATUS(un, pktp);
19059 
19060         sd_retry_command(un, bp, (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE),
19061             sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19062 }
19063 
19064 
19065 
19066 /*
19067  *    Function: sd_pkt_reason_cmd_reset
19068  *
19069  * Description: Recovery actions for a SCSA "CMD_RESET" pkt_reason.
19070  *
19071  *     Context: May be called from interrupt context
19072  */
19073 
19074 static void
19075 sd_pkt_reason_cmd_reset(struct sd_lun *un, struct buf *bp,
19076         struct sd_xbuf *xp, struct scsi_pkt *pktp)
19077 {
19078         ASSERT(un != NULL);
19079         ASSERT(mutex_owned(SD_MUTEX(un)));
19080         ASSERT(bp != NULL);
19081         ASSERT(xp != NULL);
19082         ASSERT(pktp != NULL);
19083 
19084         /* The target may still be running the command, so try to reset. */
19085         SD_UPDATE_ERRSTATS(un, sd_transerrs);
19086         sd_reset_target(un, pktp);
19087 
19088         SD_UPDATE_RESERVATION_STATUS(un, pktp);
19089 
19090         /*
19091          * If pkt_reason is CMD_RESET chances are that this pkt got
19092          * reset because another target on this bus caused it. The target
19093          * that caused it should get CMD_TIMEOUT with pkt_statistics
19094          * of STAT_TIMEOUT/STAT_DEV_RESET.
19095          */
19096 
19097         sd_retry_command(un, bp, (SD_RETRIES_VICTIM | SD_RETRIES_ISOLATE),
19098             sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19099 }
19100 
19101 
19102 
19103 
19104 /*
19105  *    Function: sd_pkt_reason_cmd_aborted
19106  *
19107  * Description: Recovery actions for a SCSA "CMD_ABORTED" pkt_reason.
19108  *
19109  *     Context: May be called from interrupt context
19110  */
19111 
19112 static void
19113 sd_pkt_reason_cmd_aborted(struct sd_lun *un, struct buf *bp,
19114         struct sd_xbuf *xp, struct scsi_pkt *pktp)
19115 {
19116         ASSERT(un != NULL);
19117         ASSERT(mutex_owned(SD_MUTEX(un)));
19118         ASSERT(bp != NULL);
19119         ASSERT(xp != NULL);
19120         ASSERT(pktp != NULL);
19121 
19122         /* The target may still be running the command, so try to reset. */
19123         SD_UPDATE_ERRSTATS(un, sd_transerrs);
19124         sd_reset_target(un, pktp);
19125 
19126         SD_UPDATE_RESERVATION_STATUS(un, pktp);
19127 
19128         /*
19129          * If pkt_reason is CMD_ABORTED chances are that this pkt got
19130          * aborted because another target on this bus caused it. The target
19131          * that caused it should get CMD_TIMEOUT with pkt_statistics
19132          * of STAT_TIMEOUT/STAT_DEV_RESET.
19133          */
19134 
19135         sd_retry_command(un, bp, (SD_RETRIES_VICTIM | SD_RETRIES_ISOLATE),
19136             sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19137 }
19138 
19139 
19140 
19141 /*
19142  *    Function: sd_pkt_reason_cmd_timeout
19143  *
19144  * Description: Recovery actions for a SCSA "CMD_TIMEOUT" pkt_reason.
19145  *
19146  *     Context: May be called from interrupt context
19147  */
19148 
19149 static void
19150 sd_pkt_reason_cmd_timeout(struct sd_lun *un, struct buf *bp,
19151         struct sd_xbuf *xp, struct scsi_pkt *pktp)
19152 {
19153         ASSERT(un != NULL);
19154         ASSERT(mutex_owned(SD_MUTEX(un)));
19155         ASSERT(bp != NULL);
19156         ASSERT(xp != NULL);
19157         ASSERT(pktp != NULL);
19158 
19159 
19160         SD_UPDATE_ERRSTATS(un, sd_transerrs);
19161         sd_reset_target(un, pktp);
19162 
19163         SD_UPDATE_RESERVATION_STATUS(un, pktp);
19164 
19165         /*
19166          * A command timeout indicates that we could not establish
19167          * communication with the target, so set SD_RETRIES_FAILFAST
19168          * as further retries/commands are likely to take a long time.
19169          */
19170         sd_retry_command(un, bp,
19171             (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE | SD_RETRIES_FAILFAST),
19172             sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19173 }
19174 
19175 
19176 
19177 /*
19178  *    Function: sd_pkt_reason_cmd_unx_bus_free
19179  *
19180  * Description: Recovery actions for a SCSA "CMD_UNX_BUS_FREE" pkt_reason.
19181  *
19182  *     Context: May be called from interrupt context
19183  */
19184 
19185 static void
19186 sd_pkt_reason_cmd_unx_bus_free(struct sd_lun *un, struct buf *bp,
19187         struct sd_xbuf *xp, struct scsi_pkt *pktp)
19188 {
19189         void (*funcp)(struct sd_lun *un, struct buf *bp, void *arg, int code);
19190 
19191         ASSERT(un != NULL);
19192         ASSERT(mutex_owned(SD_MUTEX(un)));
19193         ASSERT(bp != NULL);
19194         ASSERT(xp != NULL);
19195         ASSERT(pktp != NULL);
19196 
19197         SD_UPDATE_ERRSTATS(un, sd_harderrs);
19198         SD_UPDATE_RESERVATION_STATUS(un, pktp);
19199 
19200         funcp = ((pktp->pkt_statistics & STAT_PERR) == 0) ?
19201             sd_print_retry_msg : NULL;
19202 
19203         sd_retry_command(un, bp, (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE),
19204             funcp, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19205 }
19206 
19207 
19208 /*
19209  *    Function: sd_pkt_reason_cmd_tag_reject
19210  *
19211  * Description: Recovery actions for a SCSA "CMD_TAG_REJECT" pkt_reason.
19212  *
19213  *     Context: May be called from interrupt context
19214  */
19215 
19216 static void
19217 sd_pkt_reason_cmd_tag_reject(struct sd_lun *un, struct buf *bp,
19218         struct sd_xbuf *xp, struct scsi_pkt *pktp)
19219 {
19220         ASSERT(un != NULL);
19221         ASSERT(mutex_owned(SD_MUTEX(un)));
19222         ASSERT(bp != NULL);
19223         ASSERT(xp != NULL);
19224         ASSERT(pktp != NULL);
19225 
19226         SD_UPDATE_ERRSTATS(un, sd_harderrs);
19227         pktp->pkt_flags = 0;
19228         un->un_tagflags = 0;
19229         if (un->un_f_opt_queueing == TRUE) {
19230                 un->un_throttle = min(un->un_throttle, 3);
19231         } else {
19232                 un->un_throttle = 1;
19233         }
19234         mutex_exit(SD_MUTEX(un));
19235         (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
19236         mutex_enter(SD_MUTEX(un));
19237 
19238         SD_UPDATE_RESERVATION_STATUS(un, pktp);
19239 
19240         /* Legacy behavior not to check retry counts here. */
19241         sd_retry_command(un, bp, (SD_RETRIES_NOCHECK | SD_RETRIES_ISOLATE),
19242             sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19243 }
19244 
19245 
19246 /*
19247  *    Function: sd_pkt_reason_default
19248  *
19249  * Description: Default recovery actions for SCSA pkt_reason values that
19250  *              do not have more explicit recovery actions.
19251  *
19252  *     Context: May be called from interrupt context
19253  */
19254 
19255 static void
19256 sd_pkt_reason_default(struct sd_lun *un, struct buf *bp,
19257         struct sd_xbuf *xp, struct scsi_pkt *pktp)
19258 {
19259         ASSERT(un != NULL);
19260         ASSERT(mutex_owned(SD_MUTEX(un)));
19261         ASSERT(bp != NULL);
19262         ASSERT(xp != NULL);
19263         ASSERT(pktp != NULL);
19264 
19265         SD_UPDATE_ERRSTATS(un, sd_transerrs);
19266         sd_reset_target(un, pktp);
19267 
19268         SD_UPDATE_RESERVATION_STATUS(un, pktp);
19269 
19270         sd_retry_command(un, bp, (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE),
19271             sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL);
19272 }
19273 
19274 
19275 
19276 /*
19277  *    Function: sd_pkt_status_check_condition
19278  *
19279  * Description: Recovery actions for a "STATUS_CHECK" SCSI command status.
19280  *
19281  *     Context: May be called from interrupt context
19282  */
19283 
19284 static void
19285 sd_pkt_status_check_condition(struct sd_lun *un, struct buf *bp,
19286         struct sd_xbuf *xp, struct scsi_pkt *pktp)
19287 {
19288         ASSERT(un != NULL);
19289         ASSERT(mutex_owned(SD_MUTEX(un)));
19290         ASSERT(bp != NULL);
19291         ASSERT(xp != NULL);
19292         ASSERT(pktp != NULL);
19293 
19294         SD_TRACE(SD_LOG_IO, un, "sd_pkt_status_check_condition: "
19295             "entry: buf:0x%p xp:0x%p\n", bp, xp);
19296 
19297         /*
19298          * If ARQ is NOT enabled, then issue a REQUEST SENSE command (the
19299          * command will be retried after the request sense). Otherwise, retry
19300          * the command. Note: we are issuing the request sense even though the
19301          * retry limit may have been reached for the failed command.
19302          */
19303         if (un->un_f_arq_enabled == FALSE) {
19304                 SD_INFO(SD_LOG_IO_CORE, un, "sd_pkt_status_check_condition: "
19305                     "no ARQ, sending request sense command\n");
19306                 sd_send_request_sense_command(un, bp, pktp);
19307         } else {
19308                 SD_INFO(SD_LOG_IO_CORE, un, "sd_pkt_status_check_condition: "
19309                     "ARQ,retrying request sense command\n");
19310 #if defined(__i386) || defined(__amd64)
19311                 /*
19312                  * The SD_RETRY_DELAY value need to be adjusted here
19313                  * when SD_RETRY_DELAY change in sddef.h
19314                  */
19315                 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, NULL, EIO,
19316                     un->un_f_is_fibre?drv_usectohz(100000):(clock_t)0,
19317                     NULL);
19318 #else
19319                 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, NULL,
19320                     EIO, SD_RETRY_DELAY, NULL);
19321 #endif
19322         }
19323 
19324         SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_check_condition: exit\n");
19325 }
19326 
19327 
19328 /*
19329  *    Function: sd_pkt_status_busy
19330  *
19331  * Description: Recovery actions for a "STATUS_BUSY" SCSI command status.
19332  *
19333  *     Context: May be called from interrupt context
19334  */
19335 
19336 static void
19337 sd_pkt_status_busy(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp,
19338         struct scsi_pkt *pktp)
19339 {
19340         ASSERT(un != NULL);
19341         ASSERT(mutex_owned(SD_MUTEX(un)));
19342         ASSERT(bp != NULL);
19343         ASSERT(xp != NULL);
19344         ASSERT(pktp != NULL);
19345 
19346         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19347             "sd_pkt_status_busy: entry\n");
19348 
19349         /* If retries are exhausted, just fail the command. */
19350         if (xp->xb_retry_count >= un->un_busy_retry_count) {
19351                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
19352                     "device busy too long\n");
19353                 sd_return_failed_command(un, bp, EIO);
19354                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19355                     "sd_pkt_status_busy: exit\n");
19356                 return;
19357         }
19358         xp->xb_retry_count++;
19359 
19360         /*
19361          * Try to reset the target. However, we do not want to perform
19362          * more than one reset if the device continues to fail. The reset
19363          * will be performed when the retry count reaches the reset
19364          * threshold.  This threshold should be set such that at least
19365          * one retry is issued before the reset is performed.
19366          */
19367         if (xp->xb_retry_count ==
19368             ((un->un_reset_retry_count < 2) ? 2 : un->un_reset_retry_count)) {
19369                 int rval = 0;
19370                 mutex_exit(SD_MUTEX(un));
19371                 if (un->un_f_allow_bus_device_reset == TRUE) {
19372                         /*
19373                          * First try to reset the LUN; if we cannot then
19374                          * try to reset the target.
19375                          */
19376                         if (un->un_f_lun_reset_enabled == TRUE) {
19377                                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19378                                     "sd_pkt_status_busy: RESET_LUN\n");
19379                                 rval = scsi_reset(SD_ADDRESS(un), RESET_LUN);
19380                         }
19381                         if (rval == 0) {
19382                                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19383                                     "sd_pkt_status_busy: RESET_TARGET\n");
19384                                 rval = scsi_reset(SD_ADDRESS(un), RESET_TARGET);
19385                         }
19386                 }
19387                 if (rval == 0) {
19388                         /*
19389                          * If the RESET_LUN and/or RESET_TARGET failed,
19390                          * try RESET_ALL
19391                          */
19392                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19393                             "sd_pkt_status_busy: RESET_ALL\n");
19394                         rval = scsi_reset(SD_ADDRESS(un), RESET_ALL);
19395                 }
19396                 mutex_enter(SD_MUTEX(un));
19397                 if (rval == 0) {
19398                         /*
19399                          * The RESET_LUN, RESET_TARGET, and/or RESET_ALL failed.
19400                          * At this point we give up & fail the command.
19401                          */
19402                         sd_return_failed_command(un, bp, EIO);
19403                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19404                             "sd_pkt_status_busy: exit (failed cmd)\n");
19405                         return;
19406                 }
19407         }
19408 
19409         /*
19410          * Retry the command. Be sure to specify SD_RETRIES_NOCHECK as
19411          * we have already checked the retry counts above.
19412          */
19413         sd_retry_command(un, bp, SD_RETRIES_NOCHECK, NULL, NULL,
19414             EIO, un->un_busy_timeout, NULL);
19415 
19416         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19417             "sd_pkt_status_busy: exit\n");
19418 }
19419 
19420 
19421 /*
19422  *    Function: sd_pkt_status_reservation_conflict
19423  *
19424  * Description: Recovery actions for a "STATUS_RESERVATION_CONFLICT" SCSI
19425  *              command status.
19426  *
19427  *     Context: May be called from interrupt context
19428  */
19429 
19430 static void
19431 sd_pkt_status_reservation_conflict(struct sd_lun *un, struct buf *bp,
19432         struct sd_xbuf *xp, struct scsi_pkt *pktp)
19433 {
19434         ASSERT(un != NULL);
19435         ASSERT(mutex_owned(SD_MUTEX(un)));
19436         ASSERT(bp != NULL);
19437         ASSERT(xp != NULL);
19438         ASSERT(pktp != NULL);
19439 
19440         /*
19441          * If the command was PERSISTENT_RESERVATION_[IN|OUT] then reservation
19442          * conflict could be due to various reasons like incorrect keys, not
19443          * registered or not reserved etc. So, we return EACCES to the caller.
19444          */
19445         if (un->un_reservation_type == SD_SCSI3_RESERVATION) {
19446                 int cmd = SD_GET_PKT_OPCODE(pktp);
19447                 if ((cmd == SCMD_PERSISTENT_RESERVE_IN) ||
19448                     (cmd == SCMD_PERSISTENT_RESERVE_OUT)) {
19449                         sd_return_failed_command(un, bp, EACCES);
19450                         return;
19451                 }
19452         }
19453 
19454         un->un_resvd_status |= SD_RESERVATION_CONFLICT;
19455 
19456         if ((un->un_resvd_status & SD_FAILFAST) != 0) {
19457                 if (sd_failfast_enable != 0) {
19458                         /* By definition, we must panic here.... */
19459                         sd_panic_for_res_conflict(un);
19460                         /*NOTREACHED*/
19461                 }
19462                 SD_ERROR(SD_LOG_IO, un,
19463                     "sd_handle_resv_conflict: Disk Reserved\n");
19464                 sd_return_failed_command(un, bp, EACCES);
19465                 return;
19466         }
19467 
19468         /*
19469          * 1147670: retry only if sd_retry_on_reservation_conflict
19470          * property is set (default is 1). Retries will not succeed
19471          * on a disk reserved by another initiator. HA systems
19472          * may reset this via sd.conf to avoid these retries.
19473          *
19474          * Note: The legacy return code for this failure is EIO, however EACCES
19475          * seems more appropriate for a reservation conflict.
19476          */
19477         if (sd_retry_on_reservation_conflict == 0) {
19478                 SD_ERROR(SD_LOG_IO, un,
19479                     "sd_handle_resv_conflict: Device Reserved\n");
19480                 sd_return_failed_command(un, bp, EIO);
19481                 return;
19482         }
19483 
19484         /*
19485          * Retry the command if we can.
19486          *
19487          * Note: The legacy return code for this failure is EIO, however EACCES
19488          * seems more appropriate for a reservation conflict.
19489          */
19490         sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, NULL, EIO,
19491             (clock_t)2, NULL);
19492 }
19493 
19494 
19495 
19496 /*
19497  *    Function: sd_pkt_status_qfull
19498  *
19499  * Description: Handle a QUEUE FULL condition from the target.  This can
19500  *              occur if the HBA does not handle the queue full condition.
19501  *              (Basically this means third-party HBAs as Sun HBAs will
19502  *              handle the queue full condition.)  Note that if there are
19503  *              some commands already in the transport, then the queue full
19504  *              has occurred because the queue for this nexus is actually
19505  *              full. If there are no commands in the transport, then the
19506  *              queue full is resulting from some other initiator or lun
19507  *              consuming all the resources at the target.
19508  *
19509  *     Context: May be called from interrupt context
19510  */
19511 
19512 static void
19513 sd_pkt_status_qfull(struct sd_lun *un, struct buf *bp,
19514         struct sd_xbuf *xp, struct scsi_pkt *pktp)
19515 {
19516         ASSERT(un != NULL);
19517         ASSERT(mutex_owned(SD_MUTEX(un)));
19518         ASSERT(bp != NULL);
19519         ASSERT(xp != NULL);
19520         ASSERT(pktp != NULL);
19521 
19522         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19523             "sd_pkt_status_qfull: entry\n");
19524 
19525         /*
19526          * Just lower the QFULL throttle and retry the command.  Note that
19527          * we do not limit the number of retries here.
19528          */
19529         sd_reduce_throttle(un, SD_THROTTLE_QFULL);
19530         sd_retry_command(un, bp, SD_RETRIES_NOCHECK, NULL, NULL, 0,
19531             SD_RESTART_TIMEOUT, NULL);
19532 
19533         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19534             "sd_pkt_status_qfull: exit\n");
19535 }
19536 
19537 
19538 /*
19539  *    Function: sd_reset_target
19540  *
19541  * Description: Issue a scsi_reset(9F), with either RESET_LUN,
19542  *              RESET_TARGET, or RESET_ALL.
19543  *
19544  *     Context: May be called under interrupt context.
19545  */
19546 
19547 static void
19548 sd_reset_target(struct sd_lun *un, struct scsi_pkt *pktp)
19549 {
19550         int rval = 0;
19551 
19552         ASSERT(un != NULL);
19553         ASSERT(mutex_owned(SD_MUTEX(un)));
19554         ASSERT(pktp != NULL);
19555 
19556         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reset_target: entry\n");
19557 
19558         /*
19559          * No need to reset if the transport layer has already done so.
19560          */
19561         if ((pktp->pkt_statistics &
19562             (STAT_BUS_RESET | STAT_DEV_RESET | STAT_ABORTED)) != 0) {
19563                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19564                     "sd_reset_target: no reset\n");
19565                 return;
19566         }
19567 
19568         mutex_exit(SD_MUTEX(un));
19569 
19570         if (un->un_f_allow_bus_device_reset == TRUE) {
19571                 if (un->un_f_lun_reset_enabled == TRUE) {
19572                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19573                             "sd_reset_target: RESET_LUN\n");
19574                         rval = scsi_reset(SD_ADDRESS(un), RESET_LUN);
19575                 }
19576                 if (rval == 0) {
19577                         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19578                             "sd_reset_target: RESET_TARGET\n");
19579                         rval = scsi_reset(SD_ADDRESS(un), RESET_TARGET);
19580                 }
19581         }
19582 
19583         if (rval == 0) {
19584                 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
19585                     "sd_reset_target: RESET_ALL\n");
19586                 (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
19587         }
19588 
19589         mutex_enter(SD_MUTEX(un));
19590 
19591         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reset_target: exit\n");
19592 }
19593 
19594 /*
19595  *    Function: sd_target_change_task
19596  *
19597  * Description: Handle dynamic target change
19598  *
19599  *     Context: Executes in a taskq() thread context
19600  */
19601 static void
19602 sd_target_change_task(void *arg)
19603 {
19604         struct sd_lun           *un = arg;
19605         uint64_t                capacity;
19606         diskaddr_t              label_cap;
19607         uint_t                  lbasize;
19608         sd_ssc_t                *ssc;
19609 
19610         ASSERT(un != NULL);
19611         ASSERT(!mutex_owned(SD_MUTEX(un)));
19612 
19613         if ((un->un_f_blockcount_is_valid == FALSE) ||
19614             (un->un_f_tgt_blocksize_is_valid == FALSE)) {
19615                 return;
19616         }
19617 
19618         ssc = sd_ssc_init(un);
19619 
19620         if (sd_send_scsi_READ_CAPACITY(ssc, &capacity,
19621             &lbasize, SD_PATH_DIRECT) != 0) {
19622                 SD_ERROR(SD_LOG_ERROR, un,
19623                     "sd_target_change_task: fail to read capacity\n");
19624                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
19625                 goto task_exit;
19626         }
19627 
19628         mutex_enter(SD_MUTEX(un));
19629         if (capacity <= un->un_blockcount) {
19630                 mutex_exit(SD_MUTEX(un));
19631                 goto task_exit;
19632         }
19633 
19634         sd_update_block_info(un, lbasize, capacity);
19635         mutex_exit(SD_MUTEX(un));
19636 
19637         /*
19638          * If lun is EFI labeled and lun capacity is greater than the
19639          * capacity contained in the label, log a sys event.
19640          */
19641         if (cmlb_efi_label_capacity(un->un_cmlbhandle, &label_cap,
19642             (void*)SD_PATH_DIRECT) == 0) {
19643                 mutex_enter(SD_MUTEX(un));
19644                 if (un->un_f_blockcount_is_valid &&
19645                     un->un_blockcount > label_cap) {
19646                         mutex_exit(SD_MUTEX(un));
19647                         sd_log_lun_expansion_event(un, KM_SLEEP);
19648                 } else {
19649                         mutex_exit(SD_MUTEX(un));
19650                 }
19651         }
19652 
19653 task_exit:
19654         sd_ssc_fini(ssc);
19655 }
19656 
19657 
19658 /*
19659  *    Function: sd_log_dev_status_event
19660  *
19661  * Description: Log EC_dev_status sysevent
19662  *
19663  *     Context: Never called from interrupt context
19664  */
19665 static void
19666 sd_log_dev_status_event(struct sd_lun *un, char *esc, int km_flag)
19667 {
19668         int err;
19669         char                    *path;
19670         nvlist_t                *attr_list;
19671 
19672         /* Allocate and build sysevent attribute list */
19673         err = nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, km_flag);
19674         if (err != 0) {
19675                 SD_ERROR(SD_LOG_ERROR, un,
19676                     "sd_log_dev_status_event: fail to allocate space\n");
19677                 return;
19678         }
19679 
19680         path = kmem_alloc(MAXPATHLEN, km_flag);
19681         if (path == NULL) {
19682                 nvlist_free(attr_list);
19683                 SD_ERROR(SD_LOG_ERROR, un,
19684                     "sd_log_dev_status_event: fail to allocate space\n");
19685                 return;
19686         }
19687         /*
19688          * Add path attribute to identify the lun.
19689          * We are using minor node 'a' as the sysevent attribute.
19690          */
19691         (void) snprintf(path, MAXPATHLEN, "/devices");
19692         (void) ddi_pathname(SD_DEVINFO(un), path + strlen(path));
19693         (void) snprintf(path + strlen(path), MAXPATHLEN - strlen(path),
19694             ":a");
19695 
19696         err = nvlist_add_string(attr_list, DEV_PHYS_PATH, path);
19697         if (err != 0) {
19698                 nvlist_free(attr_list);
19699                 kmem_free(path, MAXPATHLEN);
19700                 SD_ERROR(SD_LOG_ERROR, un,
19701                     "sd_log_dev_status_event: fail to add attribute\n");
19702                 return;
19703         }
19704 
19705         /* Log dynamic lun expansion sysevent */
19706         err = ddi_log_sysevent(SD_DEVINFO(un), SUNW_VENDOR, EC_DEV_STATUS,
19707             esc, attr_list, NULL, km_flag);
19708         if (err != DDI_SUCCESS) {
19709                 SD_ERROR(SD_LOG_ERROR, un,
19710                     "sd_log_dev_status_event: fail to log sysevent\n");
19711         }
19712 
19713         nvlist_free(attr_list);
19714         kmem_free(path, MAXPATHLEN);
19715 }
19716 
19717 
19718 /*
19719  *    Function: sd_log_lun_expansion_event
19720  *
19721  * Description: Log lun expansion sys event
19722  *
19723  *     Context: Never called from interrupt context
19724  */
19725 static void
19726 sd_log_lun_expansion_event(struct sd_lun *un, int km_flag)
19727 {
19728         sd_log_dev_status_event(un, ESC_DEV_DLE, km_flag);
19729 }
19730 
19731 
19732 /*
19733  *    Function: sd_log_eject_request_event
19734  *
19735  * Description: Log eject request sysevent
19736  *
19737  *     Context: Never called from interrupt context
19738  */
19739 static void
19740 sd_log_eject_request_event(struct sd_lun *un, int km_flag)
19741 {
19742         sd_log_dev_status_event(un, ESC_DEV_EJECT_REQUEST, km_flag);
19743 }
19744 
19745 
19746 /*
19747  *    Function: sd_media_change_task
19748  *
19749  * Description: Recovery action for CDROM to become available.
19750  *
19751  *     Context: Executes in a taskq() thread context
19752  */
19753 
19754 static void
19755 sd_media_change_task(void *arg)
19756 {
19757         struct  scsi_pkt        *pktp = arg;
19758         struct  sd_lun          *un;
19759         struct  buf             *bp;
19760         struct  sd_xbuf         *xp;
19761         int     err             = 0;
19762         int     retry_count     = 0;
19763         int     retry_limit     = SD_UNIT_ATTENTION_RETRY/10;
19764         struct  sd_sense_info   si;
19765 
19766         ASSERT(pktp != NULL);
19767         bp = (struct buf *)pktp->pkt_private;
19768         ASSERT(bp != NULL);
19769         xp = SD_GET_XBUF(bp);
19770         ASSERT(xp != NULL);
19771         un = SD_GET_UN(bp);
19772         ASSERT(un != NULL);
19773         ASSERT(!mutex_owned(SD_MUTEX(un)));
19774         ASSERT(un->un_f_monitor_media_state);
19775 
19776         si.ssi_severity = SCSI_ERR_INFO;
19777         si.ssi_pfa_flag = FALSE;
19778 
19779         /*
19780          * When a reset is issued on a CDROM, it takes a long time to
19781          * recover. First few attempts to read capacity and other things
19782          * related to handling unit attention fail (with a ASC 0x4 and
19783          * ASCQ 0x1). In that case we want to do enough retries and we want
19784          * to limit the retries in other cases of genuine failures like
19785          * no media in drive.
19786          */
19787         while (retry_count++ < retry_limit) {
19788                 if ((err = sd_handle_mchange(un)) == 0) {
19789                         break;
19790                 }
19791                 if (err == EAGAIN) {
19792                         retry_limit = SD_UNIT_ATTENTION_RETRY;
19793                 }
19794                 /* Sleep for 0.5 sec. & try again */
19795                 delay(drv_usectohz(500000));
19796         }
19797 
19798         /*
19799          * Dispatch (retry or fail) the original command here,
19800          * along with appropriate console messages....
19801          *
19802          * Must grab the mutex before calling sd_retry_command,
19803          * sd_print_sense_msg and sd_return_failed_command.
19804          */
19805         mutex_enter(SD_MUTEX(un));
19806         if (err != SD_CMD_SUCCESS) {
19807                 SD_UPDATE_ERRSTATS(un, sd_harderrs);
19808                 SD_UPDATE_ERRSTATS(un, sd_rq_nodev_err);
19809                 si.ssi_severity = SCSI_ERR_FATAL;
19810                 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED);
19811                 sd_return_failed_command(un, bp, EIO);
19812         } else {
19813                 sd_retry_command(un, bp, SD_RETRIES_UA, sd_print_sense_msg,
19814                     &si, EIO, (clock_t)0, NULL);
19815         }
19816         mutex_exit(SD_MUTEX(un));
19817 }
19818 
19819 
19820 
19821 /*
19822  *    Function: sd_handle_mchange
19823  *
19824  * Description: Perform geometry validation & other recovery when CDROM
19825  *              has been removed from drive.
19826  *
19827  * Return Code: 0 for success
19828  *              errno-type return code of either sd_send_scsi_DOORLOCK() or
19829  *              sd_send_scsi_READ_CAPACITY()
19830  *
19831  *     Context: Executes in a taskq() thread context
19832  */
19833 
19834 static int
19835 sd_handle_mchange(struct sd_lun *un)
19836 {
19837         uint64_t        capacity;
19838         uint32_t        lbasize;
19839         int             rval;
19840         sd_ssc_t        *ssc;
19841 
19842         ASSERT(!mutex_owned(SD_MUTEX(un)));
19843         ASSERT(un->un_f_monitor_media_state);
19844 
19845         ssc = sd_ssc_init(un);
19846         rval = sd_send_scsi_READ_CAPACITY(ssc, &capacity, &lbasize,
19847             SD_PATH_DIRECT_PRIORITY);
19848 
19849         if (rval != 0)
19850                 goto failed;
19851 
19852         mutex_enter(SD_MUTEX(un));
19853         sd_update_block_info(un, lbasize, capacity);
19854 
19855         if (un->un_errstats != NULL) {
19856                 struct  sd_errstats *stp =
19857                     (struct sd_errstats *)un->un_errstats->ks_data;
19858                 stp->sd_capacity.value.ui64 = (uint64_t)
19859                     ((uint64_t)un->un_blockcount *
19860                     (uint64_t)un->un_tgt_blocksize);
19861         }
19862 
19863         /*
19864          * Check if the media in the device is writable or not
19865          */
19866         if (ISCD(un)) {
19867                 sd_check_for_writable_cd(ssc, SD_PATH_DIRECT_PRIORITY);
19868         }
19869 
19870         /*
19871          * Note: Maybe let the strategy/partitioning chain worry about getting
19872          * valid geometry.
19873          */
19874         mutex_exit(SD_MUTEX(un));
19875         cmlb_invalidate(un->un_cmlbhandle, (void *)SD_PATH_DIRECT_PRIORITY);
19876 
19877 
19878         if (cmlb_validate(un->un_cmlbhandle, 0,
19879             (void *)SD_PATH_DIRECT_PRIORITY) != 0) {
19880                 sd_ssc_fini(ssc);
19881                 return (EIO);
19882         } else {
19883                 if (un->un_f_pkstats_enabled) {
19884                         sd_set_pstats(un);
19885                         SD_TRACE(SD_LOG_IO_PARTITION, un,
19886                             "sd_handle_mchange: un:0x%p pstats created and "
19887                             "set\n", un);
19888                 }
19889         }
19890 
19891         /*
19892          * Try to lock the door
19893          */
19894         rval = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_PREVENT,
19895             SD_PATH_DIRECT_PRIORITY);
19896 failed:
19897         if (rval != 0)
19898                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
19899         sd_ssc_fini(ssc);
19900         return (rval);
19901 }
19902 
19903 
19904 /*
19905  *    Function: sd_send_scsi_DOORLOCK
19906  *
19907  * Description: Issue the scsi DOOR LOCK command
19908  *
19909  *   Arguments: ssc   - ssc contains pointer to driver soft state (unit)
19910  *                      structure for this target.
19911  *              flag  - SD_REMOVAL_ALLOW
19912  *                      SD_REMOVAL_PREVENT
19913  *              path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
19914  *                      the normal command waitq, or SD_PATH_DIRECT_PRIORITY
19915  *                      to use the USCSI "direct" chain and bypass the normal
19916  *                      command waitq. SD_PATH_DIRECT_PRIORITY is used when this
19917  *                      command is issued as part of an error recovery action.
19918  *
19919  * Return Code: 0   - Success
19920  *              errno return code from sd_ssc_send()
19921  *
19922  *     Context: Can sleep.
19923  */
19924 
19925 static int
19926 sd_send_scsi_DOORLOCK(sd_ssc_t *ssc, int flag, int path_flag)
19927 {
19928         struct scsi_extended_sense      sense_buf;
19929         union scsi_cdb          cdb;
19930         struct uscsi_cmd        ucmd_buf;
19931         int                     status;
19932         struct sd_lun           *un;
19933 
19934         ASSERT(ssc != NULL);
19935         un = ssc->ssc_un;
19936         ASSERT(un != NULL);
19937         ASSERT(!mutex_owned(SD_MUTEX(un)));
19938 
19939         SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_DOORLOCK: entry: un:0x%p\n", un);
19940 
19941         /* already determined doorlock is not supported, fake success */
19942         if (un->un_f_doorlock_supported == FALSE) {
19943                 return (0);
19944         }
19945 
19946         /*
19947          * If we are ejecting and see an SD_REMOVAL_PREVENT
19948          * ignore the command so we can complete the eject
19949          * operation.
19950          */
19951         if (flag == SD_REMOVAL_PREVENT) {
19952                 mutex_enter(SD_MUTEX(un));
19953                 if (un->un_f_ejecting == TRUE) {
19954                         mutex_exit(SD_MUTEX(un));
19955                         return (EAGAIN);
19956                 }
19957                 mutex_exit(SD_MUTEX(un));
19958         }
19959 
19960         bzero(&cdb, sizeof (cdb));
19961         bzero(&ucmd_buf, sizeof (ucmd_buf));
19962 
19963         cdb.scc_cmd = SCMD_DOORLOCK;
19964         cdb.cdb_opaque[4] = (uchar_t)flag;
19965 
19966         ucmd_buf.uscsi_cdb      = (char *)&cdb;
19967         ucmd_buf.uscsi_cdblen   = CDB_GROUP0;
19968         ucmd_buf.uscsi_bufaddr  = NULL;
19969         ucmd_buf.uscsi_buflen   = 0;
19970         ucmd_buf.uscsi_rqbuf    = (caddr_t)&sense_buf;
19971         ucmd_buf.uscsi_rqlen    = sizeof (sense_buf);
19972         ucmd_buf.uscsi_flags    = USCSI_RQENABLE | USCSI_SILENT;
19973         ucmd_buf.uscsi_timeout  = 15;
19974 
19975         SD_TRACE(SD_LOG_IO, un,
19976             "sd_send_scsi_DOORLOCK: returning sd_ssc_send\n");
19977 
19978         status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
19979             UIO_SYSSPACE, path_flag);
19980 
19981         if (status == 0)
19982                 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
19983 
19984         if ((status == EIO) && (ucmd_buf.uscsi_status == STATUS_CHECK) &&
19985             (ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
19986             (scsi_sense_key((uint8_t *)&sense_buf) == KEY_ILLEGAL_REQUEST)) {
19987                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
19988 
19989                 /* fake success and skip subsequent doorlock commands */
19990                 un->un_f_doorlock_supported = FALSE;
19991                 return (0);
19992         }
19993 
19994         return (status);
19995 }
19996 
19997 /*
19998  *    Function: sd_send_scsi_READ_CAPACITY
19999  *
20000  * Description: This routine uses the scsi READ CAPACITY command to determine
20001  *              the device capacity in number of blocks and the device native
20002  *              block size. If this function returns a failure, then the
20003  *              values in *capp and *lbap are undefined.  If the capacity
20004  *              returned is 0xffffffff then the lun is too large for a
20005  *              normal READ CAPACITY command and the results of a
20006  *              READ CAPACITY 16 will be used instead.
20007  *
20008  *   Arguments: ssc   - ssc contains ptr to soft state struct for the target
20009  *              capp - ptr to unsigned 64-bit variable to receive the
20010  *                      capacity value from the command.
20011  *              lbap - ptr to unsigned 32-bit varaible to receive the
20012  *                      block size value from the command
20013  *              path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
20014  *                      the normal command waitq, or SD_PATH_DIRECT_PRIORITY
20015  *                      to use the USCSI "direct" chain and bypass the normal
20016  *                      command waitq. SD_PATH_DIRECT_PRIORITY is used when this
20017  *                      command is issued as part of an error recovery action.
20018  *
20019  * Return Code: 0   - Success
20020  *              EIO - IO error
20021  *              EACCES - Reservation conflict detected
20022  *              EAGAIN - Device is becoming ready
20023  *              errno return code from sd_ssc_send()
20024  *
20025  *     Context: Can sleep.  Blocks until command completes.
20026  */
20027 
20028 #define SD_CAPACITY_SIZE        sizeof (struct scsi_capacity)
20029 
20030 static int
20031 sd_send_scsi_READ_CAPACITY(sd_ssc_t *ssc, uint64_t *capp, uint32_t *lbap,
20032         int path_flag)
20033 {
20034         struct  scsi_extended_sense     sense_buf;
20035         struct  uscsi_cmd       ucmd_buf;
20036         union   scsi_cdb        cdb;
20037         uint32_t                *capacity_buf;
20038         uint64_t                capacity;
20039         uint32_t                lbasize;
20040         uint32_t                pbsize;
20041         int                     status;
20042         struct sd_lun           *un;
20043 
20044         ASSERT(ssc != NULL);
20045 
20046         un = ssc->ssc_un;
20047         ASSERT(un != NULL);
20048         ASSERT(!mutex_owned(SD_MUTEX(un)));
20049         ASSERT(capp != NULL);
20050         ASSERT(lbap != NULL);
20051 
20052         SD_TRACE(SD_LOG_IO, un,
20053             "sd_send_scsi_READ_CAPACITY: entry: un:0x%p\n", un);
20054 
20055         /*
20056          * First send a READ_CAPACITY command to the target.
20057          * (This command is mandatory under SCSI-2.)
20058          *
20059          * Set up the CDB for the READ_CAPACITY command.  The Partial
20060          * Medium Indicator bit is cleared.  The address field must be
20061          * zero if the PMI bit is zero.
20062          */
20063         bzero(&cdb, sizeof (cdb));
20064         bzero(&ucmd_buf, sizeof (ucmd_buf));
20065 
20066         capacity_buf = kmem_zalloc(SD_CAPACITY_SIZE, KM_SLEEP);
20067 
20068         cdb.scc_cmd = SCMD_READ_CAPACITY;
20069 
20070         ucmd_buf.uscsi_cdb      = (char *)&cdb;
20071         ucmd_buf.uscsi_cdblen   = CDB_GROUP1;
20072         ucmd_buf.uscsi_bufaddr  = (caddr_t)capacity_buf;
20073         ucmd_buf.uscsi_buflen   = SD_CAPACITY_SIZE;
20074         ucmd_buf.uscsi_rqbuf    = (caddr_t)&sense_buf;
20075         ucmd_buf.uscsi_rqlen    = sizeof (sense_buf);
20076         ucmd_buf.uscsi_flags    = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
20077         ucmd_buf.uscsi_timeout  = 60;
20078 
20079         status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20080             UIO_SYSSPACE, path_flag);
20081 
20082         switch (status) {
20083         case 0:
20084                 /* Return failure if we did not get valid capacity data. */
20085                 if (ucmd_buf.uscsi_resid != 0) {
20086                         sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
20087                             "sd_send_scsi_READ_CAPACITY received invalid "
20088                             "capacity data");
20089                         kmem_free(capacity_buf, SD_CAPACITY_SIZE);
20090                         return (EIO);
20091                 }
20092                 /*
20093                  * Read capacity and block size from the READ CAPACITY 10 data.
20094                  * This data may be adjusted later due to device specific
20095                  * issues.
20096                  *
20097                  * According to the SCSI spec, the READ CAPACITY 10
20098                  * command returns the following:
20099                  *
20100                  *  bytes 0-3: Maximum logical block address available.
20101                  *              (MSB in byte:0 & LSB in byte:3)
20102                  *
20103                  *  bytes 4-7: Block length in bytes
20104                  *              (MSB in byte:4 & LSB in byte:7)
20105                  *
20106                  */
20107                 capacity = BE_32(capacity_buf[0]);
20108                 lbasize = BE_32(capacity_buf[1]);
20109 
20110                 /*
20111                  * Done with capacity_buf
20112                  */
20113                 kmem_free(capacity_buf, SD_CAPACITY_SIZE);
20114 
20115                 /*
20116                  * if the reported capacity is set to all 0xf's, then
20117                  * this disk is too large and requires SBC-2 commands.
20118                  * Reissue the request using READ CAPACITY 16.
20119                  */
20120                 if (capacity == 0xffffffff) {
20121                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
20122                         status = sd_send_scsi_READ_CAPACITY_16(ssc, &capacity,
20123                             &lbasize, &pbsize, path_flag);
20124                         if (status != 0) {
20125                                 return (status);
20126                         } else {
20127                                 goto rc16_done;
20128                         }
20129                 }
20130                 break;  /* Success! */
20131         case EIO:
20132                 switch (ucmd_buf.uscsi_status) {
20133                 case STATUS_RESERVATION_CONFLICT:
20134                         status = EACCES;
20135                         break;
20136                 case STATUS_CHECK:
20137                         /*
20138                          * Check condition; look for ASC/ASCQ of 0x04/0x01
20139                          * (LOGICAL UNIT IS IN PROCESS OF BECOMING READY)
20140                          */
20141                         if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
20142                             (scsi_sense_asc((uint8_t *)&sense_buf) == 0x04) &&
20143                             (scsi_sense_ascq((uint8_t *)&sense_buf) == 0x01)) {
20144                                 kmem_free(capacity_buf, SD_CAPACITY_SIZE);
20145                                 return (EAGAIN);
20146                         }
20147                         break;
20148                 default:
20149                         break;
20150                 }
20151                 /* FALLTHRU */
20152         default:
20153                 kmem_free(capacity_buf, SD_CAPACITY_SIZE);
20154                 return (status);
20155         }
20156 
20157         /*
20158          * Some ATAPI CD-ROM drives report inaccurate LBA size values
20159          * (2352 and 0 are common) so for these devices always force the value
20160          * to 2048 as required by the ATAPI specs.
20161          */
20162         if ((un->un_f_cfg_is_atapi == TRUE) && (ISCD(un))) {
20163                 lbasize = 2048;
20164         }
20165 
20166         /*
20167          * Get the maximum LBA value from the READ CAPACITY data.
20168          * Here we assume that the Partial Medium Indicator (PMI) bit
20169          * was cleared when issuing the command. This means that the LBA
20170          * returned from the device is the LBA of the last logical block
20171          * on the logical unit.  The actual logical block count will be
20172          * this value plus one.
20173          */
20174         capacity += 1;
20175 
20176         /*
20177          * Currently, for removable media, the capacity is saved in terms
20178          * of un->un_sys_blocksize, so scale the capacity value to reflect this.
20179          */
20180         if (un->un_f_has_removable_media)
20181                 capacity *= (lbasize / un->un_sys_blocksize);
20182 
20183 rc16_done:
20184 
20185         /*
20186          * Copy the values from the READ CAPACITY command into the space
20187          * provided by the caller.
20188          */
20189         *capp = capacity;
20190         *lbap = lbasize;
20191 
20192         SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_READ_CAPACITY: "
20193             "capacity:0x%llx  lbasize:0x%x\n", capacity, lbasize);
20194 
20195         /*
20196          * Both the lbasize and capacity from the device must be nonzero,
20197          * otherwise we assume that the values are not valid and return
20198          * failure to the caller. (4203735)
20199          */
20200         if ((capacity == 0) || (lbasize == 0)) {
20201                 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
20202                     "sd_send_scsi_READ_CAPACITY received invalid value "
20203                     "capacity %llu lbasize %d", capacity, lbasize);
20204                 return (EIO);
20205         }
20206         sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20207         return (0);
20208 }
20209 
20210 /*
20211  *    Function: sd_send_scsi_READ_CAPACITY_16
20212  *
20213  * Description: This routine uses the scsi READ CAPACITY 16 command to
20214  *              determine the device capacity in number of blocks and the
20215  *              device native block size.  If this function returns a failure,
20216  *              then the values in *capp and *lbap are undefined.
20217  *              This routine should be called by sd_send_scsi_READ_CAPACITY
20218  *              which will apply any device specific adjustments to capacity
20219  *              and lbasize. One exception is it is also called by
20220  *              sd_get_media_info_ext. In that function, there is no need to
20221  *              adjust the capacity and lbasize.
20222  *
20223  *   Arguments: ssc   - ssc contains ptr to soft state struct for the target
20224  *              capp - ptr to unsigned 64-bit variable to receive the
20225  *                      capacity value from the command.
20226  *              lbap - ptr to unsigned 32-bit varaible to receive the
20227  *                      block size value from the command
20228  *              psp  - ptr to unsigned 32-bit variable to receive the
20229  *                      physical block size value from the command
20230  *              path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
20231  *                      the normal command waitq, or SD_PATH_DIRECT_PRIORITY
20232  *                      to use the USCSI "direct" chain and bypass the normal
20233  *                      command waitq. SD_PATH_DIRECT_PRIORITY is used when
20234  *                      this command is issued as part of an error recovery
20235  *                      action.
20236  *
20237  * Return Code: 0   - Success
20238  *              EIO - IO error
20239  *              EACCES - Reservation conflict detected
20240  *              EAGAIN - Device is becoming ready
20241  *              errno return code from sd_ssc_send()
20242  *
20243  *     Context: Can sleep.  Blocks until command completes.
20244  */
20245 
20246 #define SD_CAPACITY_16_SIZE     sizeof (struct scsi_capacity_16)
20247 
20248 static int
20249 sd_send_scsi_READ_CAPACITY_16(sd_ssc_t *ssc, uint64_t *capp,
20250         uint32_t *lbap, uint32_t *psp, int path_flag)
20251 {
20252         struct  scsi_extended_sense     sense_buf;
20253         struct  uscsi_cmd       ucmd_buf;
20254         union   scsi_cdb        cdb;
20255         uint64_t                *capacity16_buf;
20256         uint64_t                capacity;
20257         uint32_t                lbasize;
20258         uint32_t                pbsize;
20259         uint32_t                lbpb_exp;
20260         int                     status;
20261         struct sd_lun           *un;
20262 
20263         ASSERT(ssc != NULL);
20264 
20265         un = ssc->ssc_un;
20266         ASSERT(un != NULL);
20267         ASSERT(!mutex_owned(SD_MUTEX(un)));
20268         ASSERT(capp != NULL);
20269         ASSERT(lbap != NULL);
20270 
20271         SD_TRACE(SD_LOG_IO, un,
20272             "sd_send_scsi_READ_CAPACITY: entry: un:0x%p\n", un);
20273 
20274         /*
20275          * First send a READ_CAPACITY_16 command to the target.
20276          *
20277          * Set up the CDB for the READ_CAPACITY_16 command.  The Partial
20278          * Medium Indicator bit is cleared.  The address field must be
20279          * zero if the PMI bit is zero.
20280          */
20281         bzero(&cdb, sizeof (cdb));
20282         bzero(&ucmd_buf, sizeof (ucmd_buf));
20283 
20284         capacity16_buf = kmem_zalloc(SD_CAPACITY_16_SIZE, KM_SLEEP);
20285 
20286         ucmd_buf.uscsi_cdb      = (char *)&cdb;
20287         ucmd_buf.uscsi_cdblen   = CDB_GROUP4;
20288         ucmd_buf.uscsi_bufaddr  = (caddr_t)capacity16_buf;
20289         ucmd_buf.uscsi_buflen   = SD_CAPACITY_16_SIZE;
20290         ucmd_buf.uscsi_rqbuf    = (caddr_t)&sense_buf;
20291         ucmd_buf.uscsi_rqlen    = sizeof (sense_buf);
20292         ucmd_buf.uscsi_flags    = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
20293         ucmd_buf.uscsi_timeout  = 60;
20294 
20295         /*
20296          * Read Capacity (16) is a Service Action In command.  One
20297          * command byte (0x9E) is overloaded for multiple operations,
20298          * with the second CDB byte specifying the desired operation
20299          */
20300         cdb.scc_cmd = SCMD_SVC_ACTION_IN_G4;
20301         cdb.cdb_opaque[1] = SSVC_ACTION_READ_CAPACITY_G4;
20302 
20303         /*
20304          * Fill in allocation length field
20305          */
20306         FORMG4COUNT(&cdb, ucmd_buf.uscsi_buflen);
20307 
20308         status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20309             UIO_SYSSPACE, path_flag);
20310 
20311         switch (status) {
20312         case 0:
20313                 /* Return failure if we did not get valid capacity data. */
20314                 if (ucmd_buf.uscsi_resid > 20) {
20315                         sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
20316                             "sd_send_scsi_READ_CAPACITY_16 received invalid "
20317                             "capacity data");
20318                         kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE);
20319                         return (EIO);
20320                 }
20321 
20322                 /*
20323                  * Read capacity and block size from the READ CAPACITY 16 data.
20324                  * This data may be adjusted later due to device specific
20325                  * issues.
20326                  *
20327                  * According to the SCSI spec, the READ CAPACITY 16
20328                  * command returns the following:
20329                  *
20330                  *  bytes 0-7: Maximum logical block address available.
20331                  *              (MSB in byte:0 & LSB in byte:7)
20332                  *
20333                  *  bytes 8-11: Block length in bytes
20334                  *              (MSB in byte:8 & LSB in byte:11)
20335                  *
20336                  *  byte 13: LOGICAL BLOCKS PER PHYSICAL BLOCK EXPONENT
20337                  */
20338                 capacity = BE_64(capacity16_buf[0]);
20339                 lbasize = BE_32(*(uint32_t *)&capacity16_buf[1]);
20340                 lbpb_exp = (BE_64(capacity16_buf[1]) >> 16) & 0x0f;
20341 
20342                 pbsize = lbasize << lbpb_exp;
20343 
20344                 /*
20345                  * Done with capacity16_buf
20346                  */
20347                 kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE);
20348 
20349                 /*
20350                  * if the reported capacity is set to all 0xf's, then
20351                  * this disk is too large.  This could only happen with
20352                  * a device that supports LBAs larger than 64 bits which
20353                  * are not defined by any current T10 standards.
20354                  */
20355                 if (capacity == 0xffffffffffffffff) {
20356                         sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
20357                             "disk is too large");
20358                         return (EIO);
20359                 }
20360                 break;  /* Success! */
20361         case EIO:
20362                 switch (ucmd_buf.uscsi_status) {
20363                 case STATUS_RESERVATION_CONFLICT:
20364                         status = EACCES;
20365                         break;
20366                 case STATUS_CHECK:
20367                         /*
20368                          * Check condition; look for ASC/ASCQ of 0x04/0x01
20369                          * (LOGICAL UNIT IS IN PROCESS OF BECOMING READY)
20370                          */
20371                         if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
20372                             (scsi_sense_asc((uint8_t *)&sense_buf) == 0x04) &&
20373                             (scsi_sense_ascq((uint8_t *)&sense_buf) == 0x01)) {
20374                                 kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE);
20375                                 return (EAGAIN);
20376                         }
20377                         break;
20378                 default:
20379                         break;
20380                 }
20381                 /* FALLTHRU */
20382         default:
20383                 kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE);
20384                 return (status);
20385         }
20386 
20387         /*
20388          * Some ATAPI CD-ROM drives report inaccurate LBA size values
20389          * (2352 and 0 are common) so for these devices always force the value
20390          * to 2048 as required by the ATAPI specs.
20391          */
20392         if ((un->un_f_cfg_is_atapi == TRUE) && (ISCD(un))) {
20393                 lbasize = 2048;
20394         }
20395 
20396         /*
20397          * Get the maximum LBA value from the READ CAPACITY 16 data.
20398          * Here we assume that the Partial Medium Indicator (PMI) bit
20399          * was cleared when issuing the command. This means that the LBA
20400          * returned from the device is the LBA of the last logical block
20401          * on the logical unit.  The actual logical block count will be
20402          * this value plus one.
20403          */
20404         capacity += 1;
20405 
20406         /*
20407          * Currently, for removable media, the capacity is saved in terms
20408          * of un->un_sys_blocksize, so scale the capacity value to reflect this.
20409          */
20410         if (un->un_f_has_removable_media)
20411                 capacity *= (lbasize / un->un_sys_blocksize);
20412 
20413         *capp = capacity;
20414         *lbap = lbasize;
20415         *psp = pbsize;
20416 
20417         SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_READ_CAPACITY_16: "
20418             "capacity:0x%llx  lbasize:0x%x, pbsize: 0x%x\n",
20419             capacity, lbasize, pbsize);
20420 
20421         if ((capacity == 0) || (lbasize == 0) || (pbsize == 0)) {
20422                 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
20423                     "sd_send_scsi_READ_CAPACITY_16 received invalid value "
20424                     "capacity %llu lbasize %d pbsize %d", capacity, lbasize);
20425                 return (EIO);
20426         }
20427 
20428         sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20429         return (0);
20430 }
20431 
20432 
20433 /*
20434  *    Function: sd_send_scsi_START_STOP_UNIT
20435  *
20436  * Description: Issue a scsi START STOP UNIT command to the target.
20437  *
20438  *   Arguments: ssc    - ssc contatins pointer to driver soft state (unit)
20439  *                       structure for this target.
20440  *      pc_flag - SD_POWER_CONDITION
20441  *                SD_START_STOP
20442  *              flag  - SD_TARGET_START
20443  *                      SD_TARGET_STOP
20444  *                      SD_TARGET_EJECT
20445  *                      SD_TARGET_CLOSE
20446  *              path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
20447  *                      the normal command waitq, or SD_PATH_DIRECT_PRIORITY
20448  *                      to use the USCSI "direct" chain and bypass the normal
20449  *                      command waitq. SD_PATH_DIRECT_PRIORITY is used when this
20450  *                      command is issued as part of an error recovery action.
20451  *
20452  * Return Code: 0   - Success
20453  *              EIO - IO error
20454  *              EACCES - Reservation conflict detected
20455  *              ENXIO  - Not Ready, medium not present
20456  *              errno return code from sd_ssc_send()
20457  *
20458  *     Context: Can sleep.
20459  */
20460 
20461 static int
20462 sd_send_scsi_START_STOP_UNIT(sd_ssc_t *ssc, int pc_flag, int flag,
20463     int path_flag)
20464 {
20465         struct  scsi_extended_sense     sense_buf;
20466         union scsi_cdb          cdb;
20467         struct uscsi_cmd        ucmd_buf;
20468         int                     status;
20469         struct sd_lun           *un;
20470 
20471         ASSERT(ssc != NULL);
20472         un = ssc->ssc_un;
20473         ASSERT(un != NULL);
20474         ASSERT(!mutex_owned(SD_MUTEX(un)));
20475 
20476         SD_TRACE(SD_LOG_IO, un,
20477             "sd_send_scsi_START_STOP_UNIT: entry: un:0x%p\n", un);
20478 
20479         if (un->un_f_check_start_stop &&
20480             (pc_flag == SD_START_STOP) &&
20481             ((flag == SD_TARGET_START) || (flag == SD_TARGET_STOP)) &&
20482             (un->un_f_start_stop_supported != TRUE)) {
20483                 return (0);
20484         }
20485 
20486         /*
20487          * If we are performing an eject operation and
20488          * we receive any command other than SD_TARGET_EJECT
20489          * we should immediately return.
20490          */
20491         if (flag != SD_TARGET_EJECT) {
20492                 mutex_enter(SD_MUTEX(un));
20493                 if (un->un_f_ejecting == TRUE) {
20494                         mutex_exit(SD_MUTEX(un));
20495                         return (EAGAIN);
20496                 }
20497                 mutex_exit(SD_MUTEX(un));
20498         }
20499 
20500         bzero(&cdb, sizeof (cdb));
20501         bzero(&ucmd_buf, sizeof (ucmd_buf));
20502         bzero(&sense_buf, sizeof (struct scsi_extended_sense));
20503 
20504         cdb.scc_cmd = SCMD_START_STOP;
20505         cdb.cdb_opaque[4] = (pc_flag == SD_POWER_CONDITION) ?
20506             (uchar_t)(flag << 4) : (uchar_t)flag;
20507 
20508         ucmd_buf.uscsi_cdb      = (char *)&cdb;
20509         ucmd_buf.uscsi_cdblen   = CDB_GROUP0;
20510         ucmd_buf.uscsi_bufaddr  = NULL;
20511         ucmd_buf.uscsi_buflen   = 0;
20512         ucmd_buf.uscsi_rqbuf    = (caddr_t)&sense_buf;
20513         ucmd_buf.uscsi_rqlen    = sizeof (struct scsi_extended_sense);
20514         ucmd_buf.uscsi_flags    = USCSI_RQENABLE | USCSI_SILENT;
20515         ucmd_buf.uscsi_timeout  = 200;
20516 
20517         status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20518             UIO_SYSSPACE, path_flag);
20519 
20520         switch (status) {
20521         case 0:
20522                 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20523                 break;  /* Success! */
20524         case EIO:
20525                 switch (ucmd_buf.uscsi_status) {
20526                 case STATUS_RESERVATION_CONFLICT:
20527                         status = EACCES;
20528                         break;
20529                 case STATUS_CHECK:
20530                         if (ucmd_buf.uscsi_rqstatus == STATUS_GOOD) {
20531                                 switch (scsi_sense_key(
20532                                     (uint8_t *)&sense_buf)) {
20533                                 case KEY_ILLEGAL_REQUEST:
20534                                         status = ENOTSUP;
20535                                         break;
20536                                 case KEY_NOT_READY:
20537                                         if (scsi_sense_asc(
20538                                             (uint8_t *)&sense_buf)
20539                                             == 0x3A) {
20540                                                 status = ENXIO;
20541                                         }
20542                                         break;
20543                                 default:
20544                                         break;
20545                                 }
20546                         }
20547                         break;
20548                 default:
20549                         break;
20550                 }
20551                 break;
20552         default:
20553                 break;
20554         }
20555 
20556         SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_START_STOP_UNIT: exit\n");
20557 
20558         return (status);
20559 }
20560 
20561 
20562 /*
20563  *    Function: sd_start_stop_unit_callback
20564  *
20565  * Description: timeout(9F) callback to begin recovery process for a
20566  *              device that has spun down.
20567  *
20568  *   Arguments: arg - pointer to associated softstate struct.
20569  *
20570  *     Context: Executes in a timeout(9F) thread context
20571  */
20572 
20573 static void
20574 sd_start_stop_unit_callback(void *arg)
20575 {
20576         struct sd_lun   *un = arg;
20577         ASSERT(un != NULL);
20578         ASSERT(!mutex_owned(SD_MUTEX(un)));
20579 
20580         SD_TRACE(SD_LOG_IO, un, "sd_start_stop_unit_callback: entry\n");
20581 
20582         (void) taskq_dispatch(sd_tq, sd_start_stop_unit_task, un, KM_NOSLEEP);
20583 }
20584 
20585 
20586 /*
20587  *    Function: sd_start_stop_unit_task
20588  *
20589  * Description: Recovery procedure when a drive is spun down.
20590  *
20591  *   Arguments: arg - pointer to associated softstate struct.
20592  *
20593  *     Context: Executes in a taskq() thread context
20594  */
20595 
20596 static void
20597 sd_start_stop_unit_task(void *arg)
20598 {
20599         struct sd_lun   *un = arg;
20600         sd_ssc_t        *ssc;
20601         int             power_level;
20602         int             rval;
20603 
20604         ASSERT(un != NULL);
20605         ASSERT(!mutex_owned(SD_MUTEX(un)));
20606 
20607         SD_TRACE(SD_LOG_IO, un, "sd_start_stop_unit_task: entry\n");
20608 
20609         /*
20610          * Some unformatted drives report not ready error, no need to
20611          * restart if format has been initiated.
20612          */
20613         mutex_enter(SD_MUTEX(un));
20614         if (un->un_f_format_in_progress == TRUE) {
20615                 mutex_exit(SD_MUTEX(un));
20616                 return;
20617         }
20618         mutex_exit(SD_MUTEX(un));
20619 
20620         ssc = sd_ssc_init(un);
20621         /*
20622          * When a START STOP command is issued from here, it is part of a
20623          * failure recovery operation and must be issued before any other
20624          * commands, including any pending retries. Thus it must be sent
20625          * using SD_PATH_DIRECT_PRIORITY. It doesn't matter if the spin up
20626          * succeeds or not, we will start I/O after the attempt.
20627          * If power condition is supported and the current power level
20628          * is capable of performing I/O, we should set the power condition
20629          * to that level. Otherwise, set the power condition to ACTIVE.
20630          */
20631         if (un->un_f_power_condition_supported) {
20632                 mutex_enter(SD_MUTEX(un));
20633                 ASSERT(SD_PM_IS_LEVEL_VALID(un, un->un_power_level));
20634                 power_level = sd_pwr_pc.ran_perf[un->un_power_level]
20635                     > 0 ? un->un_power_level : SD_SPINDLE_ACTIVE;
20636                 mutex_exit(SD_MUTEX(un));
20637                 rval = sd_send_scsi_START_STOP_UNIT(ssc, SD_POWER_CONDITION,
20638                     sd_pl2pc[power_level], SD_PATH_DIRECT_PRIORITY);
20639         } else {
20640                 rval = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
20641                     SD_TARGET_START, SD_PATH_DIRECT_PRIORITY);
20642         }
20643 
20644         if (rval != 0)
20645                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
20646         sd_ssc_fini(ssc);
20647         /*
20648          * The above call blocks until the START_STOP_UNIT command completes.
20649          * Now that it has completed, we must re-try the original IO that
20650          * received the NOT READY condition in the first place. There are
20651          * three possible conditions here:
20652          *
20653          *  (1) The original IO is on un_retry_bp.
20654          *  (2) The original IO is on the regular wait queue, and un_retry_bp
20655          *      is NULL.
20656          *  (3) The original IO is on the regular wait queue, and un_retry_bp
20657          *      points to some other, unrelated bp.
20658          *
20659          * For each case, we must call sd_start_cmds() with un_retry_bp
20660          * as the argument. If un_retry_bp is NULL, this will initiate
20661          * processing of the regular wait queue.  If un_retry_bp is not NULL,
20662          * then this will process the bp on un_retry_bp. That may or may not
20663          * be the original IO, but that does not matter: the important thing
20664          * is to keep the IO processing going at this point.
20665          *
20666          * Note: This is a very specific error recovery sequence associated
20667          * with a drive that is not spun up. We attempt a START_STOP_UNIT and
20668          * serialize the I/O with completion of the spin-up.
20669          */
20670         mutex_enter(SD_MUTEX(un));
20671         SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un,
20672             "sd_start_stop_unit_task: un:0x%p starting bp:0x%p\n",
20673             un, un->un_retry_bp);
20674         un->un_startstop_timeid = NULL;      /* Timeout is no longer pending */
20675         sd_start_cmds(un, un->un_retry_bp);
20676         mutex_exit(SD_MUTEX(un));
20677 
20678         SD_TRACE(SD_LOG_IO, un, "sd_start_stop_unit_task: exit\n");
20679 }
20680 
20681 
20682 /*
20683  *    Function: sd_send_scsi_INQUIRY
20684  *
20685  * Description: Issue the scsi INQUIRY command.
20686  *
20687  *   Arguments: ssc   - ssc contains pointer to driver soft state (unit)
20688  *                      structure for this target.
20689  *              bufaddr
20690  *              buflen
20691  *              evpd
20692  *              page_code
20693  *              page_length
20694  *
20695  * Return Code: 0   - Success
20696  *              errno return code from sd_ssc_send()
20697  *
20698  *     Context: Can sleep. Does not return until command is completed.
20699  */
20700 
20701 static int
20702 sd_send_scsi_INQUIRY(sd_ssc_t *ssc, uchar_t *bufaddr, size_t buflen,
20703         uchar_t evpd, uchar_t page_code, size_t *residp)
20704 {
20705         union scsi_cdb          cdb;
20706         struct uscsi_cmd        ucmd_buf;
20707         int                     status;
20708         struct sd_lun           *un;
20709 
20710         ASSERT(ssc != NULL);
20711         un = ssc->ssc_un;
20712         ASSERT(un != NULL);
20713         ASSERT(!mutex_owned(SD_MUTEX(un)));
20714         ASSERT(bufaddr != NULL);
20715 
20716         SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_INQUIRY: entry: un:0x%p\n", un);
20717 
20718         bzero(&cdb, sizeof (cdb));
20719         bzero(&ucmd_buf, sizeof (ucmd_buf));
20720         bzero(bufaddr, buflen);
20721 
20722         cdb.scc_cmd = SCMD_INQUIRY;
20723         cdb.cdb_opaque[1] = evpd;
20724         cdb.cdb_opaque[2] = page_code;
20725         FORMG0COUNT(&cdb, buflen);
20726 
20727         ucmd_buf.uscsi_cdb      = (char *)&cdb;
20728         ucmd_buf.uscsi_cdblen   = CDB_GROUP0;
20729         ucmd_buf.uscsi_bufaddr  = (caddr_t)bufaddr;
20730         ucmd_buf.uscsi_buflen   = buflen;
20731         ucmd_buf.uscsi_rqbuf    = NULL;
20732         ucmd_buf.uscsi_rqlen    = 0;
20733         ucmd_buf.uscsi_flags    = USCSI_READ | USCSI_SILENT;
20734         ucmd_buf.uscsi_timeout  = 200;  /* Excessive legacy value */
20735 
20736         status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20737             UIO_SYSSPACE, SD_PATH_DIRECT);
20738 
20739         /*
20740          * Only handle status == 0, the upper-level caller
20741          * will put different assessment based on the context.
20742          */
20743         if (status == 0)
20744                 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20745 
20746         if ((status == 0) && (residp != NULL)) {
20747                 *residp = ucmd_buf.uscsi_resid;
20748         }
20749 
20750         SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_INQUIRY: exit\n");
20751 
20752         return (status);
20753 }
20754 
20755 
20756 /*
20757  *    Function: sd_send_scsi_TEST_UNIT_READY
20758  *
20759  * Description: Issue the scsi TEST UNIT READY command.
20760  *              This routine can be told to set the flag USCSI_DIAGNOSE to
20761  *              prevent retrying failed commands. Use this when the intent
20762  *              is either to check for device readiness, to clear a Unit
20763  *              Attention, or to clear any outstanding sense data.
20764  *              However under specific conditions the expected behavior
20765  *              is for retries to bring a device ready, so use the flag
20766  *              with caution.
20767  *
20768  *   Arguments: ssc   - ssc contains pointer to driver soft state (unit)
20769  *                      structure for this target.
20770  *              flag:   SD_CHECK_FOR_MEDIA: return ENXIO if no media present
20771  *                      SD_DONT_RETRY_TUR: include uscsi flag USCSI_DIAGNOSE.
20772  *                      0: dont check for media present, do retries on cmd.
20773  *
20774  * Return Code: 0   - Success
20775  *              EIO - IO error
20776  *              EACCES - Reservation conflict detected
20777  *              ENXIO  - Not Ready, medium not present
20778  *              errno return code from sd_ssc_send()
20779  *
20780  *     Context: Can sleep. Does not return until command is completed.
20781  */
20782 
20783 static int
20784 sd_send_scsi_TEST_UNIT_READY(sd_ssc_t *ssc, int flag)
20785 {
20786         struct  scsi_extended_sense     sense_buf;
20787         union scsi_cdb          cdb;
20788         struct uscsi_cmd        ucmd_buf;
20789         int                     status;
20790         struct sd_lun           *un;
20791 
20792         ASSERT(ssc != NULL);
20793         un = ssc->ssc_un;
20794         ASSERT(un != NULL);
20795         ASSERT(!mutex_owned(SD_MUTEX(un)));
20796 
20797         SD_TRACE(SD_LOG_IO, un,
20798             "sd_send_scsi_TEST_UNIT_READY: entry: un:0x%p\n", un);
20799 
20800         /*
20801          * Some Seagate elite1 TQ devices get hung with disconnect/reconnect
20802          * timeouts when they receive a TUR and the queue is not empty. Check
20803          * the configuration flag set during attach (indicating the drive has
20804          * this firmware bug) and un_ncmds_in_transport before issuing the
20805          * TUR. If there are
20806          * pending commands return success, this is a bit arbitrary but is ok
20807          * for non-removables (i.e. the eliteI disks) and non-clustering
20808          * configurations.
20809          */
20810         if (un->un_f_cfg_tur_check == TRUE) {
20811                 mutex_enter(SD_MUTEX(un));
20812                 if (un->un_ncmds_in_transport != 0) {
20813                         mutex_exit(SD_MUTEX(un));
20814                         return (0);
20815                 }
20816                 mutex_exit(SD_MUTEX(un));
20817         }
20818 
20819         bzero(&cdb, sizeof (cdb));
20820         bzero(&ucmd_buf, sizeof (ucmd_buf));
20821         bzero(&sense_buf, sizeof (struct scsi_extended_sense));
20822 
20823         cdb.scc_cmd = SCMD_TEST_UNIT_READY;
20824 
20825         ucmd_buf.uscsi_cdb      = (char *)&cdb;
20826         ucmd_buf.uscsi_cdblen   = CDB_GROUP0;
20827         ucmd_buf.uscsi_bufaddr  = NULL;
20828         ucmd_buf.uscsi_buflen   = 0;
20829         ucmd_buf.uscsi_rqbuf    = (caddr_t)&sense_buf;
20830         ucmd_buf.uscsi_rqlen    = sizeof (struct scsi_extended_sense);
20831         ucmd_buf.uscsi_flags    = USCSI_RQENABLE | USCSI_SILENT;
20832 
20833         /* Use flag USCSI_DIAGNOSE to prevent retries if it fails. */
20834         if ((flag & SD_DONT_RETRY_TUR) != 0) {
20835                 ucmd_buf.uscsi_flags |= USCSI_DIAGNOSE;
20836         }
20837         ucmd_buf.uscsi_timeout  = 60;
20838 
20839         status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20840             UIO_SYSSPACE, ((flag & SD_BYPASS_PM) ? SD_PATH_DIRECT :
20841             SD_PATH_STANDARD));
20842 
20843         switch (status) {
20844         case 0:
20845                 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20846                 break;  /* Success! */
20847         case EIO:
20848                 switch (ucmd_buf.uscsi_status) {
20849                 case STATUS_RESERVATION_CONFLICT:
20850                         status = EACCES;
20851                         break;
20852                 case STATUS_CHECK:
20853                         if ((flag & SD_CHECK_FOR_MEDIA) == 0) {
20854                                 break;
20855                         }
20856                         if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
20857                             (scsi_sense_key((uint8_t *)&sense_buf) ==
20858                             KEY_NOT_READY) &&
20859                             (scsi_sense_asc((uint8_t *)&sense_buf) == 0x3A)) {
20860                                 status = ENXIO;
20861                         }
20862                         break;
20863                 default:
20864                         break;
20865                 }
20866                 break;
20867         default:
20868                 break;
20869         }
20870 
20871         SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_TEST_UNIT_READY: exit\n");
20872 
20873         return (status);
20874 }
20875 
20876 /*
20877  *    Function: sd_send_scsi_PERSISTENT_RESERVE_IN
20878  *
20879  * Description: Issue the scsi PERSISTENT RESERVE IN command.
20880  *
20881  *   Arguments: ssc   - ssc contains pointer to driver soft state (unit)
20882  *                      structure for this target.
20883  *
20884  * Return Code: 0   - Success
20885  *              EACCES
20886  *              ENOTSUP
20887  *              errno return code from sd_ssc_send()
20888  *
20889  *     Context: Can sleep. Does not return until command is completed.
20890  */
20891 
20892 static int
20893 sd_send_scsi_PERSISTENT_RESERVE_IN(sd_ssc_t *ssc, uchar_t  usr_cmd,
20894         uint16_t data_len, uchar_t *data_bufp)
20895 {
20896         struct scsi_extended_sense      sense_buf;
20897         union scsi_cdb          cdb;
20898         struct uscsi_cmd        ucmd_buf;
20899         int                     status;
20900         int                     no_caller_buf = FALSE;
20901         struct sd_lun           *un;
20902 
20903         ASSERT(ssc != NULL);
20904         un = ssc->ssc_un;
20905         ASSERT(un != NULL);
20906         ASSERT(!mutex_owned(SD_MUTEX(un)));
20907         ASSERT((usr_cmd == SD_READ_KEYS) || (usr_cmd == SD_READ_RESV));
20908 
20909         SD_TRACE(SD_LOG_IO, un,
20910             "sd_send_scsi_PERSISTENT_RESERVE_IN: entry: un:0x%p\n", un);
20911 
20912         bzero(&cdb, sizeof (cdb));
20913         bzero(&ucmd_buf, sizeof (ucmd_buf));
20914         bzero(&sense_buf, sizeof (struct scsi_extended_sense));
20915         if (data_bufp == NULL) {
20916                 /* Allocate a default buf if the caller did not give one */
20917                 ASSERT(data_len == 0);
20918                 data_len  = MHIOC_RESV_KEY_SIZE;
20919                 data_bufp = kmem_zalloc(MHIOC_RESV_KEY_SIZE, KM_SLEEP);
20920                 no_caller_buf = TRUE;
20921         }
20922 
20923         cdb.scc_cmd = SCMD_PERSISTENT_RESERVE_IN;
20924         cdb.cdb_opaque[1] = usr_cmd;
20925         FORMG1COUNT(&cdb, data_len);
20926 
20927         ucmd_buf.uscsi_cdb      = (char *)&cdb;
20928         ucmd_buf.uscsi_cdblen   = CDB_GROUP1;
20929         ucmd_buf.uscsi_bufaddr  = (caddr_t)data_bufp;
20930         ucmd_buf.uscsi_buflen   = data_len;
20931         ucmd_buf.uscsi_rqbuf    = (caddr_t)&sense_buf;
20932         ucmd_buf.uscsi_rqlen    = sizeof (struct scsi_extended_sense);
20933         ucmd_buf.uscsi_flags    = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
20934         ucmd_buf.uscsi_timeout  = 60;
20935 
20936         status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
20937             UIO_SYSSPACE, SD_PATH_STANDARD);
20938 
20939         switch (status) {
20940         case 0:
20941                 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
20942 
20943                 break;  /* Success! */
20944         case EIO:
20945                 switch (ucmd_buf.uscsi_status) {
20946                 case STATUS_RESERVATION_CONFLICT:
20947                         status = EACCES;
20948                         break;
20949                 case STATUS_CHECK:
20950                         if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
20951                             (scsi_sense_key((uint8_t *)&sense_buf) ==
20952                             KEY_ILLEGAL_REQUEST)) {
20953                                 status = ENOTSUP;
20954                         }
20955                         break;
20956                 default:
20957                         break;
20958                 }
20959                 break;
20960         default:
20961                 break;
20962         }
20963 
20964         SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_PERSISTENT_RESERVE_IN: exit\n");
20965 
20966         if (no_caller_buf == TRUE) {
20967                 kmem_free(data_bufp, data_len);
20968         }
20969 
20970         return (status);
20971 }
20972 
20973 
20974 /*
20975  *    Function: sd_send_scsi_PERSISTENT_RESERVE_OUT
20976  *
20977  * Description: This routine is the driver entry point for handling CD-ROM
20978  *              multi-host persistent reservation requests (MHIOCGRP_INKEYS,
20979  *              MHIOCGRP_INRESV) by sending the SCSI-3 PROUT commands to the
20980  *              device.
20981  *
20982  *   Arguments: ssc  -  ssc contains un - pointer to soft state struct
20983  *                      for the target.
20984  *              usr_cmd SCSI-3 reservation facility command (one of
20985  *                      SD_SCSI3_REGISTER, SD_SCSI3_RESERVE, SD_SCSI3_RELEASE,
20986  *                      SD_SCSI3_PREEMPTANDABORT, SD_SCSI3_CLEAR)
20987  *              usr_bufp - user provided pointer register, reserve descriptor or
20988  *                      preempt and abort structure (mhioc_register_t,
20989  *                      mhioc_resv_desc_t, mhioc_preemptandabort_t)
20990  *
20991  * Return Code: 0   - Success
20992  *              EACCES
20993  *              ENOTSUP
20994  *              errno return code from sd_ssc_send()
20995  *
20996  *     Context: Can sleep. Does not return until command is completed.
20997  */
20998 
20999 static int
21000 sd_send_scsi_PERSISTENT_RESERVE_OUT(sd_ssc_t *ssc, uchar_t usr_cmd,
21001         uchar_t *usr_bufp)
21002 {
21003         struct scsi_extended_sense      sense_buf;
21004         union scsi_cdb          cdb;
21005         struct uscsi_cmd        ucmd_buf;
21006         int                     status;
21007         uchar_t                 data_len = sizeof (sd_prout_t);
21008         sd_prout_t              *prp;
21009         struct sd_lun           *un;
21010 
21011         ASSERT(ssc != NULL);
21012         un = ssc->ssc_un;
21013         ASSERT(un != NULL);
21014         ASSERT(!mutex_owned(SD_MUTEX(un)));
21015         ASSERT(data_len == 24); /* required by scsi spec */
21016 
21017         SD_TRACE(SD_LOG_IO, un,
21018             "sd_send_scsi_PERSISTENT_RESERVE_OUT: entry: un:0x%p\n", un);
21019 
21020         if (usr_bufp == NULL) {
21021                 return (EINVAL);
21022         }
21023 
21024         bzero(&cdb, sizeof (cdb));
21025         bzero(&ucmd_buf, sizeof (ucmd_buf));
21026         bzero(&sense_buf, sizeof (struct scsi_extended_sense));
21027         prp = kmem_zalloc(data_len, KM_SLEEP);
21028 
21029         cdb.scc_cmd = SCMD_PERSISTENT_RESERVE_OUT;
21030         cdb.cdb_opaque[1] = usr_cmd;
21031         FORMG1COUNT(&cdb, data_len);
21032 
21033         ucmd_buf.uscsi_cdb      = (char *)&cdb;
21034         ucmd_buf.uscsi_cdblen   = CDB_GROUP1;
21035         ucmd_buf.uscsi_bufaddr  = (caddr_t)prp;
21036         ucmd_buf.uscsi_buflen   = data_len;
21037         ucmd_buf.uscsi_rqbuf    = (caddr_t)&sense_buf;
21038         ucmd_buf.uscsi_rqlen    = sizeof (struct scsi_extended_sense);
21039         ucmd_buf.uscsi_flags    = USCSI_RQENABLE | USCSI_WRITE | USCSI_SILENT;
21040         ucmd_buf.uscsi_timeout  = 60;
21041 
21042         switch (usr_cmd) {
21043         case SD_SCSI3_REGISTER: {
21044                 mhioc_register_t *ptr = (mhioc_register_t *)usr_bufp;
21045 
21046                 bcopy(ptr->oldkey.key, prp->res_key, MHIOC_RESV_KEY_SIZE);
21047                 bcopy(ptr->newkey.key, prp->service_key,
21048                     MHIOC_RESV_KEY_SIZE);
21049                 prp->aptpl = ptr->aptpl;
21050                 break;
21051         }
21052         case SD_SCSI3_CLEAR: {
21053                 mhioc_resv_desc_t *ptr = (mhioc_resv_desc_t *)usr_bufp;
21054 
21055                 bcopy(ptr->key.key, prp->res_key, MHIOC_RESV_KEY_SIZE);
21056                 break;
21057         }
21058         case SD_SCSI3_RESERVE:
21059         case SD_SCSI3_RELEASE: {
21060                 mhioc_resv_desc_t *ptr = (mhioc_resv_desc_t *)usr_bufp;
21061 
21062                 bcopy(ptr->key.key, prp->res_key, MHIOC_RESV_KEY_SIZE);
21063                 prp->scope_address = BE_32(ptr->scope_specific_addr);
21064                 cdb.cdb_opaque[2] = ptr->type;
21065                 break;
21066         }
21067         case SD_SCSI3_PREEMPTANDABORT: {
21068                 mhioc_preemptandabort_t *ptr =
21069                     (mhioc_preemptandabort_t *)usr_bufp;
21070 
21071                 bcopy(ptr->resvdesc.key.key, prp->res_key, MHIOC_RESV_KEY_SIZE);
21072                 bcopy(ptr->victim_key.key, prp->service_key,
21073                     MHIOC_RESV_KEY_SIZE);
21074                 prp->scope_address = BE_32(ptr->resvdesc.scope_specific_addr);
21075                 cdb.cdb_opaque[2] = ptr->resvdesc.type;
21076                 ucmd_buf.uscsi_flags |= USCSI_HEAD;
21077                 break;
21078         }
21079         case SD_SCSI3_REGISTERANDIGNOREKEY:
21080         {
21081                 mhioc_registerandignorekey_t *ptr;
21082                 ptr = (mhioc_registerandignorekey_t *)usr_bufp;
21083                 bcopy(ptr->newkey.key,
21084                     prp->service_key, MHIOC_RESV_KEY_SIZE);
21085                 prp->aptpl = ptr->aptpl;
21086                 break;
21087         }
21088         default:
21089                 ASSERT(FALSE);
21090                 break;
21091         }
21092 
21093         status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
21094             UIO_SYSSPACE, SD_PATH_STANDARD);
21095 
21096         switch (status) {
21097         case 0:
21098                 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
21099                 break;  /* Success! */
21100         case EIO:
21101                 switch (ucmd_buf.uscsi_status) {
21102                 case STATUS_RESERVATION_CONFLICT:
21103                         status = EACCES;
21104                         break;
21105                 case STATUS_CHECK:
21106                         if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
21107                             (scsi_sense_key((uint8_t *)&sense_buf) ==
21108                             KEY_ILLEGAL_REQUEST)) {
21109                                 status = ENOTSUP;
21110                         }
21111                         break;
21112                 default:
21113                         break;
21114                 }
21115                 break;
21116         default:
21117                 break;
21118         }
21119 
21120         kmem_free(prp, data_len);
21121         SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_PERSISTENT_RESERVE_OUT: exit\n");
21122         return (status);
21123 }
21124 
21125 
21126 /*
21127  *    Function: sd_send_scsi_SYNCHRONIZE_CACHE
21128  *
21129  * Description: Issues a scsi SYNCHRONIZE CACHE command to the target
21130  *
21131  *   Arguments: un - pointer to the target's soft state struct
21132  *              dkc - pointer to the callback structure
21133  *
21134  * Return Code: 0 - success
21135  *              errno-type error code
21136  *
21137  *     Context: kernel thread context only.
21138  *
21139  *  _______________________________________________________________
21140  * | dkc_flag &   | dkc_callback | DKIOCFLUSHWRITECACHE            |
21141  * |FLUSH_VOLATILE|              | operation                       |
21142  * |______________|______________|_________________________________|
21143  * | 0            | NULL         | Synchronous flush on both       |
21144  * |              |              | volatile and non-volatile cache |
21145  * |______________|______________|_________________________________|
21146  * | 1            | NULL         | Synchronous flush on volatile   |
21147  * |              |              | cache; disk drivers may suppress|
21148  * |              |              | flush if disk table indicates   |
21149  * |              |              | non-volatile cache              |
21150  * |______________|______________|_________________________________|
21151  * | 0            | !NULL        | Asynchronous flush on both      |
21152  * |              |              | volatile and non-volatile cache;|
21153  * |______________|______________|_________________________________|
21154  * | 1            | !NULL        | Asynchronous flush on volatile  |
21155  * |              |              | cache; disk drivers may suppress|
21156  * |              |              | flush if disk table indicates   |
21157  * |              |              | non-volatile cache              |
21158  * |______________|______________|_________________________________|
21159  *
21160  */
21161 
21162 static int
21163 sd_send_scsi_SYNCHRONIZE_CACHE(struct sd_lun *un, struct dk_callback *dkc)
21164 {
21165         struct sd_uscsi_info    *uip;
21166         struct uscsi_cmd        *uscmd;
21167         union scsi_cdb          *cdb;
21168         struct buf              *bp;
21169         int                     rval = 0;
21170         int                     is_async;
21171 
21172         SD_TRACE(SD_LOG_IO, un,
21173             "sd_send_scsi_SYNCHRONIZE_CACHE: entry: un:0x%p\n", un);
21174 
21175         ASSERT(un != NULL);
21176         ASSERT(!mutex_owned(SD_MUTEX(un)));
21177 
21178         if (dkc == NULL || dkc->dkc_callback == NULL) {
21179                 is_async = FALSE;
21180         } else {
21181                 is_async = TRUE;
21182         }
21183 
21184         mutex_enter(SD_MUTEX(un));
21185         /* check whether cache flush should be suppressed */
21186         if (un->un_f_suppress_cache_flush == TRUE) {
21187                 mutex_exit(SD_MUTEX(un));
21188                 /*
21189                  * suppress the cache flush if the device is told to do
21190                  * so by sd.conf or disk table
21191                  */
21192                 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_SYNCHRONIZE_CACHE: \
21193                     skip the cache flush since suppress_cache_flush is %d!\n",
21194                     un->un_f_suppress_cache_flush);
21195 
21196                 if (is_async == TRUE) {
21197                         /* invoke callback for asynchronous flush */
21198                         (*dkc->dkc_callback)(dkc->dkc_cookie, 0);
21199                 }
21200                 return (rval);
21201         }
21202         mutex_exit(SD_MUTEX(un));
21203 
21204         /*
21205          * check dkc_flag & FLUSH_VOLATILE so SYNC_NV bit can be
21206          * set properly
21207          */
21208         cdb = kmem_zalloc(CDB_GROUP1, KM_SLEEP);
21209         cdb->scc_cmd = SCMD_SYNCHRONIZE_CACHE;
21210 
21211         mutex_enter(SD_MUTEX(un));
21212         if (dkc != NULL && un->un_f_sync_nv_supported &&
21213             (dkc->dkc_flag & FLUSH_VOLATILE)) {
21214                 /*
21215                  * if the device supports SYNC_NV bit, turn on
21216                  * the SYNC_NV bit to only flush volatile cache
21217                  */
21218                 cdb->cdb_un.tag |= SD_SYNC_NV_BIT;
21219         }
21220         mutex_exit(SD_MUTEX(un));
21221 
21222         /*
21223          * First get some memory for the uscsi_cmd struct and cdb
21224          * and initialize for SYNCHRONIZE_CACHE cmd.
21225          */
21226         uscmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
21227         uscmd->uscsi_cdblen = CDB_GROUP1;
21228         uscmd->uscsi_cdb = (caddr_t)cdb;
21229         uscmd->uscsi_bufaddr = NULL;
21230         uscmd->uscsi_buflen = 0;
21231         uscmd->uscsi_rqbuf = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
21232         uscmd->uscsi_rqlen = SENSE_LENGTH;
21233         uscmd->uscsi_rqresid = SENSE_LENGTH;
21234         uscmd->uscsi_flags = USCSI_RQENABLE | USCSI_SILENT;
21235         uscmd->uscsi_timeout = sd_io_time;
21236 
21237         /*
21238          * Allocate an sd_uscsi_info struct and fill it with the info
21239          * needed by sd_initpkt_for_uscsi().  Then put the pointer into
21240          * b_private in the buf for sd_initpkt_for_uscsi().  Note that
21241          * since we allocate the buf here in this function, we do not
21242          * need to preserve the prior contents of b_private.
21243          * The sd_uscsi_info struct is also used by sd_uscsi_strategy()
21244          */
21245         uip = kmem_zalloc(sizeof (struct sd_uscsi_info), KM_SLEEP);
21246         uip->ui_flags = SD_PATH_DIRECT;
21247         uip->ui_cmdp  = uscmd;
21248 
21249         bp = getrbuf(KM_SLEEP);
21250         bp->b_private = uip;
21251 
21252         /*
21253          * Setup buffer to carry uscsi request.
21254          */
21255         bp->b_flags  = B_BUSY;
21256         bp->b_bcount = 0;
21257         bp->b_blkno  = 0;
21258 
21259         if (is_async == TRUE) {
21260                 bp->b_iodone = sd_send_scsi_SYNCHRONIZE_CACHE_biodone;
21261                 uip->ui_dkc = *dkc;
21262         }
21263 
21264         bp->b_edev = SD_GET_DEV(un);
21265         bp->b_dev = cmpdev(bp->b_edev);   /* maybe unnecessary? */
21266 
21267         /*
21268          * Unset un_f_sync_cache_required flag
21269          */
21270         mutex_enter(SD_MUTEX(un));
21271         un->un_f_sync_cache_required = FALSE;
21272         mutex_exit(SD_MUTEX(un));
21273 
21274         (void) sd_uscsi_strategy(bp);
21275 
21276         /*
21277          * If synchronous request, wait for completion
21278          * If async just return and let b_iodone callback
21279          * cleanup.
21280          * NOTE: On return, u_ncmds_in_driver will be decremented,
21281          * but it was also incremented in sd_uscsi_strategy(), so
21282          * we should be ok.
21283          */
21284         if (is_async == FALSE) {
21285                 (void) biowait(bp);
21286                 rval = sd_send_scsi_SYNCHRONIZE_CACHE_biodone(bp);
21287         }
21288 
21289         return (rval);
21290 }
21291 
21292 
21293 static int
21294 sd_send_scsi_SYNCHRONIZE_CACHE_biodone(struct buf *bp)
21295 {
21296         struct sd_uscsi_info *uip;
21297         struct uscsi_cmd *uscmd;
21298         uint8_t *sense_buf;
21299         struct sd_lun *un;
21300         int status;
21301         union scsi_cdb *cdb;
21302 
21303         uip = (struct sd_uscsi_info *)(bp->b_private);
21304         ASSERT(uip != NULL);
21305 
21306         uscmd = uip->ui_cmdp;
21307         ASSERT(uscmd != NULL);
21308 
21309         sense_buf = (uint8_t *)uscmd->uscsi_rqbuf;
21310         ASSERT(sense_buf != NULL);
21311 
21312         un = ddi_get_soft_state(sd_state, SD_GET_INSTANCE_FROM_BUF(bp));
21313         ASSERT(un != NULL);
21314 
21315         cdb = (union scsi_cdb *)uscmd->uscsi_cdb;
21316 
21317         status = geterror(bp);
21318         switch (status) {
21319         case 0:
21320                 break;  /* Success! */
21321         case EIO:
21322                 switch (uscmd->uscsi_status) {
21323                 case STATUS_RESERVATION_CONFLICT:
21324                         /* Ignore reservation conflict */
21325                         status = 0;
21326                         goto done;
21327 
21328                 case STATUS_CHECK:
21329                         if ((uscmd->uscsi_rqstatus == STATUS_GOOD) &&
21330                             (scsi_sense_key(sense_buf) ==
21331                             KEY_ILLEGAL_REQUEST)) {
21332                                 /* Ignore Illegal Request error */
21333                                 if (cdb->cdb_un.tag&SD_SYNC_NV_BIT) {
21334                                         mutex_enter(SD_MUTEX(un));
21335                                         un->un_f_sync_nv_supported = FALSE;
21336                                         mutex_exit(SD_MUTEX(un));
21337                                         status = 0;
21338                                         SD_TRACE(SD_LOG_IO, un,
21339                                             "un_f_sync_nv_supported \
21340                                             is set to false.\n");
21341                                         goto done;
21342                                 }
21343 
21344                                 mutex_enter(SD_MUTEX(un));
21345                                 un->un_f_sync_cache_supported = FALSE;
21346                                 mutex_exit(SD_MUTEX(un));
21347                                 SD_TRACE(SD_LOG_IO, un,
21348                                     "sd_send_scsi_SYNCHRONIZE_CACHE_biodone: \
21349                                     un_f_sync_cache_supported set to false \
21350                                     with asc = %x, ascq = %x\n",
21351                                     scsi_sense_asc(sense_buf),
21352                                     scsi_sense_ascq(sense_buf));
21353                                 status = ENOTSUP;
21354                                 goto done;
21355                         }
21356                         break;
21357                 default:
21358                         break;
21359                 }
21360                 /* FALLTHRU */
21361         default:
21362                 /*
21363                  * Turn on the un_f_sync_cache_required flag
21364                  * since the SYNC CACHE command failed
21365                  */
21366                 mutex_enter(SD_MUTEX(un));
21367                 un->un_f_sync_cache_required = TRUE;
21368                 mutex_exit(SD_MUTEX(un));
21369 
21370                 /*
21371                  * Don't log an error message if this device
21372                  * has removable media.
21373                  */
21374                 if (!un->un_f_has_removable_media) {
21375                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
21376                             "SYNCHRONIZE CACHE command failed (%d)\n", status);
21377                 }
21378                 break;
21379         }
21380 
21381 done:
21382         if (uip->ui_dkc.dkc_callback != NULL) {
21383                 (*uip->ui_dkc.dkc_callback)(uip->ui_dkc.dkc_cookie, status);
21384         }
21385 
21386         ASSERT((bp->b_flags & B_REMAPPED) == 0);
21387         freerbuf(bp);
21388         kmem_free(uip, sizeof (struct sd_uscsi_info));
21389         kmem_free(uscmd->uscsi_rqbuf, SENSE_LENGTH);
21390         kmem_free(uscmd->uscsi_cdb, (size_t)uscmd->uscsi_cdblen);
21391         kmem_free(uscmd, sizeof (struct uscsi_cmd));
21392 
21393         return (status);
21394 }
21395 
21396 
21397 /*
21398  *    Function: sd_send_scsi_GET_CONFIGURATION
21399  *
21400  * Description: Issues the get configuration command to the device.
21401  *              Called from sd_check_for_writable_cd & sd_get_media_info
21402  *              caller needs to ensure that buflen = SD_PROFILE_HEADER_LEN
21403  *   Arguments: ssc
21404  *              ucmdbuf
21405  *              rqbuf
21406  *              rqbuflen
21407  *              bufaddr
21408  *              buflen
21409  *              path_flag
21410  *
21411  * Return Code: 0   - Success
21412  *              errno return code from sd_ssc_send()
21413  *
21414  *     Context: Can sleep. Does not return until command is completed.
21415  *
21416  */
21417 
21418 static int
21419 sd_send_scsi_GET_CONFIGURATION(sd_ssc_t *ssc, struct uscsi_cmd *ucmdbuf,
21420         uchar_t *rqbuf, uint_t rqbuflen, uchar_t *bufaddr, uint_t buflen,
21421         int path_flag)
21422 {
21423         char    cdb[CDB_GROUP1];
21424         int     status;
21425         struct sd_lun   *un;
21426 
21427         ASSERT(ssc != NULL);
21428         un = ssc->ssc_un;
21429         ASSERT(un != NULL);
21430         ASSERT(!mutex_owned(SD_MUTEX(un)));
21431         ASSERT(bufaddr != NULL);
21432         ASSERT(ucmdbuf != NULL);
21433         ASSERT(rqbuf != NULL);
21434 
21435         SD_TRACE(SD_LOG_IO, un,
21436             "sd_send_scsi_GET_CONFIGURATION: entry: un:0x%p\n", un);
21437 
21438         bzero(cdb, sizeof (cdb));
21439         bzero(ucmdbuf, sizeof (struct uscsi_cmd));
21440         bzero(rqbuf, rqbuflen);
21441         bzero(bufaddr, buflen);
21442 
21443         /*
21444          * Set up cdb field for the get configuration command.
21445          */
21446         cdb[0] = SCMD_GET_CONFIGURATION;
21447         cdb[1] = 0x02;  /* Requested Type */
21448         cdb[8] = SD_PROFILE_HEADER_LEN;
21449         ucmdbuf->uscsi_cdb = cdb;
21450         ucmdbuf->uscsi_cdblen = CDB_GROUP1;
21451         ucmdbuf->uscsi_bufaddr = (caddr_t)bufaddr;
21452         ucmdbuf->uscsi_buflen = buflen;
21453         ucmdbuf->uscsi_timeout = sd_io_time;
21454         ucmdbuf->uscsi_rqbuf = (caddr_t)rqbuf;
21455         ucmdbuf->uscsi_rqlen = rqbuflen;
21456         ucmdbuf->uscsi_flags = USCSI_RQENABLE|USCSI_SILENT|USCSI_READ;
21457 
21458         status = sd_ssc_send(ssc, ucmdbuf, FKIOCTL,
21459             UIO_SYSSPACE, path_flag);
21460 
21461         switch (status) {
21462         case 0:
21463                 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
21464                 break;  /* Success! */
21465         case EIO:
21466                 switch (ucmdbuf->uscsi_status) {
21467                 case STATUS_RESERVATION_CONFLICT:
21468                         status = EACCES;
21469                         break;
21470                 default:
21471                         break;
21472                 }
21473                 break;
21474         default:
21475                 break;
21476         }
21477 
21478         if (status == 0) {
21479                 SD_DUMP_MEMORY(un, SD_LOG_IO,
21480                     "sd_send_scsi_GET_CONFIGURATION: data",
21481                     (uchar_t *)bufaddr, SD_PROFILE_HEADER_LEN, SD_LOG_HEX);
21482         }
21483 
21484         SD_TRACE(SD_LOG_IO, un,
21485             "sd_send_scsi_GET_CONFIGURATION: exit\n");
21486 
21487         return (status);
21488 }
21489 
21490 /*
21491  *    Function: sd_send_scsi_feature_GET_CONFIGURATION
21492  *
21493  * Description: Issues the get configuration command to the device to
21494  *              retrieve a specific feature. Called from
21495  *              sd_check_for_writable_cd & sd_set_mmc_caps.
21496  *   Arguments: ssc
21497  *              ucmdbuf
21498  *              rqbuf
21499  *              rqbuflen
21500  *              bufaddr
21501  *              buflen
21502  *              feature
21503  *
21504  * Return Code: 0   - Success
21505  *              errno return code from sd_ssc_send()
21506  *
21507  *     Context: Can sleep. Does not return until command is completed.
21508  *
21509  */
21510 static int
21511 sd_send_scsi_feature_GET_CONFIGURATION(sd_ssc_t *ssc,
21512         struct uscsi_cmd *ucmdbuf, uchar_t *rqbuf, uint_t rqbuflen,
21513         uchar_t *bufaddr, uint_t buflen, char feature, int path_flag)
21514 {
21515         char    cdb[CDB_GROUP1];
21516         int     status;
21517         struct sd_lun   *un;
21518 
21519         ASSERT(ssc != NULL);
21520         un = ssc->ssc_un;
21521         ASSERT(un != NULL);
21522         ASSERT(!mutex_owned(SD_MUTEX(un)));
21523         ASSERT(bufaddr != NULL);
21524         ASSERT(ucmdbuf != NULL);
21525         ASSERT(rqbuf != NULL);
21526 
21527         SD_TRACE(SD_LOG_IO, un,
21528             "sd_send_scsi_feature_GET_CONFIGURATION: entry: un:0x%p\n", un);
21529 
21530         bzero(cdb, sizeof (cdb));
21531         bzero(ucmdbuf, sizeof (struct uscsi_cmd));
21532         bzero(rqbuf, rqbuflen);
21533         bzero(bufaddr, buflen);
21534 
21535         /*
21536          * Set up cdb field for the get configuration command.
21537          */
21538         cdb[0] = SCMD_GET_CONFIGURATION;
21539         cdb[1] = 0x02;  /* Requested Type */
21540         cdb[3] = feature;
21541         cdb[8] = buflen;
21542         ucmdbuf->uscsi_cdb = cdb;
21543         ucmdbuf->uscsi_cdblen = CDB_GROUP1;
21544         ucmdbuf->uscsi_bufaddr = (caddr_t)bufaddr;
21545         ucmdbuf->uscsi_buflen = buflen;
21546         ucmdbuf->uscsi_timeout = sd_io_time;
21547         ucmdbuf->uscsi_rqbuf = (caddr_t)rqbuf;
21548         ucmdbuf->uscsi_rqlen = rqbuflen;
21549         ucmdbuf->uscsi_flags = USCSI_RQENABLE|USCSI_SILENT|USCSI_READ;
21550 
21551         status = sd_ssc_send(ssc, ucmdbuf, FKIOCTL,
21552             UIO_SYSSPACE, path_flag);
21553 
21554         switch (status) {
21555         case 0:
21556 
21557                 break;  /* Success! */
21558         case EIO:
21559                 switch (ucmdbuf->uscsi_status) {
21560                 case STATUS_RESERVATION_CONFLICT:
21561                         status = EACCES;
21562                         break;
21563                 default:
21564                         break;
21565                 }
21566                 break;
21567         default:
21568                 break;
21569         }
21570 
21571         if (status == 0) {
21572                 SD_DUMP_MEMORY(un, SD_LOG_IO,
21573                     "sd_send_scsi_feature_GET_CONFIGURATION: data",
21574                     (uchar_t *)bufaddr, SD_PROFILE_HEADER_LEN, SD_LOG_HEX);
21575         }
21576 
21577         SD_TRACE(SD_LOG_IO, un,
21578             "sd_send_scsi_feature_GET_CONFIGURATION: exit\n");
21579 
21580         return (status);
21581 }
21582 
21583 
21584 /*
21585  *    Function: sd_send_scsi_MODE_SENSE
21586  *
21587  * Description: Utility function for issuing a scsi MODE SENSE command.
21588  *              Note: This routine uses a consistent implementation for Group0,
21589  *              Group1, and Group2 commands across all platforms. ATAPI devices
21590  *              use Group 1 Read/Write commands and Group 2 Mode Sense/Select
21591  *
21592  *   Arguments: ssc   - ssc contains pointer to driver soft state (unit)
21593  *                      structure for this target.
21594  *              cdbsize - size CDB to be used (CDB_GROUP0 (6 byte), or
21595  *                        CDB_GROUP[1|2] (10 byte).
21596  *              bufaddr - buffer for page data retrieved from the target.
21597  *              buflen - size of page to be retrieved.
21598  *              page_code - page code of data to be retrieved from the target.
21599  *              path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
21600  *                      the normal command waitq, or SD_PATH_DIRECT_PRIORITY
21601  *                      to use the USCSI "direct" chain and bypass the normal
21602  *                      command waitq.
21603  *
21604  * Return Code: 0   - Success
21605  *              errno return code from sd_ssc_send()
21606  *
21607  *     Context: Can sleep. Does not return until command is completed.
21608  */
21609 
21610 static int
21611 sd_send_scsi_MODE_SENSE(sd_ssc_t *ssc, int cdbsize, uchar_t *bufaddr,
21612         size_t buflen,  uchar_t page_code, int path_flag)
21613 {
21614         struct  scsi_extended_sense     sense_buf;
21615         union scsi_cdb          cdb;
21616         struct uscsi_cmd        ucmd_buf;
21617         int                     status;
21618         int                     headlen;
21619         struct sd_lun           *un;
21620 
21621         ASSERT(ssc != NULL);
21622         un = ssc->ssc_un;
21623         ASSERT(un != NULL);
21624         ASSERT(!mutex_owned(SD_MUTEX(un)));
21625         ASSERT(bufaddr != NULL);
21626         ASSERT((cdbsize == CDB_GROUP0) || (cdbsize == CDB_GROUP1) ||
21627             (cdbsize == CDB_GROUP2));
21628 
21629         SD_TRACE(SD_LOG_IO, un,
21630             "sd_send_scsi_MODE_SENSE: entry: un:0x%p\n", un);
21631 
21632         bzero(&cdb, sizeof (cdb));
21633         bzero(&ucmd_buf, sizeof (ucmd_buf));
21634         bzero(&sense_buf, sizeof (struct scsi_extended_sense));
21635         bzero(bufaddr, buflen);
21636 
21637         if (cdbsize == CDB_GROUP0) {
21638                 cdb.scc_cmd = SCMD_MODE_SENSE;
21639                 cdb.cdb_opaque[2] = page_code;
21640                 FORMG0COUNT(&cdb, buflen);
21641                 headlen = MODE_HEADER_LENGTH;
21642         } else {
21643                 cdb.scc_cmd = SCMD_MODE_SENSE_G1;
21644                 cdb.cdb_opaque[2] = page_code;
21645                 FORMG1COUNT(&cdb, buflen);
21646                 headlen = MODE_HEADER_LENGTH_GRP2;
21647         }
21648 
21649         ASSERT(headlen <= buflen);
21650         SD_FILL_SCSI1_LUN_CDB(un, &cdb);
21651 
21652         ucmd_buf.uscsi_cdb      = (char *)&cdb;
21653         ucmd_buf.uscsi_cdblen   = (uchar_t)cdbsize;
21654         ucmd_buf.uscsi_bufaddr  = (caddr_t)bufaddr;
21655         ucmd_buf.uscsi_buflen   = buflen;
21656         ucmd_buf.uscsi_rqbuf    = (caddr_t)&sense_buf;
21657         ucmd_buf.uscsi_rqlen    = sizeof (struct scsi_extended_sense);
21658         ucmd_buf.uscsi_flags    = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
21659         ucmd_buf.uscsi_timeout  = 60;
21660 
21661         status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
21662             UIO_SYSSPACE, path_flag);
21663 
21664         switch (status) {
21665         case 0:
21666                 /*
21667                  * sr_check_wp() uses 0x3f page code and check the header of
21668                  * mode page to determine if target device is write-protected.
21669                  * But some USB devices return 0 bytes for 0x3f page code. For
21670                  * this case, make sure that mode page header is returned at
21671                  * least.
21672                  */
21673                 if (buflen - ucmd_buf.uscsi_resid <  headlen) {
21674                         status = EIO;
21675                         sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1,
21676                             "mode page header is not returned");
21677                 }
21678                 break;  /* Success! */
21679         case EIO:
21680                 switch (ucmd_buf.uscsi_status) {
21681                 case STATUS_RESERVATION_CONFLICT:
21682                         status = EACCES;
21683                         break;
21684                 default:
21685                         break;
21686                 }
21687                 break;
21688         default:
21689                 break;
21690         }
21691 
21692         if (status == 0) {
21693                 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_MODE_SENSE: data",
21694                     (uchar_t *)bufaddr, buflen, SD_LOG_HEX);
21695         }
21696         SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_MODE_SENSE: exit\n");
21697 
21698         return (status);
21699 }
21700 
21701 
21702 /*
21703  *    Function: sd_send_scsi_MODE_SELECT
21704  *
21705  * Description: Utility function for issuing a scsi MODE SELECT command.
21706  *              Note: This routine uses a consistent implementation for Group0,
21707  *              Group1, and Group2 commands across all platforms. ATAPI devices
21708  *              use Group 1 Read/Write commands and Group 2 Mode Sense/Select
21709  *
21710  *   Arguments: ssc   - ssc contains pointer to driver soft state (unit)
21711  *                      structure for this target.
21712  *              cdbsize - size CDB to be used (CDB_GROUP0 (6 byte), or
21713  *                        CDB_GROUP[1|2] (10 byte).
21714  *              bufaddr - buffer for page data retrieved from the target.
21715  *              buflen - size of page to be retrieved.
21716  *              save_page - boolean to determin if SP bit should be set.
21717  *              path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
21718  *                      the normal command waitq, or SD_PATH_DIRECT_PRIORITY
21719  *                      to use the USCSI "direct" chain and bypass the normal
21720  *                      command waitq.
21721  *
21722  * Return Code: 0   - Success
21723  *              errno return code from sd_ssc_send()
21724  *
21725  *     Context: Can sleep. Does not return until command is completed.
21726  */
21727 
21728 static int
21729 sd_send_scsi_MODE_SELECT(sd_ssc_t *ssc, int cdbsize, uchar_t *bufaddr,
21730         size_t buflen,  uchar_t save_page, int path_flag)
21731 {
21732         struct  scsi_extended_sense     sense_buf;
21733         union scsi_cdb          cdb;
21734         struct uscsi_cmd        ucmd_buf;
21735         int                     status;
21736         struct sd_lun           *un;
21737 
21738         ASSERT(ssc != NULL);
21739         un = ssc->ssc_un;
21740         ASSERT(un != NULL);
21741         ASSERT(!mutex_owned(SD_MUTEX(un)));
21742         ASSERT(bufaddr != NULL);
21743         ASSERT((cdbsize == CDB_GROUP0) || (cdbsize == CDB_GROUP1) ||
21744             (cdbsize == CDB_GROUP2));
21745 
21746         SD_TRACE(SD_LOG_IO, un,
21747             "sd_send_scsi_MODE_SELECT: entry: un:0x%p\n", un);
21748 
21749         bzero(&cdb, sizeof (cdb));
21750         bzero(&ucmd_buf, sizeof (ucmd_buf));
21751         bzero(&sense_buf, sizeof (struct scsi_extended_sense));
21752 
21753         /* Set the PF bit for many third party drives */
21754         cdb.cdb_opaque[1] = 0x10;
21755 
21756         /* Set the savepage(SP) bit if given */
21757         if (save_page == SD_SAVE_PAGE) {
21758                 cdb.cdb_opaque[1] |= 0x01;
21759         }
21760 
21761         if (cdbsize == CDB_GROUP0) {
21762                 cdb.scc_cmd = SCMD_MODE_SELECT;
21763                 FORMG0COUNT(&cdb, buflen);
21764         } else {
21765                 cdb.scc_cmd = SCMD_MODE_SELECT_G1;
21766                 FORMG1COUNT(&cdb, buflen);
21767         }
21768 
21769         SD_FILL_SCSI1_LUN_CDB(un, &cdb);
21770 
21771         ucmd_buf.uscsi_cdb      = (char *)&cdb;
21772         ucmd_buf.uscsi_cdblen   = (uchar_t)cdbsize;
21773         ucmd_buf.uscsi_bufaddr  = (caddr_t)bufaddr;
21774         ucmd_buf.uscsi_buflen   = buflen;
21775         ucmd_buf.uscsi_rqbuf    = (caddr_t)&sense_buf;
21776         ucmd_buf.uscsi_rqlen    = sizeof (struct scsi_extended_sense);
21777         ucmd_buf.uscsi_flags    = USCSI_RQENABLE | USCSI_WRITE | USCSI_SILENT;
21778         ucmd_buf.uscsi_timeout  = 60;
21779 
21780         status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
21781             UIO_SYSSPACE, path_flag);
21782 
21783         switch (status) {
21784         case 0:
21785                 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
21786                 break;  /* Success! */
21787         case EIO:
21788                 switch (ucmd_buf.uscsi_status) {
21789                 case STATUS_RESERVATION_CONFLICT:
21790                         status = EACCES;
21791                         break;
21792                 default:
21793                         break;
21794                 }
21795                 break;
21796         default:
21797                 break;
21798         }
21799 
21800         if (status == 0) {
21801                 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_MODE_SELECT: data",
21802                     (uchar_t *)bufaddr, buflen, SD_LOG_HEX);
21803         }
21804         SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_MODE_SELECT: exit\n");
21805 
21806         return (status);
21807 }
21808 
21809 
21810 /*
21811  *    Function: sd_send_scsi_RDWR
21812  *
21813  * Description: Issue a scsi READ or WRITE command with the given parameters.
21814  *
21815  *   Arguments: ssc   - ssc contains pointer to driver soft state (unit)
21816  *                      structure for this target.
21817  *              cmd:     SCMD_READ or SCMD_WRITE
21818  *              bufaddr: Address of caller's buffer to receive the RDWR data
21819  *              buflen:  Length of caller's buffer receive the RDWR data.
21820  *              start_block: Block number for the start of the RDWR operation.
21821  *                       (Assumes target-native block size.)
21822  *              residp:  Pointer to variable to receive the redisual of the
21823  *                       RDWR operation (may be NULL of no residual requested).
21824  *              path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and
21825  *                      the normal command waitq, or SD_PATH_DIRECT_PRIORITY
21826  *                      to use the USCSI "direct" chain and bypass the normal
21827  *                      command waitq.
21828  *
21829  * Return Code: 0   - Success
21830  *              errno return code from sd_ssc_send()
21831  *
21832  *     Context: Can sleep. Does not return until command is completed.
21833  */
21834 
21835 static int
21836 sd_send_scsi_RDWR(sd_ssc_t *ssc, uchar_t cmd, void *bufaddr,
21837         size_t buflen, daddr_t start_block, int path_flag)
21838 {
21839         struct  scsi_extended_sense     sense_buf;
21840         union scsi_cdb          cdb;
21841         struct uscsi_cmd        ucmd_buf;
21842         uint32_t                block_count;
21843         int                     status;
21844         int                     cdbsize;
21845         uchar_t                 flag;
21846         struct sd_lun           *un;
21847 
21848         ASSERT(ssc != NULL);
21849         un = ssc->ssc_un;
21850         ASSERT(un != NULL);
21851         ASSERT(!mutex_owned(SD_MUTEX(un)));
21852         ASSERT(bufaddr != NULL);
21853         ASSERT((cmd == SCMD_READ) || (cmd == SCMD_WRITE));
21854 
21855         SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_RDWR: entry: un:0x%p\n", un);
21856 
21857         if (un->un_f_tgt_blocksize_is_valid != TRUE) {
21858                 return (EINVAL);
21859         }
21860 
21861         mutex_enter(SD_MUTEX(un));
21862         block_count = SD_BYTES2TGTBLOCKS(un, buflen);
21863         mutex_exit(SD_MUTEX(un));
21864 
21865         flag = (cmd == SCMD_READ) ? USCSI_READ : USCSI_WRITE;
21866 
21867         SD_INFO(SD_LOG_IO, un, "sd_send_scsi_RDWR: "
21868             "bufaddr:0x%p buflen:0x%x start_block:0x%p block_count:0x%x\n",
21869             bufaddr, buflen, start_block, block_count);
21870 
21871         bzero(&cdb, sizeof (cdb));
21872         bzero(&ucmd_buf, sizeof (ucmd_buf));
21873         bzero(&sense_buf, sizeof (struct scsi_extended_sense));
21874 
21875         /* Compute CDB size to use */
21876         if (start_block > 0xffffffff)
21877                 cdbsize = CDB_GROUP4;
21878         else if ((start_block & 0xFFE00000) ||
21879             (un->un_f_cfg_is_atapi == TRUE))
21880                 cdbsize = CDB_GROUP1;
21881         else
21882                 cdbsize = CDB_GROUP0;
21883 
21884         switch (cdbsize) {
21885         case CDB_GROUP0:        /* 6-byte CDBs */
21886                 cdb.scc_cmd = cmd;
21887                 FORMG0ADDR(&cdb, start_block);
21888                 FORMG0COUNT(&cdb, block_count);
21889                 break;
21890         case CDB_GROUP1:        /* 10-byte CDBs */
21891                 cdb.scc_cmd = cmd | SCMD_GROUP1;
21892                 FORMG1ADDR(&cdb, start_block);
21893                 FORMG1COUNT(&cdb, block_count);
21894                 break;
21895         case CDB_GROUP4:        /* 16-byte CDBs */
21896                 cdb.scc_cmd = cmd | SCMD_GROUP4;
21897                 FORMG4LONGADDR(&cdb, (uint64_t)start_block);
21898                 FORMG4COUNT(&cdb, block_count);
21899                 break;
21900         case CDB_GROUP5:        /* 12-byte CDBs (currently unsupported) */
21901         default:
21902                 /* All others reserved */
21903                 return (EINVAL);
21904         }
21905 
21906         /* Set LUN bit(s) in CDB if this is a SCSI-1 device */
21907         SD_FILL_SCSI1_LUN_CDB(un, &cdb);
21908 
21909         ucmd_buf.uscsi_cdb      = (char *)&cdb;
21910         ucmd_buf.uscsi_cdblen   = (uchar_t)cdbsize;
21911         ucmd_buf.uscsi_bufaddr  = bufaddr;
21912         ucmd_buf.uscsi_buflen   = buflen;
21913         ucmd_buf.uscsi_rqbuf    = (caddr_t)&sense_buf;
21914         ucmd_buf.uscsi_rqlen    = sizeof (struct scsi_extended_sense);
21915         ucmd_buf.uscsi_flags    = flag | USCSI_RQENABLE | USCSI_SILENT;
21916         ucmd_buf.uscsi_timeout  = 60;
21917         status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
21918             UIO_SYSSPACE, path_flag);
21919 
21920         switch (status) {
21921         case 0:
21922                 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
21923                 break;  /* Success! */
21924         case EIO:
21925                 switch (ucmd_buf.uscsi_status) {
21926                 case STATUS_RESERVATION_CONFLICT:
21927                         status = EACCES;
21928                         break;
21929                 default:
21930                         break;
21931                 }
21932                 break;
21933         default:
21934                 break;
21935         }
21936 
21937         if (status == 0) {
21938                 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_RDWR: data",
21939                     (uchar_t *)bufaddr, buflen, SD_LOG_HEX);
21940         }
21941 
21942         SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_RDWR: exit\n");
21943 
21944         return (status);
21945 }
21946 
21947 
21948 /*
21949  *    Function: sd_send_scsi_LOG_SENSE
21950  *
21951  * Description: Issue a scsi LOG_SENSE command with the given parameters.
21952  *
21953  *   Arguments: ssc   - ssc contains pointer to driver soft state (unit)
21954  *                      structure for this target.
21955  *
21956  * Return Code: 0   - Success
21957  *              errno return code from sd_ssc_send()
21958  *
21959  *     Context: Can sleep. Does not return until command is completed.
21960  */
21961 
21962 static int
21963 sd_send_scsi_LOG_SENSE(sd_ssc_t *ssc, uchar_t *bufaddr, uint16_t buflen,
21964         uchar_t page_code, uchar_t page_control, uint16_t param_ptr,
21965         int path_flag)
21966 
21967 {
21968         struct scsi_extended_sense      sense_buf;
21969         union scsi_cdb          cdb;
21970         struct uscsi_cmd        ucmd_buf;
21971         int                     status;
21972         struct sd_lun           *un;
21973 
21974         ASSERT(ssc != NULL);
21975         un = ssc->ssc_un;
21976         ASSERT(un != NULL);
21977         ASSERT(!mutex_owned(SD_MUTEX(un)));
21978 
21979         SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_LOG_SENSE: entry: un:0x%p\n", un);
21980 
21981         bzero(&cdb, sizeof (cdb));
21982         bzero(&ucmd_buf, sizeof (ucmd_buf));
21983         bzero(&sense_buf, sizeof (struct scsi_extended_sense));
21984 
21985         cdb.scc_cmd = SCMD_LOG_SENSE_G1;
21986         cdb.cdb_opaque[2] = (page_control << 6) | page_code;
21987         cdb.cdb_opaque[5] = (uchar_t)((param_ptr & 0xFF00) >> 8);
21988         cdb.cdb_opaque[6] = (uchar_t)(param_ptr  & 0x00FF);
21989         FORMG1COUNT(&cdb, buflen);
21990 
21991         ucmd_buf.uscsi_cdb      = (char *)&cdb;
21992         ucmd_buf.uscsi_cdblen   = CDB_GROUP1;
21993         ucmd_buf.uscsi_bufaddr  = (caddr_t)bufaddr;
21994         ucmd_buf.uscsi_buflen   = buflen;
21995         ucmd_buf.uscsi_rqbuf    = (caddr_t)&sense_buf;
21996         ucmd_buf.uscsi_rqlen    = sizeof (struct scsi_extended_sense);
21997         ucmd_buf.uscsi_flags    = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
21998         ucmd_buf.uscsi_timeout  = 60;
21999 
22000         status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
22001             UIO_SYSSPACE, path_flag);
22002 
22003         switch (status) {
22004         case 0:
22005                 break;
22006         case EIO:
22007                 switch (ucmd_buf.uscsi_status) {
22008                 case STATUS_RESERVATION_CONFLICT:
22009                         status = EACCES;
22010                         break;
22011                 case STATUS_CHECK:
22012                         if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) &&
22013                             (scsi_sense_key((uint8_t *)&sense_buf) ==
22014                                 KEY_ILLEGAL_REQUEST) &&
22015                             (scsi_sense_asc((uint8_t *)&sense_buf) == 0x24)) {
22016                                 /*
22017                                  * ASC 0x24: INVALID FIELD IN CDB
22018                                  */
22019                                 switch (page_code) {
22020                                 case START_STOP_CYCLE_PAGE:
22021                                         /*
22022                                          * The start stop cycle counter is
22023                                          * implemented as page 0x31 in earlier
22024                                          * generation disks. In new generation
22025                                          * disks the start stop cycle counter is
22026                                          * implemented as page 0xE. To properly
22027                                          * handle this case if an attempt for
22028                                          * log page 0xE is made and fails we
22029                                          * will try again using page 0x31.
22030                                          *
22031                                          * Network storage BU committed to
22032                                          * maintain the page 0x31 for this
22033                                          * purpose and will not have any other
22034                                          * page implemented with page code 0x31
22035                                          * until all disks transition to the
22036                                          * standard page.
22037                                          */
22038                                         mutex_enter(SD_MUTEX(un));
22039                                         un->un_start_stop_cycle_page =
22040                                             START_STOP_CYCLE_VU_PAGE;
22041                                         cdb.cdb_opaque[2] =
22042                                             (char)(page_control << 6) |
22043                                             un->un_start_stop_cycle_page;
22044                                         mutex_exit(SD_MUTEX(un));
22045                                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
22046                                         status = sd_ssc_send(
22047                                             ssc, &ucmd_buf, FKIOCTL,
22048                                             UIO_SYSSPACE, path_flag);
22049 
22050                                         break;
22051                                 case TEMPERATURE_PAGE:
22052                                         status = ENOTTY;
22053                                         break;
22054                                 default:
22055                                         break;
22056                                 }
22057                         }
22058                         break;
22059                 default:
22060                         break;
22061                 }
22062                 break;
22063         default:
22064                 break;
22065         }
22066 
22067         if (status == 0) {
22068                 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
22069                 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_LOG_SENSE: data",
22070                     (uchar_t *)bufaddr, buflen, SD_LOG_HEX);
22071         }
22072 
22073         SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_LOG_SENSE: exit\n");
22074 
22075         return (status);
22076 }
22077 
22078 
22079 /*
22080  *    Function: sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION
22081  *
22082  * Description: Issue the scsi GET EVENT STATUS NOTIFICATION command.
22083  *
22084  *   Arguments: ssc   - ssc contains pointer to driver soft state (unit)
22085  *                      structure for this target.
22086  *              bufaddr
22087  *              buflen
22088  *              class_req
22089  *
22090  * Return Code: 0   - Success
22091  *              errno return code from sd_ssc_send()
22092  *
22093  *     Context: Can sleep. Does not return until command is completed.
22094  */
22095 
22096 static int
22097 sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION(sd_ssc_t *ssc, uchar_t *bufaddr,
22098         size_t buflen, uchar_t class_req)
22099 {
22100         union scsi_cdb          cdb;
22101         struct uscsi_cmd        ucmd_buf;
22102         int                     status;
22103         struct sd_lun           *un;
22104 
22105         ASSERT(ssc != NULL);
22106         un = ssc->ssc_un;
22107         ASSERT(un != NULL);
22108         ASSERT(!mutex_owned(SD_MUTEX(un)));
22109         ASSERT(bufaddr != NULL);
22110 
22111         SD_TRACE(SD_LOG_IO, un,
22112             "sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION: entry: un:0x%p\n", un);
22113 
22114         bzero(&cdb, sizeof (cdb));
22115         bzero(&ucmd_buf, sizeof (ucmd_buf));
22116         bzero(bufaddr, buflen);
22117 
22118         cdb.scc_cmd = SCMD_GET_EVENT_STATUS_NOTIFICATION;
22119         cdb.cdb_opaque[1] = 1; /* polled */
22120         cdb.cdb_opaque[4] = class_req;
22121         FORMG1COUNT(&cdb, buflen);
22122 
22123         ucmd_buf.uscsi_cdb      = (char *)&cdb;
22124         ucmd_buf.uscsi_cdblen   = CDB_GROUP1;
22125         ucmd_buf.uscsi_bufaddr  = (caddr_t)bufaddr;
22126         ucmd_buf.uscsi_buflen   = buflen;
22127         ucmd_buf.uscsi_rqbuf    = NULL;
22128         ucmd_buf.uscsi_rqlen    = 0;
22129         ucmd_buf.uscsi_flags    = USCSI_READ | USCSI_SILENT;
22130         ucmd_buf.uscsi_timeout  = 60;
22131 
22132         status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL,
22133             UIO_SYSSPACE, SD_PATH_DIRECT);
22134 
22135         /*
22136          * Only handle status == 0, the upper-level caller
22137          * will put different assessment based on the context.
22138          */
22139         if (status == 0) {
22140                 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
22141 
22142                 if (ucmd_buf.uscsi_resid != 0) {
22143                         status = EIO;
22144                 }
22145         }
22146 
22147         SD_TRACE(SD_LOG_IO, un,
22148             "sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION: exit\n");
22149 
22150         return (status);
22151 }
22152 
22153 
22154 static boolean_t
22155 sd_gesn_media_data_valid(uchar_t *data)
22156 {
22157         uint16_t                        len;
22158 
22159         len = (data[1] << 8) | data[0];
22160         return ((len >= 6) &&
22161             ((data[2] & SD_GESN_HEADER_NEA) == 0) &&
22162             ((data[2] & SD_GESN_HEADER_CLASS) == SD_GESN_MEDIA_CLASS) &&
22163             ((data[3] & (1 << SD_GESN_MEDIA_CLASS)) != 0));
22164 }
22165 
22166 
22167 /*
22168  *    Function: sdioctl
22169  *
22170  * Description: Driver's ioctl(9e) entry point function.
22171  *
22172  *   Arguments: dev     - device number
22173  *              cmd     - ioctl operation to be performed
22174  *              arg     - user argument, contains data to be set or reference
22175  *                        parameter for get
22176  *              flag    - bit flag, indicating open settings, 32/64 bit type
22177  *              cred_p  - user credential pointer
22178  *              rval_p  - calling process return value (OPT)
22179  *
22180  * Return Code: EINVAL
22181  *              ENOTTY
22182  *              ENXIO
22183  *              EIO
22184  *              EFAULT
22185  *              ENOTSUP
22186  *              EPERM
22187  *
22188  *     Context: Called from the device switch at normal priority.
22189  */
22190 
22191 static int
22192 sdioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cred_p, int *rval_p)
22193 {
22194         struct sd_lun   *un = NULL;
22195         int             err = 0;
22196         int             i = 0;
22197         cred_t          *cr;
22198         int             tmprval = EINVAL;
22199         boolean_t       is_valid;
22200         sd_ssc_t        *ssc;
22201 
22202         /*
22203          * All device accesses go thru sdstrategy where we check on suspend
22204          * status
22205          */
22206         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
22207                 return (ENXIO);
22208         }
22209 
22210         ASSERT(!mutex_owned(SD_MUTEX(un)));
22211 
22212         /* Initialize sd_ssc_t for internal uscsi commands */
22213         ssc = sd_ssc_init(un);
22214 
22215         is_valid = SD_IS_VALID_LABEL(un);
22216 
22217         /*
22218          * Moved this wait from sd_uscsi_strategy to here for
22219          * reasons of deadlock prevention. Internal driver commands,
22220          * specifically those to change a devices power level, result
22221          * in a call to sd_uscsi_strategy.
22222          */
22223         mutex_enter(SD_MUTEX(un));
22224         while ((un->un_state == SD_STATE_SUSPENDED) ||
22225             (un->un_state == SD_STATE_PM_CHANGING)) {
22226                 cv_wait(&un->un_suspend_cv, SD_MUTEX(un));
22227         }
22228         /*
22229          * Twiddling the counter here protects commands from now
22230          * through to the top of sd_uscsi_strategy. Without the
22231          * counter inc. a power down, for example, could get in
22232          * after the above check for state is made and before
22233          * execution gets to the top of sd_uscsi_strategy.
22234          * That would cause problems.
22235          */
22236         un->un_ncmds_in_driver++;
22237 
22238         if (!is_valid &&
22239             (flag & (FNDELAY | FNONBLOCK))) {
22240                 switch (cmd) {
22241                 case DKIOCGGEOM:        /* SD_PATH_DIRECT */
22242                 case DKIOCGVTOC:
22243                 case DKIOCGEXTVTOC:
22244                 case DKIOCGAPART:
22245                 case DKIOCPARTINFO:
22246                 case DKIOCEXTPARTINFO:
22247                 case DKIOCSGEOM:
22248                 case DKIOCSAPART:
22249                 case DKIOCGETEFI:
22250                 case DKIOCPARTITION:
22251                 case DKIOCSVTOC:
22252                 case DKIOCSEXTVTOC:
22253                 case DKIOCSETEFI:
22254                 case DKIOCGMBOOT:
22255                 case DKIOCSMBOOT:
22256                 case DKIOCG_PHYGEOM:
22257                 case DKIOCG_VIRTGEOM:
22258 #if defined(__i386) || defined(__amd64)
22259                 case DKIOCSETEXTPART:
22260 #endif
22261                         /* let cmlb handle it */
22262                         goto skip_ready_valid;
22263 
22264                 case CDROMPAUSE:
22265                 case CDROMRESUME:
22266                 case CDROMPLAYMSF:
22267                 case CDROMPLAYTRKIND:
22268                 case CDROMREADTOCHDR:
22269                 case CDROMREADTOCENTRY:
22270                 case CDROMSTOP:
22271                 case CDROMSTART:
22272                 case CDROMVOLCTRL:
22273                 case CDROMSUBCHNL:
22274                 case CDROMREADMODE2:
22275                 case CDROMREADMODE1:
22276                 case CDROMREADOFFSET:
22277                 case CDROMSBLKMODE:
22278                 case CDROMGBLKMODE:
22279                 case CDROMGDRVSPEED:
22280                 case CDROMSDRVSPEED:
22281                 case CDROMCDDA:
22282                 case CDROMCDXA:
22283                 case CDROMSUBCODE:
22284                         if (!ISCD(un)) {
22285                                 un->un_ncmds_in_driver--;
22286                                 ASSERT(un->un_ncmds_in_driver >= 0);
22287                                 mutex_exit(SD_MUTEX(un));
22288                                 err = ENOTTY;
22289                                 goto done_without_assess;
22290                         }
22291                         break;
22292                 case FDEJECT:
22293                 case DKIOCEJECT:
22294                 case CDROMEJECT:
22295                         if (!un->un_f_eject_media_supported) {
22296                                 un->un_ncmds_in_driver--;
22297                                 ASSERT(un->un_ncmds_in_driver >= 0);
22298                                 mutex_exit(SD_MUTEX(un));
22299                                 err = ENOTTY;
22300                                 goto done_without_assess;
22301                         }
22302                         break;
22303                 case DKIOCFLUSHWRITECACHE:
22304                         mutex_exit(SD_MUTEX(un));
22305                         err = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
22306                         if (err != 0) {
22307                                 mutex_enter(SD_MUTEX(un));
22308                                 un->un_ncmds_in_driver--;
22309                                 ASSERT(un->un_ncmds_in_driver >= 0);
22310                                 mutex_exit(SD_MUTEX(un));
22311                                 err = EIO;
22312                                 goto done_quick_assess;
22313                         }
22314                         mutex_enter(SD_MUTEX(un));
22315                         /* FALLTHROUGH */
22316                 case DKIOCREMOVABLE:
22317                 case DKIOCHOTPLUGGABLE:
22318                 case DKIOCINFO:
22319                 case DKIOCGMEDIAINFO:
22320                 case DKIOCGMEDIAINFOEXT:
22321                 case MHIOCENFAILFAST:
22322                 case MHIOCSTATUS:
22323                 case MHIOCTKOWN:
22324                 case MHIOCRELEASE:
22325                 case MHIOCGRP_INKEYS:
22326                 case MHIOCGRP_INRESV:
22327                 case MHIOCGRP_REGISTER:
22328                 case MHIOCGRP_CLEAR:
22329                 case MHIOCGRP_RESERVE:
22330                 case MHIOCGRP_PREEMPTANDABORT:
22331                 case MHIOCGRP_REGISTERANDIGNOREKEY:
22332                 case CDROMCLOSETRAY:
22333                 case USCSICMD:
22334                         goto skip_ready_valid;
22335                 default:
22336                         break;
22337                 }
22338 
22339                 mutex_exit(SD_MUTEX(un));
22340                 err = sd_ready_and_valid(ssc, SDPART(dev));
22341                 mutex_enter(SD_MUTEX(un));
22342 
22343                 if (err != SD_READY_VALID) {
22344                         switch (cmd) {
22345                         case DKIOCSTATE:
22346                         case CDROMGDRVSPEED:
22347                         case CDROMSDRVSPEED:
22348                         case FDEJECT:   /* for eject command */
22349                         case DKIOCEJECT:
22350                         case CDROMEJECT:
22351                         case DKIOCREMOVABLE:
22352                         case DKIOCHOTPLUGGABLE:
22353                                 break;
22354                         default:
22355                                 if (un->un_f_has_removable_media) {
22356                                         err = ENXIO;
22357                                 } else {
22358                                 /* Do not map SD_RESERVED_BY_OTHERS to EIO */
22359                                         if (err == SD_RESERVED_BY_OTHERS) {
22360                                                 err = EACCES;
22361                                         } else {
22362                                                 err = EIO;
22363                                         }
22364                                 }
22365                                 un->un_ncmds_in_driver--;
22366                                 ASSERT(un->un_ncmds_in_driver >= 0);
22367                                 mutex_exit(SD_MUTEX(un));
22368 
22369                                 goto done_without_assess;
22370                         }
22371                 }
22372         }
22373 
22374 skip_ready_valid:
22375         mutex_exit(SD_MUTEX(un));
22376 
22377         switch (cmd) {
22378         case DKIOCINFO:
22379                 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCINFO\n");
22380                 err = sd_dkio_ctrl_info(dev, (caddr_t)arg, flag);
22381                 break;
22382 
22383         case DKIOCGMEDIAINFO:
22384                 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCGMEDIAINFO\n");
22385                 err = sd_get_media_info(dev, (caddr_t)arg, flag);
22386                 break;
22387 
22388         case DKIOCGMEDIAINFOEXT:
22389                 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCGMEDIAINFOEXT\n");
22390                 err = sd_get_media_info_ext(dev, (caddr_t)arg, flag);
22391                 break;
22392 
22393         case DKIOCGGEOM:
22394         case DKIOCGVTOC:
22395         case DKIOCGEXTVTOC:
22396         case DKIOCGAPART:
22397         case DKIOCPARTINFO:
22398         case DKIOCEXTPARTINFO:
22399         case DKIOCSGEOM:
22400         case DKIOCSAPART:
22401         case DKIOCGETEFI:
22402         case DKIOCPARTITION:
22403         case DKIOCSVTOC:
22404         case DKIOCSEXTVTOC:
22405         case DKIOCSETEFI:
22406         case DKIOCGMBOOT:
22407         case DKIOCSMBOOT:
22408         case DKIOCG_PHYGEOM:
22409         case DKIOCG_VIRTGEOM:
22410 #if defined(__i386) || defined(__amd64)
22411         case DKIOCSETEXTPART:
22412 #endif
22413                 SD_TRACE(SD_LOG_IOCTL, un, "DKIOC %d\n", cmd);
22414 
22415                 /* TUR should spin up */
22416 
22417                 if (un->un_f_has_removable_media)
22418                         err = sd_send_scsi_TEST_UNIT_READY(ssc,
22419                             SD_CHECK_FOR_MEDIA);
22420 
22421                 else
22422                         err = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
22423 
22424                 if (err != 0)
22425                         goto done_with_assess;
22426 
22427                 err = cmlb_ioctl(un->un_cmlbhandle, dev,
22428                     cmd, arg, flag, cred_p, rval_p, (void *)SD_PATH_DIRECT);
22429 
22430                 if ((err == 0) &&
22431                     ((cmd == DKIOCSETEFI) ||
22432                     (un->un_f_pkstats_enabled) &&
22433                     (cmd == DKIOCSAPART || cmd == DKIOCSVTOC ||
22434                     cmd == DKIOCSEXTVTOC))) {
22435 
22436                         tmprval = cmlb_validate(un->un_cmlbhandle, CMLB_SILENT,
22437                             (void *)SD_PATH_DIRECT);
22438                         if ((tmprval == 0) && un->un_f_pkstats_enabled) {
22439                                 sd_set_pstats(un);
22440                                 SD_TRACE(SD_LOG_IO_PARTITION, un,
22441                                     "sd_ioctl: un:0x%p pstats created and "
22442                                     "set\n", un);
22443                         }
22444                 }
22445 
22446                 if ((cmd == DKIOCSVTOC || cmd == DKIOCSEXTVTOC) ||
22447                     ((cmd == DKIOCSETEFI) && (tmprval == 0))) {
22448 
22449                         mutex_enter(SD_MUTEX(un));
22450                         if (un->un_f_devid_supported &&
22451                             (un->un_f_opt_fab_devid == TRUE)) {
22452                                 if (un->un_devid == NULL) {
22453                                         sd_register_devid(ssc, SD_DEVINFO(un),
22454                                             SD_TARGET_IS_UNRESERVED);
22455                                 } else {
22456                                         /*
22457                                          * The device id for this disk
22458                                          * has been fabricated. The
22459                                          * device id must be preserved
22460                                          * by writing it back out to
22461                                          * disk.
22462                                          */
22463                                         if (sd_write_deviceid(ssc) != 0) {
22464                                                 ddi_devid_free(un->un_devid);
22465                                                 un->un_devid = NULL;
22466                                         }
22467                                 }
22468                         }
22469                         mutex_exit(SD_MUTEX(un));
22470                 }
22471 
22472                 break;
22473 
22474         case DKIOCLOCK:
22475                 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCLOCK\n");
22476                 err = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_PREVENT,
22477                     SD_PATH_STANDARD);
22478                 goto done_with_assess;
22479 
22480         case DKIOCUNLOCK:
22481                 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCUNLOCK\n");
22482                 err = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_ALLOW,
22483                     SD_PATH_STANDARD);
22484                 goto done_with_assess;
22485 
22486         case DKIOCSTATE: {
22487                 enum dkio_state         state;
22488                 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCSTATE\n");
22489 
22490                 if (ddi_copyin((void *)arg, &state, sizeof (int), flag) != 0) {
22491                         err = EFAULT;
22492                 } else {
22493                         err = sd_check_media(dev, state);
22494                         if (err == 0) {
22495                                 if (ddi_copyout(&un->un_mediastate, (void *)arg,
22496                                     sizeof (int), flag) != 0)
22497                                         err = EFAULT;
22498                         }
22499                 }
22500                 break;
22501         }
22502 
22503         case DKIOCREMOVABLE:
22504                 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCREMOVABLE\n");
22505                 i = un->un_f_has_removable_media ? 1 : 0;
22506                 if (ddi_copyout(&i, (void *)arg, sizeof (int), flag) != 0) {
22507                         err = EFAULT;
22508                 } else {
22509                         err = 0;
22510                 }
22511                 break;
22512 
22513         case DKIOCHOTPLUGGABLE:
22514                 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCHOTPLUGGABLE\n");
22515                 i = un->un_f_is_hotpluggable ? 1 : 0;
22516                 if (ddi_copyout(&i, (void *)arg, sizeof (int), flag) != 0) {
22517                         err = EFAULT;
22518                 } else {
22519                         err = 0;
22520                 }
22521                 break;
22522 
22523         case DKIOCREADONLY:
22524                 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCREADONLY\n");
22525                 i = 0;
22526                 if ((ISCD(un) && !un->un_f_mmc_writable_media) ||
22527                     (sr_check_wp(dev) != 0)) {
22528                         i = 1;
22529                 }
22530                 if (ddi_copyout(&i, (void *)arg, sizeof (int), flag) != 0) {
22531                         err = EFAULT;
22532                 } else {
22533                         err = 0;
22534                 }
22535                 break;
22536 
22537         case DKIOCGTEMPERATURE:
22538                 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCGTEMPERATURE\n");
22539                 err = sd_dkio_get_temp(dev, (caddr_t)arg, flag);
22540                 break;
22541 
22542         case MHIOCENFAILFAST:
22543                 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCENFAILFAST\n");
22544                 if ((err = drv_priv(cred_p)) == 0) {
22545                         err = sd_mhdioc_failfast(dev, (caddr_t)arg, flag);
22546                 }
22547                 break;
22548 
22549         case MHIOCTKOWN:
22550                 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCTKOWN\n");
22551                 if ((err = drv_priv(cred_p)) == 0) {
22552                         err = sd_mhdioc_takeown(dev, (caddr_t)arg, flag);
22553                 }
22554                 break;
22555 
22556         case MHIOCRELEASE:
22557                 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCRELEASE\n");
22558                 if ((err = drv_priv(cred_p)) == 0) {
22559                         err = sd_mhdioc_release(dev);
22560                 }
22561                 break;
22562 
22563         case MHIOCSTATUS:
22564                 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCSTATUS\n");
22565                 if ((err = drv_priv(cred_p)) == 0) {
22566                         switch (sd_send_scsi_TEST_UNIT_READY(ssc, 0)) {
22567                         case 0:
22568                                 err = 0;
22569                                 break;
22570                         case EACCES:
22571                                 *rval_p = 1;
22572                                 err = 0;
22573                                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
22574                                 break;
22575                         default:
22576                                 err = EIO;
22577                                 goto done_with_assess;
22578                         }
22579                 }
22580                 break;
22581 
22582         case MHIOCQRESERVE:
22583                 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCQRESERVE\n");
22584                 if ((err = drv_priv(cred_p)) == 0) {
22585                         err = sd_reserve_release(dev, SD_RESERVE);
22586                 }
22587                 break;
22588 
22589         case MHIOCREREGISTERDEVID:
22590                 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCREREGISTERDEVID\n");
22591                 if (drv_priv(cred_p) == EPERM) {
22592                         err = EPERM;
22593                 } else if (!un->un_f_devid_supported) {
22594                         err = ENOTTY;
22595                 } else {
22596                         err = sd_mhdioc_register_devid(dev);
22597                 }
22598                 break;
22599 
22600         case MHIOCGRP_INKEYS:
22601                 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_INKEYS\n");
22602                 if (((err = drv_priv(cred_p)) != EPERM) && arg != NULL) {
22603                         if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22604                                 err = ENOTSUP;
22605                         } else {
22606                                 err = sd_mhdioc_inkeys(dev, (caddr_t)arg,
22607                                     flag);
22608                         }
22609                 }
22610                 break;
22611 
22612         case MHIOCGRP_INRESV:
22613                 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_INRESV\n");
22614                 if (((err = drv_priv(cred_p)) != EPERM) && arg != NULL) {
22615                         if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22616                                 err = ENOTSUP;
22617                         } else {
22618                                 err = sd_mhdioc_inresv(dev, (caddr_t)arg, flag);
22619                         }
22620                 }
22621                 break;
22622 
22623         case MHIOCGRP_REGISTER:
22624                 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_REGISTER\n");
22625                 if ((err = drv_priv(cred_p)) != EPERM) {
22626                         if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22627                                 err = ENOTSUP;
22628                         } else if (arg != NULL) {
22629                                 mhioc_register_t reg;
22630                                 if (ddi_copyin((void *)arg, &reg,
22631                                     sizeof (mhioc_register_t), flag) != 0) {
22632                                         err = EFAULT;
22633                                 } else {
22634                                         err =
22635                                             sd_send_scsi_PERSISTENT_RESERVE_OUT(
22636                                             ssc, SD_SCSI3_REGISTER,
22637                                             (uchar_t *)&reg);
22638                                         if (err != 0)
22639                                                 goto done_with_assess;
22640                                 }
22641                         }
22642                 }
22643                 break;
22644 
22645         case MHIOCGRP_CLEAR:
22646                 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_CLEAR\n");
22647                 if ((err = drv_priv(cred_p)) != EPERM) {
22648                         if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22649                                 err = ENOTSUP;
22650                         } else if (arg != NULL) {
22651                                 mhioc_register_t reg;
22652                                 if (ddi_copyin((void *)arg, &reg,
22653                                     sizeof (mhioc_register_t), flag) != 0) {
22654                                         err = EFAULT;
22655                                 } else {
22656                                         err =
22657                                             sd_send_scsi_PERSISTENT_RESERVE_OUT(
22658                                             ssc, SD_SCSI3_CLEAR,
22659                                             (uchar_t *)&reg);
22660                                         if (err != 0)
22661                                                 goto done_with_assess;
22662                                 }
22663                         }
22664                 }
22665                 break;
22666 
22667         case MHIOCGRP_RESERVE:
22668                 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_RESERVE\n");
22669                 if ((err = drv_priv(cred_p)) != EPERM) {
22670                         if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22671                                 err = ENOTSUP;
22672                         } else if (arg != NULL) {
22673                                 mhioc_resv_desc_t resv_desc;
22674                                 if (ddi_copyin((void *)arg, &resv_desc,
22675                                     sizeof (mhioc_resv_desc_t), flag) != 0) {
22676                                         err = EFAULT;
22677                                 } else {
22678                                         err =
22679                                             sd_send_scsi_PERSISTENT_RESERVE_OUT(
22680                                             ssc, SD_SCSI3_RESERVE,
22681                                             (uchar_t *)&resv_desc);
22682                                         if (err != 0)
22683                                                 goto done_with_assess;
22684                                 }
22685                         }
22686                 }
22687                 break;
22688 
22689         case MHIOCGRP_PREEMPTANDABORT:
22690                 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_PREEMPTANDABORT\n");
22691                 if ((err = drv_priv(cred_p)) != EPERM) {
22692                         if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22693                                 err = ENOTSUP;
22694                         } else if (arg != NULL) {
22695                                 mhioc_preemptandabort_t preempt_abort;
22696                                 if (ddi_copyin((void *)arg, &preempt_abort,
22697                                     sizeof (mhioc_preemptandabort_t),
22698                                     flag) != 0) {
22699                                         err = EFAULT;
22700                                 } else {
22701                                         err =
22702                                             sd_send_scsi_PERSISTENT_RESERVE_OUT(
22703                                             ssc, SD_SCSI3_PREEMPTANDABORT,
22704                                             (uchar_t *)&preempt_abort);
22705                                         if (err != 0)
22706                                                 goto done_with_assess;
22707                                 }
22708                         }
22709                 }
22710                 break;
22711 
22712         case MHIOCGRP_REGISTERANDIGNOREKEY:
22713                 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_REGISTERANDIGNOREKEY\n");
22714                 if ((err = drv_priv(cred_p)) != EPERM) {
22715                         if (un->un_reservation_type == SD_SCSI2_RESERVATION) {
22716                                 err = ENOTSUP;
22717                         } else if (arg != NULL) {
22718                                 mhioc_registerandignorekey_t r_and_i;
22719                                 if (ddi_copyin((void *)arg, (void *)&r_and_i,
22720                                     sizeof (mhioc_registerandignorekey_t),
22721                                     flag) != 0) {
22722                                         err = EFAULT;
22723                                 } else {
22724                                         err =
22725                                             sd_send_scsi_PERSISTENT_RESERVE_OUT(
22726                                             ssc, SD_SCSI3_REGISTERANDIGNOREKEY,
22727                                             (uchar_t *)&r_and_i);
22728                                         if (err != 0)
22729                                                 goto done_with_assess;
22730                                 }
22731                         }
22732                 }
22733                 break;
22734 
22735         case USCSICMD:
22736                 SD_TRACE(SD_LOG_IOCTL, un, "USCSICMD\n");
22737                 cr = ddi_get_cred();
22738                 if ((drv_priv(cred_p) != 0) && (drv_priv(cr) != 0)) {
22739                         err = EPERM;
22740                 } else {
22741                         enum uio_seg    uioseg;
22742 
22743                         uioseg = (flag & FKIOCTL) ? UIO_SYSSPACE :
22744                             UIO_USERSPACE;
22745                         if (un->un_f_format_in_progress == TRUE) {
22746                                 err = EAGAIN;
22747                                 break;
22748                         }
22749 
22750                         err = sd_ssc_send(ssc,
22751                             (struct uscsi_cmd *)arg,
22752                             flag, uioseg, SD_PATH_STANDARD);
22753                         if (err != 0)
22754                                 goto done_with_assess;
22755                         else
22756                                 sd_ssc_assessment(ssc, SD_FMT_STANDARD);
22757                 }
22758                 break;
22759 
22760         case CDROMPAUSE:
22761         case CDROMRESUME:
22762                 SD_TRACE(SD_LOG_IOCTL, un, "PAUSE-RESUME\n");
22763                 if (!ISCD(un)) {
22764                         err = ENOTTY;
22765                 } else {
22766                         err = sr_pause_resume(dev, cmd);
22767                 }
22768                 break;
22769 
22770         case CDROMPLAYMSF:
22771                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMPLAYMSF\n");
22772                 if (!ISCD(un)) {
22773                         err = ENOTTY;
22774                 } else {
22775                         err = sr_play_msf(dev, (caddr_t)arg, flag);
22776                 }
22777                 break;
22778 
22779         case CDROMPLAYTRKIND:
22780                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMPLAYTRKIND\n");
22781 #if defined(__i386) || defined(__amd64)
22782                 /*
22783                  * not supported on ATAPI CD drives, use CDROMPLAYMSF instead
22784                  */
22785                 if (!ISCD(un) || (un->un_f_cfg_is_atapi == TRUE)) {
22786 #else
22787                 if (!ISCD(un)) {
22788 #endif
22789                         err = ENOTTY;
22790                 } else {
22791                         err = sr_play_trkind(dev, (caddr_t)arg, flag);
22792                 }
22793                 break;
22794 
22795         case CDROMREADTOCHDR:
22796                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADTOCHDR\n");
22797                 if (!ISCD(un)) {
22798                         err = ENOTTY;
22799                 } else {
22800                         err = sr_read_tochdr(dev, (caddr_t)arg, flag);
22801                 }
22802                 break;
22803 
22804         case CDROMREADTOCENTRY:
22805                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADTOCENTRY\n");
22806                 if (!ISCD(un)) {
22807                         err = ENOTTY;
22808                 } else {
22809                         err = sr_read_tocentry(dev, (caddr_t)arg, flag);
22810                 }
22811                 break;
22812 
22813         case CDROMSTOP:
22814                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSTOP\n");
22815                 if (!ISCD(un)) {
22816                         err = ENOTTY;
22817                 } else {
22818                         err = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
22819                             SD_TARGET_STOP, SD_PATH_STANDARD);
22820                         goto done_with_assess;
22821                 }
22822                 break;
22823 
22824         case CDROMSTART:
22825                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSTART\n");
22826                 if (!ISCD(un)) {
22827                         err = ENOTTY;
22828                 } else {
22829                         err = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
22830                             SD_TARGET_START, SD_PATH_STANDARD);
22831                         goto done_with_assess;
22832                 }
22833                 break;
22834 
22835         case CDROMCLOSETRAY:
22836                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMCLOSETRAY\n");
22837                 if (!ISCD(un)) {
22838                         err = ENOTTY;
22839                 } else {
22840                         err = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
22841                             SD_TARGET_CLOSE, SD_PATH_STANDARD);
22842                         goto done_with_assess;
22843                 }
22844                 break;
22845 
22846         case FDEJECT:   /* for eject command */
22847         case DKIOCEJECT:
22848         case CDROMEJECT:
22849                 SD_TRACE(SD_LOG_IOCTL, un, "EJECT\n");
22850                 if (!un->un_f_eject_media_supported) {
22851                         err = ENOTTY;
22852                 } else {
22853                         err = sr_eject(dev);
22854                 }
22855                 break;
22856 
22857         case CDROMVOLCTRL:
22858                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMVOLCTRL\n");
22859                 if (!ISCD(un)) {
22860                         err = ENOTTY;
22861                 } else {
22862                         err = sr_volume_ctrl(dev, (caddr_t)arg, flag);
22863                 }
22864                 break;
22865 
22866         case CDROMSUBCHNL:
22867                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSUBCHNL\n");
22868                 if (!ISCD(un)) {
22869                         err = ENOTTY;
22870                 } else {
22871                         err = sr_read_subchannel(dev, (caddr_t)arg, flag);
22872                 }
22873                 break;
22874 
22875         case CDROMREADMODE2:
22876                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADMODE2\n");
22877                 if (!ISCD(un)) {
22878                         err = ENOTTY;
22879                 } else if (un->un_f_cfg_is_atapi == TRUE) {
22880                         /*
22881                          * If the drive supports READ CD, use that instead of
22882                          * switching the LBA size via a MODE SELECT
22883                          * Block Descriptor
22884                          */
22885                         err = sr_read_cd_mode2(dev, (caddr_t)arg, flag);
22886                 } else {
22887                         err = sr_read_mode2(dev, (caddr_t)arg, flag);
22888                 }
22889                 break;
22890 
22891         case CDROMREADMODE1:
22892                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADMODE1\n");
22893                 if (!ISCD(un)) {
22894                         err = ENOTTY;
22895                 } else {
22896                         err = sr_read_mode1(dev, (caddr_t)arg, flag);
22897                 }
22898                 break;
22899 
22900         case CDROMREADOFFSET:
22901                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADOFFSET\n");
22902                 if (!ISCD(un)) {
22903                         err = ENOTTY;
22904                 } else {
22905                         err = sr_read_sony_session_offset(dev, (caddr_t)arg,
22906                             flag);
22907                 }
22908                 break;
22909 
22910         case CDROMSBLKMODE:
22911                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSBLKMODE\n");
22912                 /*
22913                  * There is no means of changing block size in case of atapi
22914                  * drives, thus return ENOTTY if drive type is atapi
22915                  */
22916                 if (!ISCD(un) || (un->un_f_cfg_is_atapi == TRUE)) {
22917                         err = ENOTTY;
22918                 } else if (un->un_f_mmc_cap == TRUE) {
22919 
22920                         /*
22921                          * MMC Devices do not support changing the
22922                          * logical block size
22923                          *
22924                          * Note: EINVAL is being returned instead of ENOTTY to
22925                          * maintain consistancy with the original mmc
22926                          * driver update.
22927                          */
22928                         err = EINVAL;
22929                 } else {
22930                         mutex_enter(SD_MUTEX(un));
22931                         if ((!(un->un_exclopen & (1<<SDPART(dev)))) ||
22932                             (un->un_ncmds_in_transport > 0)) {
22933                                 mutex_exit(SD_MUTEX(un));
22934                                 err = EINVAL;
22935                         } else {
22936                                 mutex_exit(SD_MUTEX(un));
22937                                 err = sr_change_blkmode(dev, cmd, arg, flag);
22938                         }
22939                 }
22940                 break;
22941 
22942         case CDROMGBLKMODE:
22943                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMGBLKMODE\n");
22944                 if (!ISCD(un)) {
22945                         err = ENOTTY;
22946                 } else if ((un->un_f_cfg_is_atapi != FALSE) &&
22947                     (un->un_f_blockcount_is_valid != FALSE)) {
22948                         /*
22949                          * Drive is an ATAPI drive so return target block
22950                          * size for ATAPI drives since we cannot change the
22951                          * blocksize on ATAPI drives. Used primarily to detect
22952                          * if an ATAPI cdrom is present.
22953                          */
22954                         if (ddi_copyout(&un->un_tgt_blocksize, (void *)arg,
22955                             sizeof (int), flag) != 0) {
22956                                 err = EFAULT;
22957                         } else {
22958                                 err = 0;
22959                         }
22960 
22961                 } else {
22962                         /*
22963                          * Drive supports changing block sizes via a Mode
22964                          * Select.
22965                          */
22966                         err = sr_change_blkmode(dev, cmd, arg, flag);
22967                 }
22968                 break;
22969 
22970         case CDROMGDRVSPEED:
22971         case CDROMSDRVSPEED:
22972                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMXDRVSPEED\n");
22973                 if (!ISCD(un)) {
22974                         err = ENOTTY;
22975                 } else if (un->un_f_mmc_cap == TRUE) {
22976                         /*
22977                          * Note: In the future the driver implementation
22978                          * for getting and
22979                          * setting cd speed should entail:
22980                          * 1) If non-mmc try the Toshiba mode page
22981                          *    (sr_change_speed)
22982                          * 2) If mmc but no support for Real Time Streaming try
22983                          *    the SET CD SPEED (0xBB) command
22984                          *   (sr_atapi_change_speed)
22985                          * 3) If mmc and support for Real Time Streaming
22986                          *    try the GET PERFORMANCE and SET STREAMING
22987                          *    commands (not yet implemented, 4380808)
22988                          */
22989                         /*
22990                          * As per recent MMC spec, CD-ROM speed is variable
22991                          * and changes with LBA. Since there is no such
22992                          * things as drive speed now, fail this ioctl.
22993                          *
22994                          * Note: EINVAL is returned for consistancy of original
22995                          * implementation which included support for getting
22996                          * the drive speed of mmc devices but not setting
22997                          * the drive speed. Thus EINVAL would be returned
22998                          * if a set request was made for an mmc device.
22999                          * We no longer support get or set speed for
23000                          * mmc but need to remain consistent with regard
23001                          * to the error code returned.
23002                          */
23003                         err = EINVAL;
23004                 } else if (un->un_f_cfg_is_atapi == TRUE) {
23005                         err = sr_atapi_change_speed(dev, cmd, arg, flag);
23006                 } else {
23007                         err = sr_change_speed(dev, cmd, arg, flag);
23008                 }
23009                 break;
23010 
23011         case CDROMCDDA:
23012                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMCDDA\n");
23013                 if (!ISCD(un)) {
23014                         err = ENOTTY;
23015                 } else {
23016                         err = sr_read_cdda(dev, (void *)arg, flag);
23017                 }
23018                 break;
23019 
23020         case CDROMCDXA:
23021                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMCDXA\n");
23022                 if (!ISCD(un)) {
23023                         err = ENOTTY;
23024                 } else {
23025                         err = sr_read_cdxa(dev, (caddr_t)arg, flag);
23026                 }
23027                 break;
23028 
23029         case CDROMSUBCODE:
23030                 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSUBCODE\n");
23031                 if (!ISCD(un)) {
23032                         err = ENOTTY;
23033                 } else {
23034                         err = sr_read_all_subcodes(dev, (caddr_t)arg, flag);
23035                 }
23036                 break;
23037 
23038 
23039 #ifdef SDDEBUG
23040 /* RESET/ABORTS testing ioctls */
23041         case DKIOCRESET: {
23042                 int     reset_level;
23043 
23044                 if (ddi_copyin((void *)arg, &reset_level, sizeof (int), flag)) {
23045                         err = EFAULT;
23046                 } else {
23047                         SD_INFO(SD_LOG_IOCTL, un, "sdioctl: DKIOCRESET: "
23048                             "reset_level = 0x%lx\n", reset_level);
23049                         if (scsi_reset(SD_ADDRESS(un), reset_level)) {
23050                                 err = 0;
23051                         } else {
23052                                 err = EIO;
23053                         }
23054                 }
23055                 break;
23056         }
23057 
23058         case DKIOCABORT:
23059                 SD_INFO(SD_LOG_IOCTL, un, "sdioctl: DKIOCABORT:\n");
23060                 if (scsi_abort(SD_ADDRESS(un), NULL)) {
23061                         err = 0;
23062                 } else {
23063                         err = EIO;
23064                 }
23065                 break;
23066 #endif
23067 
23068 #ifdef SD_FAULT_INJECTION
23069 /* SDIOC FaultInjection testing ioctls */
23070         case SDIOCSTART:
23071         case SDIOCSTOP:
23072         case SDIOCINSERTPKT:
23073         case SDIOCINSERTXB:
23074         case SDIOCINSERTUN:
23075         case SDIOCINSERTARQ:
23076         case SDIOCPUSH:
23077         case SDIOCRETRIEVE:
23078         case SDIOCRUN:
23079                 SD_INFO(SD_LOG_SDTEST, un, "sdioctl:"
23080                     "SDIOC detected cmd:0x%X:\n", cmd);
23081                 /* call error generator */
23082                 sd_faultinjection_ioctl(cmd, arg, un);
23083                 err = 0;
23084                 break;
23085 
23086 #endif /* SD_FAULT_INJECTION */
23087 
23088         case DKIOCFLUSHWRITECACHE:
23089                 {
23090                         struct dk_callback *dkc = (struct dk_callback *)arg;
23091 
23092                         mutex_enter(SD_MUTEX(un));
23093                         if (!un->un_f_sync_cache_supported ||
23094                             !un->un_f_write_cache_enabled) {
23095                                 err = un->un_f_sync_cache_supported ?
23096                                     0 : ENOTSUP;
23097                                 mutex_exit(SD_MUTEX(un));
23098                                 if ((flag & FKIOCTL) && dkc != NULL &&
23099                                     dkc->dkc_callback != NULL) {
23100                                         (*dkc->dkc_callback)(dkc->dkc_cookie,
23101                                             err);
23102                                         /*
23103                                          * Did callback and reported error.
23104                                          * Since we did a callback, ioctl
23105                                          * should return 0.
23106                                          */
23107                                         err = 0;
23108                                 }
23109                                 break;
23110                         }
23111                         mutex_exit(SD_MUTEX(un));
23112 
23113                         if ((flag & FKIOCTL) && dkc != NULL &&
23114                             dkc->dkc_callback != NULL) {
23115                                 /* async SYNC CACHE request */
23116                                 err = sd_send_scsi_SYNCHRONIZE_CACHE(un, dkc);
23117                         } else {
23118                                 /* synchronous SYNC CACHE request */
23119                                 err = sd_send_scsi_SYNCHRONIZE_CACHE(un, NULL);
23120                         }
23121                 }
23122                 break;
23123 
23124         case DKIOCGETWCE: {
23125 
23126                 int wce;
23127 
23128                 if ((err = sd_get_write_cache_enabled(ssc, &wce)) != 0) {
23129                         break;
23130                 }
23131 
23132                 if (ddi_copyout(&wce, (void *)arg, sizeof (wce), flag)) {
23133                         err = EFAULT;
23134                 }
23135                 break;
23136         }
23137 
23138         case DKIOCSETWCE: {
23139 
23140                 int wce, sync_supported;
23141                 int cur_wce = 0;
23142 
23143                 if (ddi_copyin((void *)arg, &wce, sizeof (wce), flag)) {
23144                         err = EFAULT;
23145                         break;
23146                 }
23147 
23148                 /*
23149                  * Synchronize multiple threads trying to enable
23150                  * or disable the cache via the un_f_wcc_cv
23151                  * condition variable.
23152                  */
23153                 mutex_enter(SD_MUTEX(un));
23154 
23155                 /*
23156                  * Don't allow the cache to be enabled if the
23157                  * config file has it disabled.
23158                  */
23159                 if (un->un_f_opt_disable_cache && wce) {
23160                         mutex_exit(SD_MUTEX(un));
23161                         err = EINVAL;
23162                         break;
23163                 }
23164 
23165                 /*
23166                  * Wait for write cache change in progress
23167                  * bit to be clear before proceeding.
23168                  */
23169                 while (un->un_f_wcc_inprog)
23170                         cv_wait(&un->un_wcc_cv, SD_MUTEX(un));
23171 
23172                 un->un_f_wcc_inprog = 1;
23173 
23174                 mutex_exit(SD_MUTEX(un));
23175 
23176                 /*
23177                  * Get the current write cache state
23178                  */
23179                 if ((err = sd_get_write_cache_enabled(ssc, &cur_wce)) != 0) {
23180                         mutex_enter(SD_MUTEX(un));
23181                         un->un_f_wcc_inprog = 0;
23182                         cv_broadcast(&un->un_wcc_cv);
23183                         mutex_exit(SD_MUTEX(un));
23184                         break;
23185                 }
23186 
23187                 mutex_enter(SD_MUTEX(un));
23188                 un->un_f_write_cache_enabled = (cur_wce != 0);
23189 
23190                 if (un->un_f_write_cache_enabled && wce == 0) {
23191                         /*
23192                          * Disable the write cache.  Don't clear
23193                          * un_f_write_cache_enabled until after
23194                          * the mode select and flush are complete.
23195                          */
23196                         sync_supported = un->un_f_sync_cache_supported;
23197 
23198                         /*
23199                          * If cache flush is suppressed, we assume that the
23200                          * controller firmware will take care of managing the
23201                          * write cache for us: no need to explicitly
23202                          * disable it.
23203                          */
23204                         if (!un->un_f_suppress_cache_flush) {
23205                                 mutex_exit(SD_MUTEX(un));
23206                                 if ((err = sd_cache_control(ssc,
23207                                     SD_CACHE_NOCHANGE,
23208                                     SD_CACHE_DISABLE)) == 0 &&
23209                                     sync_supported) {
23210                                         err = sd_send_scsi_SYNCHRONIZE_CACHE(un,
23211                                             NULL);
23212                                 }
23213                         } else {
23214                                 mutex_exit(SD_MUTEX(un));
23215                         }
23216 
23217                         mutex_enter(SD_MUTEX(un));
23218                         if (err == 0) {
23219                                 un->un_f_write_cache_enabled = 0;
23220                         }
23221 
23222                 } else if (!un->un_f_write_cache_enabled && wce != 0) {
23223                         /*
23224                          * Set un_f_write_cache_enabled first, so there is
23225                          * no window where the cache is enabled, but the
23226                          * bit says it isn't.
23227                          */
23228                         un->un_f_write_cache_enabled = 1;
23229 
23230                         /*
23231                          * If cache flush is suppressed, we assume that the
23232                          * controller firmware will take care of managing the
23233                          * write cache for us: no need to explicitly
23234                          * enable it.
23235                          */
23236                         if (!un->un_f_suppress_cache_flush) {
23237                                 mutex_exit(SD_MUTEX(un));
23238                                 err = sd_cache_control(ssc, SD_CACHE_NOCHANGE,
23239                                     SD_CACHE_ENABLE);
23240                         } else {
23241                                 mutex_exit(SD_MUTEX(un));
23242                         }
23243 
23244                         mutex_enter(SD_MUTEX(un));
23245 
23246                         if (err) {
23247                                 un->un_f_write_cache_enabled = 0;
23248                         }
23249                 }
23250 
23251                 un->un_f_wcc_inprog = 0;
23252                 cv_broadcast(&un->un_wcc_cv);
23253                 mutex_exit(SD_MUTEX(un));
23254                 break;
23255         }
23256 
23257         default:
23258                 err = ENOTTY;
23259                 break;
23260         }
23261         mutex_enter(SD_MUTEX(un));
23262         un->un_ncmds_in_driver--;
23263         ASSERT(un->un_ncmds_in_driver >= 0);
23264         mutex_exit(SD_MUTEX(un));
23265 
23266 
23267 done_without_assess:
23268         sd_ssc_fini(ssc);
23269 
23270         SD_TRACE(SD_LOG_IOCTL, un, "sdioctl: exit: %d\n", err);
23271         return (err);
23272 
23273 done_with_assess:
23274         mutex_enter(SD_MUTEX(un));
23275         un->un_ncmds_in_driver--;
23276         ASSERT(un->un_ncmds_in_driver >= 0);
23277         mutex_exit(SD_MUTEX(un));
23278 
23279 done_quick_assess:
23280         if (err != 0)
23281                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23282         /* Uninitialize sd_ssc_t pointer */
23283         sd_ssc_fini(ssc);
23284 
23285         SD_TRACE(SD_LOG_IOCTL, un, "sdioctl: exit: %d\n", err);
23286         return (err);
23287 }
23288 
23289 
23290 /*
23291  *    Function: sd_dkio_ctrl_info
23292  *
23293  * Description: This routine is the driver entry point for handling controller
23294  *              information ioctl requests (DKIOCINFO).
23295  *
23296  *   Arguments: dev  - the device number
23297  *              arg  - pointer to user provided dk_cinfo structure
23298  *                     specifying the controller type and attributes.
23299  *              flag - this argument is a pass through to ddi_copyxxx()
23300  *                     directly from the mode argument of ioctl().
23301  *
23302  * Return Code: 0
23303  *              EFAULT
23304  *              ENXIO
23305  */
23306 
23307 static int
23308 sd_dkio_ctrl_info(dev_t dev, caddr_t arg, int flag)
23309 {
23310         struct sd_lun   *un = NULL;
23311         struct dk_cinfo *info;
23312         dev_info_t      *pdip;
23313         int             lun, tgt;
23314 
23315         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
23316                 return (ENXIO);
23317         }
23318 
23319         info = (struct dk_cinfo *)
23320             kmem_zalloc(sizeof (struct dk_cinfo), KM_SLEEP);
23321 
23322         switch (un->un_ctype) {
23323         case CTYPE_CDROM:
23324                 info->dki_ctype = DKC_CDROM;
23325                 break;
23326         default:
23327                 info->dki_ctype = DKC_SCSI_CCS;
23328                 break;
23329         }
23330         pdip = ddi_get_parent(SD_DEVINFO(un));
23331         info->dki_cnum = ddi_get_instance(pdip);
23332         if (strlen(ddi_get_name(pdip)) < DK_DEVLEN) {
23333                 (void) strcpy(info->dki_cname, ddi_get_name(pdip));
23334         } else {
23335                 (void) strncpy(info->dki_cname, ddi_node_name(pdip),
23336                     DK_DEVLEN - 1);
23337         }
23338 
23339         lun = ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
23340             DDI_PROP_DONTPASS, SCSI_ADDR_PROP_LUN, 0);
23341         tgt = ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un),
23342             DDI_PROP_DONTPASS, SCSI_ADDR_PROP_TARGET, 0);
23343 
23344         /* Unit Information */
23345         info->dki_unit = ddi_get_instance(SD_DEVINFO(un));
23346         info->dki_slave = ((tgt << 3) | lun);
23347         (void) strncpy(info->dki_dname, ddi_driver_name(SD_DEVINFO(un)),
23348             DK_DEVLEN - 1);
23349         info->dki_flags = DKI_FMTVOL;
23350         info->dki_partition = SDPART(dev);
23351 
23352         /* Max Transfer size of this device in blocks */
23353         info->dki_maxtransfer = un->un_max_xfer_size / un->un_sys_blocksize;
23354         info->dki_addr = 0;
23355         info->dki_space = 0;
23356         info->dki_prio = 0;
23357         info->dki_vec = 0;
23358 
23359         if (ddi_copyout(info, arg, sizeof (struct dk_cinfo), flag) != 0) {
23360                 kmem_free(info, sizeof (struct dk_cinfo));
23361                 return (EFAULT);
23362         } else {
23363                 kmem_free(info, sizeof (struct dk_cinfo));
23364                 return (0);
23365         }
23366 }
23367 
23368 /*
23369  *    Function: sd_get_media_info_com
23370  *
23371  * Description: This routine returns the information required to populate
23372  *              the fields for the dk_minfo/dk_minfo_ext structures.
23373  *
23374  *   Arguments: dev             - the device number
23375  *              dki_media_type  - media_type
23376  *              dki_lbsize      - logical block size
23377  *              dki_capacity    - capacity in blocks
23378  *              dki_pbsize      - physical block size (if requested)
23379  *
23380  * Return Code: 0
23381  *              EACCESS
23382  *              EFAULT
23383  *              ENXIO
23384  *              EIO
23385  */
23386 static int
23387 sd_get_media_info_com(dev_t dev, uint_t *dki_media_type, uint_t *dki_lbsize,
23388         diskaddr_t *dki_capacity, uint_t *dki_pbsize)
23389 {
23390         struct sd_lun           *un = NULL;
23391         struct uscsi_cmd        com;
23392         struct scsi_inquiry     *sinq;
23393         u_longlong_t            media_capacity;
23394         uint64_t                capacity;
23395         uint_t                  lbasize;
23396         uint_t                  pbsize;
23397         uchar_t                 *out_data;
23398         uchar_t                 *rqbuf;
23399         int                     rval = 0;
23400         int                     rtn;
23401         sd_ssc_t                *ssc;
23402 
23403         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
23404             (un->un_state == SD_STATE_OFFLINE)) {
23405                 return (ENXIO);
23406         }
23407 
23408         SD_TRACE(SD_LOG_IOCTL_DKIO, un, "sd_get_media_info_com: entry\n");
23409 
23410         out_data = kmem_zalloc(SD_PROFILE_HEADER_LEN, KM_SLEEP);
23411         rqbuf = kmem_zalloc(SENSE_LENGTH, KM_SLEEP);
23412         ssc = sd_ssc_init(un);
23413 
23414         /* Issue a TUR to determine if the drive is ready with media present */
23415         rval = sd_send_scsi_TEST_UNIT_READY(ssc, SD_CHECK_FOR_MEDIA);
23416         if (rval == ENXIO) {
23417                 goto done;
23418         } else if (rval != 0) {
23419                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23420         }
23421 
23422         /* Now get configuration data */
23423         if (ISCD(un)) {
23424                 *dki_media_type = DK_CDROM;
23425 
23426                 /* Allow SCMD_GET_CONFIGURATION to MMC devices only */
23427                 if (un->un_f_mmc_cap == TRUE) {
23428                         rtn = sd_send_scsi_GET_CONFIGURATION(ssc, &com, rqbuf,
23429                             SENSE_LENGTH, out_data, SD_PROFILE_HEADER_LEN,
23430                             SD_PATH_STANDARD);
23431 
23432                         if (rtn) {
23433                                 /*
23434                                  * We ignore all failures for CD and need to
23435                                  * put the assessment before processing code
23436                                  * to avoid missing assessment for FMA.
23437                                  */
23438                                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23439                                 /*
23440                                  * Failed for other than an illegal request
23441                                  * or command not supported
23442                                  */
23443                                 if ((com.uscsi_status == STATUS_CHECK) &&
23444                                     (com.uscsi_rqstatus == STATUS_GOOD)) {
23445                                         if ((rqbuf[2] != KEY_ILLEGAL_REQUEST) ||
23446                                             (rqbuf[12] != 0x20)) {
23447                                                 rval = EIO;
23448                                                 goto no_assessment;
23449                                         }
23450                                 }
23451                         } else {
23452                                 /*
23453                                  * The GET CONFIGURATION command succeeded
23454                                  * so set the media type according to the
23455                                  * returned data
23456                                  */
23457                                 *dki_media_type = out_data[6];
23458                                 *dki_media_type <<= 8;
23459                                 *dki_media_type |= out_data[7];
23460                         }
23461                 }
23462         } else {
23463                 /*
23464                  * The profile list is not available, so we attempt to identify
23465                  * the media type based on the inquiry data
23466                  */
23467                 sinq = un->un_sd->sd_inq;
23468                 if ((sinq->inq_dtype == DTYPE_DIRECT) ||
23469                     (sinq->inq_dtype == DTYPE_OPTICAL)) {
23470                         /* This is a direct access device  or optical disk */
23471                         *dki_media_type = DK_FIXED_DISK;
23472 
23473                         if ((bcmp(sinq->inq_vid, "IOMEGA", 6) == 0) ||
23474                             (bcmp(sinq->inq_vid, "iomega", 6) == 0)) {
23475                                 if ((bcmp(sinq->inq_pid, "ZIP", 3) == 0)) {
23476                                         *dki_media_type = DK_ZIP;
23477                                 } else if (
23478                                     (bcmp(sinq->inq_pid, "jaz", 3) == 0)) {
23479                                         *dki_media_type = DK_JAZ;
23480                                 }
23481                         }
23482                 } else {
23483                         /*
23484                          * Not a CD, direct access or optical disk so return
23485                          * unknown media
23486                          */
23487                         *dki_media_type = DK_UNKNOWN;
23488                 }
23489         }
23490 
23491         /*
23492          * Now read the capacity so we can provide the lbasize,
23493          * pbsize and capacity.
23494          */
23495         if (dki_pbsize && un->un_f_descr_format_supported) {
23496                 rval = sd_send_scsi_READ_CAPACITY_16(ssc, &capacity, &lbasize,
23497                     &pbsize, SD_PATH_DIRECT);
23498 
23499                 /*
23500                  * Override the physical blocksize if the instance already
23501                  * has a larger value.
23502                  */
23503                 pbsize = MAX(pbsize, un->un_phy_blocksize);
23504         }
23505 
23506         if (dki_pbsize == NULL || rval != 0 ||
23507             !un->un_f_descr_format_supported) {
23508                 rval = sd_send_scsi_READ_CAPACITY(ssc, &capacity, &lbasize,
23509                     SD_PATH_DIRECT);
23510 
23511                 switch (rval) {
23512                 case 0:
23513                         if (un->un_f_enable_rmw &&
23514                             un->un_phy_blocksize != 0) {
23515                                 pbsize = un->un_phy_blocksize;
23516                         } else {
23517                                 pbsize = lbasize;
23518                         }
23519                         media_capacity = capacity;
23520 
23521                         /*
23522                          * sd_send_scsi_READ_CAPACITY() reports capacity in
23523                          * un->un_sys_blocksize chunks. So we need to convert
23524                          * it into cap.lbsize chunks.
23525                          */
23526                         if (un->un_f_has_removable_media) {
23527                                 media_capacity *= un->un_sys_blocksize;
23528                                 media_capacity /= lbasize;
23529                         }
23530                         break;
23531                 case EACCES:
23532                         rval = EACCES;
23533                         goto done;
23534                 default:
23535                         rval = EIO;
23536                         goto done;
23537                 }
23538         } else {
23539                 if (un->un_f_enable_rmw &&
23540                     !ISP2(pbsize % DEV_BSIZE)) {
23541                         pbsize = SSD_SECSIZE;
23542                 } else if (!ISP2(lbasize % DEV_BSIZE) ||
23543                     !ISP2(pbsize % DEV_BSIZE)) {
23544                         pbsize = lbasize = DEV_BSIZE;
23545                 }
23546                 media_capacity = capacity;
23547         }
23548 
23549         /*
23550          * If lun is expanded dynamically, update the un structure.
23551          */
23552         mutex_enter(SD_MUTEX(un));
23553         if ((un->un_f_blockcount_is_valid == TRUE) &&
23554             (un->un_f_tgt_blocksize_is_valid == TRUE) &&
23555             (capacity > un->un_blockcount)) {
23556                 un->un_f_expnevent = B_FALSE;
23557                 sd_update_block_info(un, lbasize, capacity);
23558         }
23559         mutex_exit(SD_MUTEX(un));
23560 
23561         *dki_lbsize = lbasize;
23562         *dki_capacity = media_capacity;
23563         if (dki_pbsize)
23564                 *dki_pbsize = pbsize;
23565 
23566 done:
23567         if (rval != 0) {
23568                 if (rval == EIO)
23569                         sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
23570                 else
23571                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23572         }
23573 no_assessment:
23574         sd_ssc_fini(ssc);
23575         kmem_free(out_data, SD_PROFILE_HEADER_LEN);
23576         kmem_free(rqbuf, SENSE_LENGTH);
23577         return (rval);
23578 }
23579 
23580 /*
23581  *    Function: sd_get_media_info
23582  *
23583  * Description: This routine is the driver entry point for handling ioctl
23584  *              requests for the media type or command set profile used by the
23585  *              drive to operate on the media (DKIOCGMEDIAINFO).
23586  *
23587  *   Arguments: dev     - the device number
23588  *              arg     - pointer to user provided dk_minfo structure
23589  *                        specifying the media type, logical block size and
23590  *                        drive capacity.
23591  *              flag    - this argument is a pass through to ddi_copyxxx()
23592  *                        directly from the mode argument of ioctl().
23593  *
23594  * Return Code: returns the value from sd_get_media_info_com
23595  */
23596 static int
23597 sd_get_media_info(dev_t dev, caddr_t arg, int flag)
23598 {
23599         struct dk_minfo         mi;
23600         int                     rval;
23601 
23602         rval = sd_get_media_info_com(dev, &mi.dki_media_type,
23603             &mi.dki_lbsize, &mi.dki_capacity, NULL);
23604 
23605         if (rval)
23606                 return (rval);
23607         if (ddi_copyout(&mi, arg, sizeof (struct dk_minfo), flag))
23608                 rval = EFAULT;
23609         return (rval);
23610 }
23611 
23612 /*
23613  *    Function: sd_get_media_info_ext
23614  *
23615  * Description: This routine is the driver entry point for handling ioctl
23616  *              requests for the media type or command set profile used by the
23617  *              drive to operate on the media (DKIOCGMEDIAINFOEXT). The
23618  *              difference this ioctl and DKIOCGMEDIAINFO is the return value
23619  *              of this ioctl contains both logical block size and physical
23620  *              block size.
23621  *
23622  *
23623  *   Arguments: dev     - the device number
23624  *              arg     - pointer to user provided dk_minfo_ext structure
23625  *                        specifying the media type, logical block size,
23626  *                        physical block size and disk capacity.
23627  *              flag    - this argument is a pass through to ddi_copyxxx()
23628  *                        directly from the mode argument of ioctl().
23629  *
23630  * Return Code: returns the value from sd_get_media_info_com
23631  */
23632 static int
23633 sd_get_media_info_ext(dev_t dev, caddr_t arg, int flag)
23634 {
23635         struct dk_minfo_ext     mie;
23636         int                     rval = 0;
23637 
23638         rval = sd_get_media_info_com(dev, &mie.dki_media_type,
23639             &mie.dki_lbsize, &mie.dki_capacity, &mie.dki_pbsize);
23640 
23641         if (rval)
23642                 return (rval);
23643         if (ddi_copyout(&mie, arg, sizeof (struct dk_minfo_ext), flag))
23644                 rval = EFAULT;
23645         return (rval);
23646 
23647 }
23648 
23649 /*
23650  *    Function: sd_watch_request_submit
23651  *
23652  * Description: Call scsi_watch_request_submit or scsi_mmc_watch_request_submit
23653  *              depending on which is supported by device.
23654  */
23655 static opaque_t
23656 sd_watch_request_submit(struct sd_lun *un)
23657 {
23658         dev_t                   dev;
23659 
23660         /* All submissions are unified to use same device number */
23661         dev = sd_make_device(SD_DEVINFO(un));
23662 
23663         if (un->un_f_mmc_cap && un->un_f_mmc_gesn_polling) {
23664                 return (scsi_mmc_watch_request_submit(SD_SCSI_DEVP(un),
23665                     sd_check_media_time, SENSE_LENGTH, sd_media_watch_cb,
23666                     (caddr_t)dev));
23667         } else {
23668                 return (scsi_watch_request_submit(SD_SCSI_DEVP(un),
23669                     sd_check_media_time, SENSE_LENGTH, sd_media_watch_cb,
23670                     (caddr_t)dev));
23671         }
23672 }
23673 
23674 
23675 /*
23676  *    Function: sd_check_media
23677  *
23678  * Description: This utility routine implements the functionality for the
23679  *              DKIOCSTATE ioctl. This ioctl blocks the user thread until the
23680  *              driver state changes from that specified by the user
23681  *              (inserted or ejected). For example, if the user specifies
23682  *              DKIO_EJECTED and the current media state is inserted this
23683  *              routine will immediately return DKIO_INSERTED. However, if the
23684  *              current media state is not inserted the user thread will be
23685  *              blocked until the drive state changes. If DKIO_NONE is specified
23686  *              the user thread will block until a drive state change occurs.
23687  *
23688  *   Arguments: dev  - the device number
23689  *              state  - user pointer to a dkio_state, updated with the current
23690  *                      drive state at return.
23691  *
23692  * Return Code: ENXIO
23693  *              EIO
23694  *              EAGAIN
23695  *              EINTR
23696  */
23697 
23698 static int
23699 sd_check_media(dev_t dev, enum dkio_state state)
23700 {
23701         struct sd_lun           *un = NULL;
23702         enum dkio_state         prev_state;
23703         opaque_t                token = NULL;
23704         int                     rval = 0;
23705         sd_ssc_t                *ssc;
23706 
23707         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
23708                 return (ENXIO);
23709         }
23710 
23711         SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: entry\n");
23712 
23713         ssc = sd_ssc_init(un);
23714 
23715         mutex_enter(SD_MUTEX(un));
23716 
23717         SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: "
23718             "state=%x, mediastate=%x\n", state, un->un_mediastate);
23719 
23720         prev_state = un->un_mediastate;
23721 
23722         /* is there anything to do? */
23723         if (state == un->un_mediastate || un->un_mediastate == DKIO_NONE) {
23724                 /*
23725                  * submit the request to the scsi_watch service;
23726                  * scsi_media_watch_cb() does the real work
23727                  */
23728                 mutex_exit(SD_MUTEX(un));
23729 
23730                 /*
23731                  * This change handles the case where a scsi watch request is
23732                  * added to a device that is powered down. To accomplish this
23733                  * we power up the device before adding the scsi watch request,
23734                  * since the scsi watch sends a TUR directly to the device
23735                  * which the device cannot handle if it is powered down.
23736                  */
23737                 if (sd_pm_entry(un) != DDI_SUCCESS) {
23738                         mutex_enter(SD_MUTEX(un));
23739                         goto done;
23740                 }
23741 
23742                 token = sd_watch_request_submit(un);
23743 
23744                 sd_pm_exit(un);
23745 
23746                 mutex_enter(SD_MUTEX(un));
23747                 if (token == NULL) {
23748                         rval = EAGAIN;
23749                         goto done;
23750                 }
23751 
23752                 /*
23753                  * This is a special case IOCTL that doesn't return
23754                  * until the media state changes. Routine sdpower
23755                  * knows about and handles this so don't count it
23756                  * as an active cmd in the driver, which would
23757                  * keep the device busy to the pm framework.
23758                  * If the count isn't decremented the device can't
23759                  * be powered down.
23760                  */
23761                 un->un_ncmds_in_driver--;
23762                 ASSERT(un->un_ncmds_in_driver >= 0);
23763 
23764                 /*
23765                  * if a prior request had been made, this will be the same
23766                  * token, as scsi_watch was designed that way.
23767                  */
23768                 un->un_swr_token = token;
23769                 un->un_specified_mediastate = state;
23770 
23771                 /*
23772                  * now wait for media change
23773                  * we will not be signalled unless mediastate == state but it is
23774                  * still better to test for this condition, since there is a
23775                  * 2 sec cv_broadcast delay when mediastate == DKIO_INSERTED
23776                  */
23777                 SD_TRACE(SD_LOG_COMMON, un,
23778                     "sd_check_media: waiting for media state change\n");
23779                 while (un->un_mediastate == state) {
23780                         if (cv_wait_sig(&un->un_state_cv, SD_MUTEX(un)) == 0) {
23781                                 SD_TRACE(SD_LOG_COMMON, un,
23782                                     "sd_check_media: waiting for media state "
23783                                     "was interrupted\n");
23784                                 un->un_ncmds_in_driver++;
23785                                 rval = EINTR;
23786                                 goto done;
23787                         }
23788                         SD_TRACE(SD_LOG_COMMON, un,
23789                             "sd_check_media: received signal, state=%x\n",
23790                             un->un_mediastate);
23791                 }
23792                 /*
23793                  * Inc the counter to indicate the device once again
23794                  * has an active outstanding cmd.
23795                  */
23796                 un->un_ncmds_in_driver++;
23797         }
23798 
23799         /* invalidate geometry */
23800         if (prev_state == DKIO_INSERTED && un->un_mediastate == DKIO_EJECTED) {
23801                 sr_ejected(un);
23802         }
23803 
23804         if (un->un_mediastate == DKIO_INSERTED && prev_state != DKIO_INSERTED) {
23805                 uint64_t        capacity;
23806                 uint_t          lbasize;
23807 
23808                 SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: media inserted\n");
23809                 mutex_exit(SD_MUTEX(un));
23810                 /*
23811                  * Since the following routines use SD_PATH_DIRECT, we must
23812                  * call PM directly before the upcoming disk accesses. This
23813                  * may cause the disk to be power/spin up.
23814                  */
23815 
23816                 if (sd_pm_entry(un) == DDI_SUCCESS) {
23817                         rval = sd_send_scsi_READ_CAPACITY(ssc,
23818                             &capacity, &lbasize, SD_PATH_DIRECT);
23819                         if (rval != 0) {
23820                                 sd_pm_exit(un);
23821                                 if (rval == EIO)
23822                                         sd_ssc_assessment(ssc,
23823                                             SD_FMT_STATUS_CHECK);
23824                                 else
23825                                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23826                                 mutex_enter(SD_MUTEX(un));
23827                                 goto done;
23828                         }
23829                 } else {
23830                         rval = EIO;
23831                         mutex_enter(SD_MUTEX(un));
23832                         goto done;
23833                 }
23834                 mutex_enter(SD_MUTEX(un));
23835 
23836                 sd_update_block_info(un, lbasize, capacity);
23837 
23838                 /*
23839                  *  Check if the media in the device is writable or not
23840                  */
23841                 if (ISCD(un)) {
23842                         sd_check_for_writable_cd(ssc, SD_PATH_DIRECT);
23843                 }
23844 
23845                 mutex_exit(SD_MUTEX(un));
23846                 cmlb_invalidate(un->un_cmlbhandle, (void *)SD_PATH_DIRECT);
23847                 if ((cmlb_validate(un->un_cmlbhandle, 0,
23848                     (void *)SD_PATH_DIRECT) == 0) && un->un_f_pkstats_enabled) {
23849                         sd_set_pstats(un);
23850                         SD_TRACE(SD_LOG_IO_PARTITION, un,
23851                             "sd_check_media: un:0x%p pstats created and "
23852                             "set\n", un);
23853                 }
23854 
23855                 rval = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_PREVENT,
23856                     SD_PATH_DIRECT);
23857 
23858                 sd_pm_exit(un);
23859 
23860                 if (rval != 0) {
23861                         if (rval == EIO)
23862                                 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
23863                         else
23864                                 sd_ssc_assessment(ssc, SD_FMT_IGNORE);
23865                 }
23866 
23867                 mutex_enter(SD_MUTEX(un));
23868         }
23869 done:
23870         sd_ssc_fini(ssc);
23871         un->un_f_watcht_stopped = FALSE;
23872         if (token != NULL && un->un_swr_token != NULL) {
23873                 /*
23874                  * Use of this local token and the mutex ensures that we avoid
23875                  * some race conditions associated with terminating the
23876                  * scsi watch.
23877                  */
23878                 token = un->un_swr_token;
23879                 mutex_exit(SD_MUTEX(un));
23880                 (void) scsi_watch_request_terminate(token,
23881                     SCSI_WATCH_TERMINATE_WAIT);
23882                 if (scsi_watch_get_ref_count(token) == 0) {
23883                         mutex_enter(SD_MUTEX(un));
23884                         un->un_swr_token = (opaque_t)NULL;
23885                 } else {
23886                         mutex_enter(SD_MUTEX(un));
23887                 }
23888         }
23889 
23890         /*
23891          * Update the capacity kstat value, if no media previously
23892          * (capacity kstat is 0) and a media has been inserted
23893          * (un_f_blockcount_is_valid == TRUE)
23894          */
23895         if (un->un_errstats) {
23896                 struct sd_errstats      *stp = NULL;
23897 
23898                 stp = (struct sd_errstats *)un->un_errstats->ks_data;
23899                 if ((stp->sd_capacity.value.ui64 == 0) &&
23900                     (un->un_f_blockcount_is_valid == TRUE)) {
23901                         stp->sd_capacity.value.ui64 =
23902                             (uint64_t)((uint64_t)un->un_blockcount *
23903                             un->un_sys_blocksize);
23904                 }
23905         }
23906         mutex_exit(SD_MUTEX(un));
23907         SD_TRACE(SD_LOG_COMMON, un, "sd_check_media: done\n");
23908         return (rval);
23909 }
23910 
23911 
23912 /*
23913  *    Function: sd_delayed_cv_broadcast
23914  *
23915  * Description: Delayed cv_broadcast to allow for target to recover from media
23916  *              insertion.
23917  *
23918  *   Arguments: arg - driver soft state (unit) structure
23919  */
23920 
23921 static void
23922 sd_delayed_cv_broadcast(void *arg)
23923 {
23924         struct sd_lun *un = arg;
23925 
23926         SD_TRACE(SD_LOG_COMMON, un, "sd_delayed_cv_broadcast\n");
23927 
23928         mutex_enter(SD_MUTEX(un));
23929         un->un_dcvb_timeid = NULL;
23930         cv_broadcast(&un->un_state_cv);
23931         mutex_exit(SD_MUTEX(un));
23932 }
23933 
23934 
23935 /*
23936  *    Function: sd_media_watch_cb
23937  *
23938  * Description: Callback routine used for support of the DKIOCSTATE ioctl. This
23939  *              routine processes the TUR sense data and updates the driver
23940  *              state if a transition has occurred. The user thread
23941  *              (sd_check_media) is then signalled.
23942  *
23943  *   Arguments: arg -   the device 'dev_t' is used for context to discriminate
23944  *                      among multiple watches that share this callback function
23945  *              resultp - scsi watch facility result packet containing scsi
23946  *                        packet, status byte and sense data
23947  *
23948  * Return Code: 0 for success, -1 for failure
23949  */
23950 
23951 static int
23952 sd_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp)
23953 {
23954         struct sd_lun                   *un;
23955         struct scsi_status              *statusp = resultp->statusp;
23956         uint8_t                         *sensep = (uint8_t *)resultp->sensep;
23957         enum dkio_state                 state = DKIO_NONE;
23958         dev_t                           dev = (dev_t)arg;
23959         uchar_t                         actual_sense_length;
23960         uint8_t                         skey, asc, ascq;
23961 
23962         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
23963                 return (-1);
23964         }
23965         actual_sense_length = resultp->actual_sense_length;
23966 
23967         mutex_enter(SD_MUTEX(un));
23968         SD_TRACE(SD_LOG_COMMON, un,
23969             "sd_media_watch_cb: status=%x, sensep=%p, len=%x\n",
23970             *((char *)statusp), (void *)sensep, actual_sense_length);
23971 
23972         if (resultp->pkt->pkt_reason == CMD_DEV_GONE) {
23973                 un->un_mediastate = DKIO_DEV_GONE;
23974                 cv_broadcast(&un->un_state_cv);
23975                 mutex_exit(SD_MUTEX(un));
23976 
23977                 return (0);
23978         }
23979 
23980         if (un->un_f_mmc_cap && un->un_f_mmc_gesn_polling) {
23981                 if (sd_gesn_media_data_valid(resultp->mmc_data)) {
23982                         if ((resultp->mmc_data[5] &
23983                             SD_GESN_MEDIA_EVENT_STATUS_PRESENT) != 0) {
23984                                 state = DKIO_INSERTED;
23985                         } else {
23986                                 state = DKIO_EJECTED;
23987                         }
23988                         if ((resultp->mmc_data[4] & SD_GESN_MEDIA_EVENT_CODE) ==
23989                             SD_GESN_MEDIA_EVENT_EJECTREQUEST) {
23990                                 sd_log_eject_request_event(un, KM_NOSLEEP);
23991                         }
23992                 }
23993         } else if (sensep != NULL) {
23994                 /*
23995                  * If there was a check condition then sensep points to valid
23996                  * sense data. If status was not a check condition but a
23997                  * reservation or busy status then the new state is DKIO_NONE.
23998                  */
23999                 skey = scsi_sense_key(sensep);
24000                 asc = scsi_sense_asc(sensep);
24001                 ascq = scsi_sense_ascq(sensep);
24002 
24003                 SD_INFO(SD_LOG_COMMON, un,
24004                     "sd_media_watch_cb: sense KEY=%x, ASC=%x, ASCQ=%x\n",
24005                     skey, asc, ascq);
24006                 /* This routine only uses up to 13 bytes of sense data. */
24007                 if (actual_sense_length >= 13) {
24008                         if (skey == KEY_UNIT_ATTENTION) {
24009                                 if (asc == 0x28) {
24010                                         state = DKIO_INSERTED;
24011                                 }
24012                         } else if (skey == KEY_NOT_READY) {
24013                                 /*
24014                                  * Sense data of 02/06/00 means that the
24015                                  * drive could not read the media (No
24016                                  * reference position found). In this case
24017                                  * to prevent a hang on the DKIOCSTATE IOCTL
24018                                  * we set the media state to DKIO_INSERTED.
24019                                  */
24020                                 if (asc == 0x06 && ascq == 0x00)
24021                                         state = DKIO_INSERTED;
24022 
24023                                 /*
24024                                  * if 02/04/02  means that the host
24025                                  * should send start command. Explicitly
24026                                  * leave the media state as is
24027                                  * (inserted) as the media is inserted
24028                                  * and host has stopped device for PM
24029                                  * reasons. Upon next true read/write
24030                                  * to this media will bring the
24031                                  * device to the right state good for
24032                                  * media access.
24033                                  */
24034                                 if (asc == 0x3a) {
24035                                         state = DKIO_EJECTED;
24036                                 } else {
24037                                         /*
24038                                          * If the drive is busy with an
24039                                          * operation or long write, keep the
24040                                          * media in an inserted state.
24041                                          */
24042 
24043                                         if ((asc == 0x04) &&
24044                                             ((ascq == 0x02) ||
24045                                             (ascq == 0x07) ||
24046                                             (ascq == 0x08))) {
24047                                                 state = DKIO_INSERTED;
24048                                         }
24049                                 }
24050                         } else if (skey == KEY_NO_SENSE) {
24051                                 if ((asc == 0x00) && (ascq == 0x00)) {
24052                                         /*
24053                                          * Sense Data 00/00/00 does not provide
24054                                          * any information about the state of
24055                                          * the media. Ignore it.
24056                                          */
24057                                         mutex_exit(SD_MUTEX(un));
24058                                         return (0);
24059                                 }
24060                         }
24061                 }
24062         } else if ((*((char *)statusp) == STATUS_GOOD) &&
24063             (resultp->pkt->pkt_reason == CMD_CMPLT)) {
24064                 state = DKIO_INSERTED;
24065         }
24066 
24067         SD_TRACE(SD_LOG_COMMON, un,
24068             "sd_media_watch_cb: state=%x, specified=%x\n",
24069             state, un->un_specified_mediastate);
24070 
24071         /*
24072          * now signal the waiting thread if this is *not* the specified state;
24073          * delay the signal if the state is DKIO_INSERTED to allow the target
24074          * to recover
24075          */
24076         if (state != un->un_specified_mediastate) {
24077                 un->un_mediastate = state;
24078                 if (state == DKIO_INSERTED) {
24079                         /*
24080                          * delay the signal to give the drive a chance
24081                          * to do what it apparently needs to do
24082                          */
24083                         SD_TRACE(SD_LOG_COMMON, un,
24084                             "sd_media_watch_cb: delayed cv_broadcast\n");
24085                         if (un->un_dcvb_timeid == NULL) {
24086                                 un->un_dcvb_timeid =
24087                                     timeout(sd_delayed_cv_broadcast, un,
24088                                     drv_usectohz((clock_t)MEDIA_ACCESS_DELAY));
24089                         }
24090                 } else {
24091                         SD_TRACE(SD_LOG_COMMON, un,
24092                             "sd_media_watch_cb: immediate cv_broadcast\n");
24093                         cv_broadcast(&un->un_state_cv);
24094                 }
24095         }
24096         mutex_exit(SD_MUTEX(un));
24097         return (0);
24098 }
24099 
24100 
24101 /*
24102  *    Function: sd_dkio_get_temp
24103  *
24104  * Description: This routine is the driver entry point for handling ioctl
24105  *              requests to get the disk temperature.
24106  *
24107  *   Arguments: dev  - the device number
24108  *              arg  - pointer to user provided dk_temperature structure.
24109  *              flag - this argument is a pass through to ddi_copyxxx()
24110  *                     directly from the mode argument of ioctl().
24111  *
24112  * Return Code: 0
24113  *              EFAULT
24114  *              ENXIO
24115  *              EAGAIN
24116  */
24117 
24118 static int
24119 sd_dkio_get_temp(dev_t dev, caddr_t arg, int flag)
24120 {
24121         struct sd_lun           *un = NULL;
24122         struct dk_temperature   *dktemp = NULL;
24123         uchar_t                 *temperature_page;
24124         int                     rval = 0;
24125         int                     path_flag = SD_PATH_STANDARD;
24126         sd_ssc_t                *ssc;
24127 
24128         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24129                 return (ENXIO);
24130         }
24131 
24132         ssc = sd_ssc_init(un);
24133         dktemp = kmem_zalloc(sizeof (struct dk_temperature), KM_SLEEP);
24134 
24135         /* copyin the disk temp argument to get the user flags */
24136         if (ddi_copyin((void *)arg, dktemp,
24137             sizeof (struct dk_temperature), flag) != 0) {
24138                 rval = EFAULT;
24139                 goto done;
24140         }
24141 
24142         /* Initialize the temperature to invalid. */
24143         dktemp->dkt_cur_temp = (short)DKT_INVALID_TEMP;
24144         dktemp->dkt_ref_temp = (short)DKT_INVALID_TEMP;
24145 
24146         /*
24147          * Note: Investigate removing the "bypass pm" semantic.
24148          * Can we just bypass PM always?
24149          */
24150         if (dktemp->dkt_flags & DKT_BYPASS_PM) {
24151                 path_flag = SD_PATH_DIRECT;
24152                 ASSERT(!mutex_owned(&un->un_pm_mutex));
24153                 mutex_enter(&un->un_pm_mutex);
24154                 if (SD_DEVICE_IS_IN_LOW_POWER(un)) {
24155                         /*
24156                          * If DKT_BYPASS_PM is set, and the drive happens to be
24157                          * in low power mode, we can not wake it up, Need to
24158                          * return EAGAIN.
24159                          */
24160                         mutex_exit(&un->un_pm_mutex);
24161                         rval = EAGAIN;
24162                         goto done;
24163                 } else {
24164                         /*
24165                          * Indicate to PM the device is busy. This is required
24166                          * to avoid a race - i.e. the ioctl is issuing a
24167                          * command and the pm framework brings down the device
24168                          * to low power mode (possible power cut-off on some
24169                          * platforms).
24170                          */
24171                         mutex_exit(&un->un_pm_mutex);
24172                         if (sd_pm_entry(un) != DDI_SUCCESS) {
24173                                 rval = EAGAIN;
24174                                 goto done;
24175                         }
24176                 }
24177         }
24178 
24179         temperature_page = kmem_zalloc(TEMPERATURE_PAGE_SIZE, KM_SLEEP);
24180 
24181         rval = sd_send_scsi_LOG_SENSE(ssc, temperature_page,
24182             TEMPERATURE_PAGE_SIZE, TEMPERATURE_PAGE, 1, 0, path_flag);
24183         if (rval != 0)
24184                 goto done2;
24185 
24186         /*
24187          * For the current temperature verify that the parameter length is 0x02
24188          * and the parameter code is 0x00
24189          */
24190         if ((temperature_page[7] == 0x02) && (temperature_page[4] == 0x00) &&
24191             (temperature_page[5] == 0x00)) {
24192                 if (temperature_page[9] == 0xFF) {
24193                         dktemp->dkt_cur_temp = (short)DKT_INVALID_TEMP;
24194                 } else {
24195                         dktemp->dkt_cur_temp = (short)(temperature_page[9]);
24196                 }
24197         }
24198 
24199         /*
24200          * For the reference temperature verify that the parameter
24201          * length is 0x02 and the parameter code is 0x01
24202          */
24203         if ((temperature_page[13] == 0x02) && (temperature_page[10] == 0x00) &&
24204             (temperature_page[11] == 0x01)) {
24205                 if (temperature_page[15] == 0xFF) {
24206                         dktemp->dkt_ref_temp = (short)DKT_INVALID_TEMP;
24207                 } else {
24208                         dktemp->dkt_ref_temp = (short)(temperature_page[15]);
24209                 }
24210         }
24211 
24212         /* Do the copyout regardless of the temperature commands status. */
24213         if (ddi_copyout(dktemp, (void *)arg, sizeof (struct dk_temperature),
24214             flag) != 0) {
24215                 rval = EFAULT;
24216                 goto done1;
24217         }
24218 
24219 done2:
24220         if (rval != 0) {
24221                 if (rval == EIO)
24222                         sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
24223                 else
24224                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
24225         }
24226 done1:
24227         if (path_flag == SD_PATH_DIRECT) {
24228                 sd_pm_exit(un);
24229         }
24230 
24231         kmem_free(temperature_page, TEMPERATURE_PAGE_SIZE);
24232 done:
24233         sd_ssc_fini(ssc);
24234         if (dktemp != NULL) {
24235                 kmem_free(dktemp, sizeof (struct dk_temperature));
24236         }
24237 
24238         return (rval);
24239 }
24240 
24241 
24242 /*
24243  *    Function: sd_log_page_supported
24244  *
24245  * Description: This routine uses sd_send_scsi_LOG_SENSE to find the list of
24246  *              supported log pages.
24247  *
24248  *   Arguments: ssc   - ssc contains pointer to driver soft state (unit)
24249  *                      structure for this target.
24250  *              log_page -
24251  *
24252  * Return Code: -1 - on error (log sense is optional and may not be supported).
24253  *              0  - log page not found.
24254  *              1  - log page found.
24255  */
24256 
24257 static int
24258 sd_log_page_supported(sd_ssc_t *ssc, int log_page)
24259 {
24260         uchar_t *log_page_data;
24261         int     i;
24262         int     match = 0;
24263         int     log_size;
24264         int     status = 0;
24265         struct sd_lun   *un;
24266 
24267         ASSERT(ssc != NULL);
24268         un = ssc->ssc_un;
24269         ASSERT(un != NULL);
24270 
24271         log_page_data = kmem_zalloc(0xFF, KM_SLEEP);
24272 
24273         status = sd_send_scsi_LOG_SENSE(ssc, log_page_data, 0xFF, 0, 0x01, 0,
24274             SD_PATH_DIRECT);
24275 
24276         if (status != 0) {
24277                 if (status == EIO) {
24278                         /*
24279                          * Some disks do not support log sense, we
24280                          * should ignore this kind of error(sense key is
24281                          * 0x5 - illegal request).
24282                          */
24283                         uint8_t *sensep;
24284                         int senlen;
24285 
24286                         sensep = (uint8_t *)ssc->ssc_uscsi_cmd->uscsi_rqbuf;
24287                         senlen = (int)(ssc->ssc_uscsi_cmd->uscsi_rqlen -
24288                             ssc->ssc_uscsi_cmd->uscsi_rqresid);
24289 
24290                         if (senlen > 0 &&
24291                             scsi_sense_key(sensep) == KEY_ILLEGAL_REQUEST) {
24292                                 sd_ssc_assessment(ssc,
24293                                     SD_FMT_IGNORE_COMPROMISE);
24294                         } else {
24295                                 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
24296                         }
24297                 } else {
24298                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
24299                 }
24300 
24301                 SD_ERROR(SD_LOG_COMMON, un,
24302                     "sd_log_page_supported: failed log page retrieval\n");
24303                 kmem_free(log_page_data, 0xFF);
24304                 return (-1);
24305         }
24306 
24307         log_size = log_page_data[3];
24308 
24309         /*
24310          * The list of supported log pages start from the fourth byte. Check
24311          * until we run out of log pages or a match is found.
24312          */
24313         for (i = 4; (i < (log_size + 4)) && !match; i++) {
24314                 if (log_page_data[i] == log_page) {
24315                         match++;
24316                 }
24317         }
24318         kmem_free(log_page_data, 0xFF);
24319         return (match);
24320 }
24321 
24322 
24323 /*
24324  *    Function: sd_mhdioc_failfast
24325  *
24326  * Description: This routine is the driver entry point for handling ioctl
24327  *              requests to enable/disable the multihost failfast option.
24328  *              (MHIOCENFAILFAST)
24329  *
24330  *   Arguments: dev     - the device number
24331  *              arg     - user specified probing interval.
24332  *              flag    - this argument is a pass through to ddi_copyxxx()
24333  *                        directly from the mode argument of ioctl().
24334  *
24335  * Return Code: 0
24336  *              EFAULT
24337  *              ENXIO
24338  */
24339 
24340 static int
24341 sd_mhdioc_failfast(dev_t dev, caddr_t arg, int flag)
24342 {
24343         struct sd_lun   *un = NULL;
24344         int             mh_time;
24345         int             rval = 0;
24346 
24347         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24348                 return (ENXIO);
24349         }
24350 
24351         if (ddi_copyin((void *)arg, &mh_time, sizeof (int), flag))
24352                 return (EFAULT);
24353 
24354         if (mh_time) {
24355                 mutex_enter(SD_MUTEX(un));
24356                 un->un_resvd_status |= SD_FAILFAST;
24357                 mutex_exit(SD_MUTEX(un));
24358                 /*
24359                  * If mh_time is INT_MAX, then this ioctl is being used for
24360                  * SCSI-3 PGR purposes, and we don't need to spawn watch thread.
24361                  */
24362                 if (mh_time != INT_MAX) {
24363                         rval = sd_check_mhd(dev, mh_time);
24364                 }
24365         } else {
24366                 (void) sd_check_mhd(dev, 0);
24367                 mutex_enter(SD_MUTEX(un));
24368                 un->un_resvd_status &= ~SD_FAILFAST;
24369                 mutex_exit(SD_MUTEX(un));
24370         }
24371         return (rval);
24372 }
24373 
24374 
24375 /*
24376  *    Function: sd_mhdioc_takeown
24377  *
24378  * Description: This routine is the driver entry point for handling ioctl
24379  *              requests to forcefully acquire exclusive access rights to the
24380  *              multihost disk (MHIOCTKOWN).
24381  *
24382  *   Arguments: dev     - the device number
24383  *              arg     - user provided structure specifying the delay
24384  *                        parameters in milliseconds
24385  *              flag    - this argument is a pass through to ddi_copyxxx()
24386  *                        directly from the mode argument of ioctl().
24387  *
24388  * Return Code: 0
24389  *              EFAULT
24390  *              ENXIO
24391  */
24392 
24393 static int
24394 sd_mhdioc_takeown(dev_t dev, caddr_t arg, int flag)
24395 {
24396         struct sd_lun           *un = NULL;
24397         struct mhioctkown       *tkown = NULL;
24398         int                     rval = 0;
24399 
24400         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24401                 return (ENXIO);
24402         }
24403 
24404         if (arg != NULL) {
24405                 tkown = (struct mhioctkown *)
24406                     kmem_zalloc(sizeof (struct mhioctkown), KM_SLEEP);
24407                 rval = ddi_copyin(arg, tkown, sizeof (struct mhioctkown), flag);
24408                 if (rval != 0) {
24409                         rval = EFAULT;
24410                         goto error;
24411                 }
24412         }
24413 
24414         rval = sd_take_ownership(dev, tkown);
24415         mutex_enter(SD_MUTEX(un));
24416         if (rval == 0) {
24417                 un->un_resvd_status |= SD_RESERVE;
24418                 if (tkown != NULL && tkown->reinstate_resv_delay != 0) {
24419                         sd_reinstate_resv_delay =
24420                             tkown->reinstate_resv_delay * 1000;
24421                 } else {
24422                         sd_reinstate_resv_delay = SD_REINSTATE_RESV_DELAY;
24423                 }
24424                 /*
24425                  * Give the scsi_watch routine interval set by
24426                  * the MHIOCENFAILFAST ioctl precedence here.
24427                  */
24428                 if ((un->un_resvd_status & SD_FAILFAST) == 0) {
24429                         mutex_exit(SD_MUTEX(un));
24430                         (void) sd_check_mhd(dev, sd_reinstate_resv_delay/1000);
24431                         SD_TRACE(SD_LOG_IOCTL_MHD, un,
24432                             "sd_mhdioc_takeown : %d\n",
24433                             sd_reinstate_resv_delay);
24434                 } else {
24435                         mutex_exit(SD_MUTEX(un));
24436                 }
24437                 (void) scsi_reset_notify(SD_ADDRESS(un), SCSI_RESET_NOTIFY,
24438                     sd_mhd_reset_notify_cb, (caddr_t)un);
24439         } else {
24440                 un->un_resvd_status &= ~SD_RESERVE;
24441                 mutex_exit(SD_MUTEX(un));
24442         }
24443 
24444 error:
24445         if (tkown != NULL) {
24446                 kmem_free(tkown, sizeof (struct mhioctkown));
24447         }
24448         return (rval);
24449 }
24450 
24451 
24452 /*
24453  *    Function: sd_mhdioc_release
24454  *
24455  * Description: This routine is the driver entry point for handling ioctl
24456  *              requests to release exclusive access rights to the multihost
24457  *              disk (MHIOCRELEASE).
24458  *
24459  *   Arguments: dev     - the device number
24460  *
24461  * Return Code: 0
24462  *              ENXIO
24463  */
24464 
24465 static int
24466 sd_mhdioc_release(dev_t dev)
24467 {
24468         struct sd_lun           *un = NULL;
24469         timeout_id_t            resvd_timeid_save;
24470         int                     resvd_status_save;
24471         int                     rval = 0;
24472 
24473         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24474                 return (ENXIO);
24475         }
24476 
24477         mutex_enter(SD_MUTEX(un));
24478         resvd_status_save = un->un_resvd_status;
24479         un->un_resvd_status &=
24480             ~(SD_RESERVE | SD_LOST_RESERVE | SD_WANT_RESERVE);
24481         if (un->un_resvd_timeid) {
24482                 resvd_timeid_save = un->un_resvd_timeid;
24483                 un->un_resvd_timeid = NULL;
24484                 mutex_exit(SD_MUTEX(un));
24485                 (void) untimeout(resvd_timeid_save);
24486         } else {
24487                 mutex_exit(SD_MUTEX(un));
24488         }
24489 
24490         /*
24491          * destroy any pending timeout thread that may be attempting to
24492          * reinstate reservation on this device.
24493          */
24494         sd_rmv_resv_reclaim_req(dev);
24495 
24496         if ((rval = sd_reserve_release(dev, SD_RELEASE)) == 0) {
24497                 mutex_enter(SD_MUTEX(un));
24498                 if ((un->un_mhd_token) &&
24499                     ((un->un_resvd_status & SD_FAILFAST) == 0)) {
24500                         mutex_exit(SD_MUTEX(un));
24501                         (void) sd_check_mhd(dev, 0);
24502                 } else {
24503                         mutex_exit(SD_MUTEX(un));
24504                 }
24505                 (void) scsi_reset_notify(SD_ADDRESS(un), SCSI_RESET_CANCEL,
24506                     sd_mhd_reset_notify_cb, (caddr_t)un);
24507         } else {
24508                 /*
24509                  * sd_mhd_watch_cb will restart the resvd recover timeout thread
24510                  */
24511                 mutex_enter(SD_MUTEX(un));
24512                 un->un_resvd_status = resvd_status_save;
24513                 mutex_exit(SD_MUTEX(un));
24514         }
24515         return (rval);
24516 }
24517 
24518 
24519 /*
24520  *    Function: sd_mhdioc_register_devid
24521  *
24522  * Description: This routine is the driver entry point for handling ioctl
24523  *              requests to register the device id (MHIOCREREGISTERDEVID).
24524  *
24525  *              Note: The implementation for this ioctl has been updated to
24526  *              be consistent with the original PSARC case (1999/357)
24527  *              (4375899, 4241671, 4220005)
24528  *
24529  *   Arguments: dev     - the device number
24530  *
24531  * Return Code: 0
24532  *              ENXIO
24533  */
24534 
24535 static int
24536 sd_mhdioc_register_devid(dev_t dev)
24537 {
24538         struct sd_lun   *un = NULL;
24539         int             rval = 0;
24540         sd_ssc_t        *ssc;
24541 
24542         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24543                 return (ENXIO);
24544         }
24545 
24546         ASSERT(!mutex_owned(SD_MUTEX(un)));
24547 
24548         mutex_enter(SD_MUTEX(un));
24549 
24550         /* If a devid already exists, de-register it */
24551         if (un->un_devid != NULL) {
24552                 ddi_devid_unregister(SD_DEVINFO(un));
24553                 /*
24554                  * After unregister devid, needs to free devid memory
24555                  */
24556                 ddi_devid_free(un->un_devid);
24557                 un->un_devid = NULL;
24558         }
24559 
24560         /* Check for reservation conflict */
24561         mutex_exit(SD_MUTEX(un));
24562         ssc = sd_ssc_init(un);
24563         rval = sd_send_scsi_TEST_UNIT_READY(ssc, 0);
24564         mutex_enter(SD_MUTEX(un));
24565 
24566         switch (rval) {
24567         case 0:
24568                 sd_register_devid(ssc, SD_DEVINFO(un), SD_TARGET_IS_UNRESERVED);
24569                 break;
24570         case EACCES:
24571                 break;
24572         default:
24573                 rval = EIO;
24574         }
24575 
24576         mutex_exit(SD_MUTEX(un));
24577         if (rval != 0) {
24578                 if (rval == EIO)
24579                         sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
24580                 else
24581                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
24582         }
24583         sd_ssc_fini(ssc);
24584         return (rval);
24585 }
24586 
24587 
24588 /*
24589  *    Function: sd_mhdioc_inkeys
24590  *
24591  * Description: This routine is the driver entry point for handling ioctl
24592  *              requests to issue the SCSI-3 Persistent In Read Keys command
24593  *              to the device (MHIOCGRP_INKEYS).
24594  *
24595  *   Arguments: dev     - the device number
24596  *              arg     - user provided in_keys structure
24597  *              flag    - this argument is a pass through to ddi_copyxxx()
24598  *                        directly from the mode argument of ioctl().
24599  *
24600  * Return Code: code returned by sd_persistent_reservation_in_read_keys()
24601  *              ENXIO
24602  *              EFAULT
24603  */
24604 
24605 static int
24606 sd_mhdioc_inkeys(dev_t dev, caddr_t arg, int flag)
24607 {
24608         struct sd_lun           *un;
24609         mhioc_inkeys_t          inkeys;
24610         int                     rval = 0;
24611 
24612         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24613                 return (ENXIO);
24614         }
24615 
24616 #ifdef _MULTI_DATAMODEL
24617         switch (ddi_model_convert_from(flag & FMODELS)) {
24618         case DDI_MODEL_ILP32: {
24619                 struct mhioc_inkeys32   inkeys32;
24620 
24621                 if (ddi_copyin(arg, &inkeys32,
24622                     sizeof (struct mhioc_inkeys32), flag) != 0) {
24623                         return (EFAULT);
24624                 }
24625                 inkeys.li = (mhioc_key_list_t *)(uintptr_t)inkeys32.li;
24626                 if ((rval = sd_persistent_reservation_in_read_keys(un,
24627                     &inkeys, flag)) != 0) {
24628                         return (rval);
24629                 }
24630                 inkeys32.generation = inkeys.generation;
24631                 if (ddi_copyout(&inkeys32, arg, sizeof (struct mhioc_inkeys32),
24632                     flag) != 0) {
24633                         return (EFAULT);
24634                 }
24635                 break;
24636         }
24637         case DDI_MODEL_NONE:
24638                 if (ddi_copyin(arg, &inkeys, sizeof (mhioc_inkeys_t),
24639                     flag) != 0) {
24640                         return (EFAULT);
24641                 }
24642                 if ((rval = sd_persistent_reservation_in_read_keys(un,
24643                     &inkeys, flag)) != 0) {
24644                         return (rval);
24645                 }
24646                 if (ddi_copyout(&inkeys, arg, sizeof (mhioc_inkeys_t),
24647                     flag) != 0) {
24648                         return (EFAULT);
24649                 }
24650                 break;
24651         }
24652 
24653 #else /* ! _MULTI_DATAMODEL */
24654 
24655         if (ddi_copyin(arg, &inkeys, sizeof (mhioc_inkeys_t), flag) != 0) {
24656                 return (EFAULT);
24657         }
24658         rval = sd_persistent_reservation_in_read_keys(un, &inkeys, flag);
24659         if (rval != 0) {
24660                 return (rval);
24661         }
24662         if (ddi_copyout(&inkeys, arg, sizeof (mhioc_inkeys_t), flag) != 0) {
24663                 return (EFAULT);
24664         }
24665 
24666 #endif /* _MULTI_DATAMODEL */
24667 
24668         return (rval);
24669 }
24670 
24671 
24672 /*
24673  *    Function: sd_mhdioc_inresv
24674  *
24675  * Description: This routine is the driver entry point for handling ioctl
24676  *              requests to issue the SCSI-3 Persistent In Read Reservations
24677  *              command to the device (MHIOCGRP_INKEYS).
24678  *
24679  *   Arguments: dev     - the device number
24680  *              arg     - user provided in_resv structure
24681  *              flag    - this argument is a pass through to ddi_copyxxx()
24682  *                        directly from the mode argument of ioctl().
24683  *
24684  * Return Code: code returned by sd_persistent_reservation_in_read_resv()
24685  *              ENXIO
24686  *              EFAULT
24687  */
24688 
24689 static int
24690 sd_mhdioc_inresv(dev_t dev, caddr_t arg, int flag)
24691 {
24692         struct sd_lun           *un;
24693         mhioc_inresvs_t         inresvs;
24694         int                     rval = 0;
24695 
24696         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24697                 return (ENXIO);
24698         }
24699 
24700 #ifdef _MULTI_DATAMODEL
24701 
24702         switch (ddi_model_convert_from(flag & FMODELS)) {
24703         case DDI_MODEL_ILP32: {
24704                 struct mhioc_inresvs32  inresvs32;
24705 
24706                 if (ddi_copyin(arg, &inresvs32,
24707                     sizeof (struct mhioc_inresvs32), flag) != 0) {
24708                         return (EFAULT);
24709                 }
24710                 inresvs.li = (mhioc_resv_desc_list_t *)(uintptr_t)inresvs32.li;
24711                 if ((rval = sd_persistent_reservation_in_read_resv(un,
24712                     &inresvs, flag)) != 0) {
24713                         return (rval);
24714                 }
24715                 inresvs32.generation = inresvs.generation;
24716                 if (ddi_copyout(&inresvs32, arg,
24717                     sizeof (struct mhioc_inresvs32), flag) != 0) {
24718                         return (EFAULT);
24719                 }
24720                 break;
24721         }
24722         case DDI_MODEL_NONE:
24723                 if (ddi_copyin(arg, &inresvs,
24724                     sizeof (mhioc_inresvs_t), flag) != 0) {
24725                         return (EFAULT);
24726                 }
24727                 if ((rval = sd_persistent_reservation_in_read_resv(un,
24728                     &inresvs, flag)) != 0) {
24729                         return (rval);
24730                 }
24731                 if (ddi_copyout(&inresvs, arg,
24732                     sizeof (mhioc_inresvs_t), flag) != 0) {
24733                         return (EFAULT);
24734                 }
24735                 break;
24736         }
24737 
24738 #else /* ! _MULTI_DATAMODEL */
24739 
24740         if (ddi_copyin(arg, &inresvs, sizeof (mhioc_inresvs_t), flag) != 0) {
24741                 return (EFAULT);
24742         }
24743         rval = sd_persistent_reservation_in_read_resv(un, &inresvs, flag);
24744         if (rval != 0) {
24745                 return (rval);
24746         }
24747         if (ddi_copyout(&inresvs, arg, sizeof (mhioc_inresvs_t), flag)) {
24748                 return (EFAULT);
24749         }
24750 
24751 #endif /* ! _MULTI_DATAMODEL */
24752 
24753         return (rval);
24754 }
24755 
24756 
24757 /*
24758  * The following routines support the clustering functionality described below
24759  * and implement lost reservation reclaim functionality.
24760  *
24761  * Clustering
24762  * ----------
24763  * The clustering code uses two different, independent forms of SCSI
24764  * reservation. Traditional SCSI-2 Reserve/Release and the newer SCSI-3
24765  * Persistent Group Reservations. For any particular disk, it will use either
24766  * SCSI-2 or SCSI-3 PGR but never both at the same time for the same disk.
24767  *
24768  * SCSI-2
24769  * The cluster software takes ownership of a multi-hosted disk by issuing the
24770  * MHIOCTKOWN ioctl to the disk driver. It releases ownership by issuing the
24771  * MHIOCRELEASE ioctl.  Closely related is the MHIOCENFAILFAST ioctl -- a
24772  * cluster, just after taking ownership of the disk with the MHIOCTKOWN ioctl
24773  * then issues the MHIOCENFAILFAST ioctl.  This ioctl "enables failfast" in the
24774  * driver. The meaning of failfast is that if the driver (on this host) ever
24775  * encounters the scsi error return code RESERVATION_CONFLICT from the device,
24776  * it should immediately panic the host. The motivation for this ioctl is that
24777  * if this host does encounter reservation conflict, the underlying cause is
24778  * that some other host of the cluster has decided that this host is no longer
24779  * in the cluster and has seized control of the disks for itself. Since this
24780  * host is no longer in the cluster, it ought to panic itself. The
24781  * MHIOCENFAILFAST ioctl does two things:
24782  *      (a) it sets a flag that will cause any returned RESERVATION_CONFLICT
24783  *      error to panic the host
24784  *      (b) it sets up a periodic timer to test whether this host still has
24785  *      "access" (in that no other host has reserved the device):  if the
24786  *      periodic timer gets RESERVATION_CONFLICT, the host is panicked. The
24787  *      purpose of that periodic timer is to handle scenarios where the host is
24788  *      otherwise temporarily quiescent, temporarily doing no real i/o.
24789  * The MHIOCTKOWN ioctl will "break" a reservation that is held by another host,
24790  * by issuing a SCSI Bus Device Reset.  It will then issue a SCSI Reserve for
24791  * the device itself.
24792  *
24793  * SCSI-3 PGR
24794  * A direct semantic implementation of the SCSI-3 Persistent Reservation
24795  * facility is supported through the shared multihost disk ioctls
24796  * (MHIOCGRP_INKEYS, MHIOCGRP_INRESV, MHIOCGRP_REGISTER, MHIOCGRP_RESERVE,
24797  * MHIOCGRP_PREEMPTANDABORT, MHIOCGRP_CLEAR)
24798  *
24799  * Reservation Reclaim:
24800  * --------------------
24801  * To support the lost reservation reclaim operations this driver creates a
24802  * single thread to handle reinstating reservations on all devices that have
24803  * lost reservations sd_resv_reclaim_requests are logged for all devices that
24804  * have LOST RESERVATIONS when the scsi watch facility callsback sd_mhd_watch_cb
24805  * and the reservation reclaim thread loops through the requests to regain the
24806  * lost reservations.
24807  */
24808 
24809 /*
24810  *    Function: sd_check_mhd()
24811  *
24812  * Description: This function sets up and submits a scsi watch request or
24813  *              terminates an existing watch request. This routine is used in
24814  *              support of reservation reclaim.
24815  *
24816  *   Arguments: dev    - the device 'dev_t' is used for context to discriminate
24817  *                       among multiple watches that share the callback function
24818  *              interval - the number of microseconds specifying the watch
24819  *                         interval for issuing TEST UNIT READY commands. If
24820  *                         set to 0 the watch should be terminated. If the
24821  *                         interval is set to 0 and if the device is required
24822  *                         to hold reservation while disabling failfast, the
24823  *                         watch is restarted with an interval of
24824  *                         reinstate_resv_delay.
24825  *
24826  * Return Code: 0          - Successful submit/terminate of scsi watch request
24827  *              ENXIO      - Indicates an invalid device was specified
24828  *              EAGAIN     - Unable to submit the scsi watch request
24829  */
24830 
24831 static int
24832 sd_check_mhd(dev_t dev, int interval)
24833 {
24834         struct sd_lun   *un;
24835         opaque_t        token;
24836 
24837         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24838                 return (ENXIO);
24839         }
24840 
24841         /* is this a watch termination request? */
24842         if (interval == 0) {
24843                 mutex_enter(SD_MUTEX(un));
24844                 /* if there is an existing watch task then terminate it */
24845                 if (un->un_mhd_token) {
24846                         token = un->un_mhd_token;
24847                         un->un_mhd_token = NULL;
24848                         mutex_exit(SD_MUTEX(un));
24849                         (void) scsi_watch_request_terminate(token,
24850                             SCSI_WATCH_TERMINATE_ALL_WAIT);
24851                         mutex_enter(SD_MUTEX(un));
24852                 } else {
24853                         mutex_exit(SD_MUTEX(un));
24854                         /*
24855                          * Note: If we return here we don't check for the
24856                          * failfast case. This is the original legacy
24857                          * implementation but perhaps we should be checking
24858                          * the failfast case.
24859                          */
24860                         return (0);
24861                 }
24862                 /*
24863                  * If the device is required to hold reservation while
24864                  * disabling failfast, we need to restart the scsi_watch
24865                  * routine with an interval of reinstate_resv_delay.
24866                  */
24867                 if (un->un_resvd_status & SD_RESERVE) {
24868                         interval = sd_reinstate_resv_delay/1000;
24869                 } else {
24870                         /* no failfast so bail */
24871                         mutex_exit(SD_MUTEX(un));
24872                         return (0);
24873                 }
24874                 mutex_exit(SD_MUTEX(un));
24875         }
24876 
24877         /*
24878          * adjust minimum time interval to 1 second,
24879          * and convert from msecs to usecs
24880          */
24881         if (interval > 0 && interval < 1000) {
24882                 interval = 1000;
24883         }
24884         interval *= 1000;
24885 
24886         /*
24887          * submit the request to the scsi_watch service
24888          */
24889         token = scsi_watch_request_submit(SD_SCSI_DEVP(un), interval,
24890             SENSE_LENGTH, sd_mhd_watch_cb, (caddr_t)dev);
24891         if (token == NULL) {
24892                 return (EAGAIN);
24893         }
24894 
24895         /*
24896          * save token for termination later on
24897          */
24898         mutex_enter(SD_MUTEX(un));
24899         un->un_mhd_token = token;
24900         mutex_exit(SD_MUTEX(un));
24901         return (0);
24902 }
24903 
24904 
24905 /*
24906  *    Function: sd_mhd_watch_cb()
24907  *
24908  * Description: This function is the call back function used by the scsi watch
24909  *              facility. The scsi watch facility sends the "Test Unit Ready"
24910  *              and processes the status. If applicable (i.e. a "Unit Attention"
24911  *              status and automatic "Request Sense" not used) the scsi watch
24912  *              facility will send a "Request Sense" and retrieve the sense data
24913  *              to be passed to this callback function. In either case the
24914  *              automatic "Request Sense" or the facility submitting one, this
24915  *              callback is passed the status and sense data.
24916  *
24917  *   Arguments: arg -   the device 'dev_t' is used for context to discriminate
24918  *                      among multiple watches that share this callback function
24919  *              resultp - scsi watch facility result packet containing scsi
24920  *                        packet, status byte and sense data
24921  *
24922  * Return Code: 0 - continue the watch task
24923  *              non-zero - terminate the watch task
24924  */
24925 
24926 static int
24927 sd_mhd_watch_cb(caddr_t arg, struct scsi_watch_result *resultp)
24928 {
24929         struct sd_lun                   *un;
24930         struct scsi_status              *statusp;
24931         uint8_t                         *sensep;
24932         struct scsi_pkt                 *pkt;
24933         uchar_t                         actual_sense_length;
24934         dev_t                           dev = (dev_t)arg;
24935 
24936         ASSERT(resultp != NULL);
24937         statusp                 = resultp->statusp;
24938         sensep                  = (uint8_t *)resultp->sensep;
24939         pkt                     = resultp->pkt;
24940         actual_sense_length     = resultp->actual_sense_length;
24941 
24942         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
24943                 return (ENXIO);
24944         }
24945 
24946         SD_TRACE(SD_LOG_IOCTL_MHD, un,
24947             "sd_mhd_watch_cb: reason '%s', status '%s'\n",
24948             scsi_rname(pkt->pkt_reason), sd_sname(*((unsigned char *)statusp)));
24949 
24950         /* Begin processing of the status and/or sense data */
24951         if (pkt->pkt_reason != CMD_CMPLT) {
24952                 /* Handle the incomplete packet */
24953                 sd_mhd_watch_incomplete(un, pkt);
24954                 return (0);
24955         } else if (*((unsigned char *)statusp) != STATUS_GOOD) {
24956                 if (*((unsigned char *)statusp)
24957                     == STATUS_RESERVATION_CONFLICT) {
24958                         /*
24959                          * Handle a reservation conflict by panicking if
24960                          * configured for failfast or by logging the conflict
24961                          * and updating the reservation status
24962                          */
24963                         mutex_enter(SD_MUTEX(un));
24964                         if ((un->un_resvd_status & SD_FAILFAST) &&
24965                             (sd_failfast_enable)) {
24966                                 sd_panic_for_res_conflict(un);
24967                                 /*NOTREACHED*/
24968                         }
24969                         SD_INFO(SD_LOG_IOCTL_MHD, un,
24970                             "sd_mhd_watch_cb: Reservation Conflict\n");
24971                         un->un_resvd_status |= SD_RESERVATION_CONFLICT;
24972                         mutex_exit(SD_MUTEX(un));
24973                 }
24974         }
24975 
24976         if (sensep != NULL) {
24977                 if (actual_sense_length >= (SENSE_LENGTH - 2)) {
24978                         mutex_enter(SD_MUTEX(un));
24979                         if ((scsi_sense_asc(sensep) ==
24980                             SD_SCSI_RESET_SENSE_CODE) &&
24981                             (un->un_resvd_status & SD_RESERVE)) {
24982                                 /*
24983                                  * The additional sense code indicates a power
24984                                  * on or bus device reset has occurred; update
24985                                  * the reservation status.
24986                                  */
24987                                 un->un_resvd_status |=
24988                                     (SD_LOST_RESERVE | SD_WANT_RESERVE);
24989                                 SD_INFO(SD_LOG_IOCTL_MHD, un,
24990                                     "sd_mhd_watch_cb: Lost Reservation\n");
24991                         }
24992                 } else {
24993                         return (0);
24994                 }
24995         } else {
24996                 mutex_enter(SD_MUTEX(un));
24997         }
24998 
24999         if ((un->un_resvd_status & SD_RESERVE) &&
25000             (un->un_resvd_status & SD_LOST_RESERVE)) {
25001                 if (un->un_resvd_status & SD_WANT_RESERVE) {
25002                         /*
25003                          * A reset occurred in between the last probe and this
25004                          * one so if a timeout is pending cancel it.
25005                          */
25006                         if (un->un_resvd_timeid) {
25007                                 timeout_id_t temp_id = un->un_resvd_timeid;
25008                                 un->un_resvd_timeid = NULL;
25009                                 mutex_exit(SD_MUTEX(un));
25010                                 (void) untimeout(temp_id);
25011                                 mutex_enter(SD_MUTEX(un));
25012                         }
25013                         un->un_resvd_status &= ~SD_WANT_RESERVE;
25014                 }
25015                 if (un->un_resvd_timeid == 0) {
25016                         /* Schedule a timeout to handle the lost reservation */
25017                         un->un_resvd_timeid = timeout(sd_mhd_resvd_recover,
25018                             (void *)dev,
25019                             drv_usectohz(sd_reinstate_resv_delay));
25020                 }
25021         }
25022         mutex_exit(SD_MUTEX(un));
25023         return (0);
25024 }
25025 
25026 
25027 /*
25028  *    Function: sd_mhd_watch_incomplete()
25029  *
25030  * Description: This function is used to find out why a scsi pkt sent by the
25031  *              scsi watch facility was not completed. Under some scenarios this
25032  *              routine will return. Otherwise it will send a bus reset to see
25033  *              if the drive is still online.
25034  *
25035  *   Arguments: un  - driver soft state (unit) structure
25036  *              pkt - incomplete scsi pkt
25037  */
25038 
25039 static void
25040 sd_mhd_watch_incomplete(struct sd_lun *un, struct scsi_pkt *pkt)
25041 {
25042         int     be_chatty;
25043         int     perr;
25044 
25045         ASSERT(pkt != NULL);
25046         ASSERT(un != NULL);
25047         be_chatty       = (!(pkt->pkt_flags & FLAG_SILENT));
25048         perr            = (pkt->pkt_statistics & STAT_PERR);
25049 
25050         mutex_enter(SD_MUTEX(un));
25051         if (un->un_state == SD_STATE_DUMPING) {
25052                 mutex_exit(SD_MUTEX(un));
25053                 return;
25054         }
25055 
25056         switch (pkt->pkt_reason) {
25057         case CMD_UNX_BUS_FREE:
25058                 /*
25059                  * If we had a parity error that caused the target to drop BSY*,
25060                  * don't be chatty about it.
25061                  */
25062                 if (perr && be_chatty) {
25063                         be_chatty = 0;
25064                 }
25065                 break;
25066         case CMD_TAG_REJECT:
25067                 /*
25068                  * The SCSI-2 spec states that a tag reject will be sent by the
25069                  * target if tagged queuing is not supported. A tag reject may
25070                  * also be sent during certain initialization periods or to
25071                  * control internal resources. For the latter case the target
25072                  * may also return Queue Full.
25073                  *
25074                  * If this driver receives a tag reject from a target that is
25075                  * going through an init period or controlling internal
25076                  * resources tagged queuing will be disabled. This is a less
25077                  * than optimal behavior but the driver is unable to determine
25078                  * the target state and assumes tagged queueing is not supported
25079                  */
25080                 pkt->pkt_flags = 0;
25081                 un->un_tagflags = 0;
25082 
25083                 if (un->un_f_opt_queueing == TRUE) {
25084                         un->un_throttle = min(un->un_throttle, 3);
25085                 } else {
25086                         un->un_throttle = 1;
25087                 }
25088                 mutex_exit(SD_MUTEX(un));
25089                 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1);
25090                 mutex_enter(SD_MUTEX(un));
25091                 break;
25092         case CMD_INCOMPLETE:
25093                 /*
25094                  * The transport stopped with an abnormal state, fallthrough and
25095                  * reset the target and/or bus unless selection did not complete
25096                  * (indicated by STATE_GOT_BUS) in which case we don't want to
25097                  * go through a target/bus reset
25098                  */
25099                 if (pkt->pkt_state == STATE_GOT_BUS) {
25100                         break;
25101                 }
25102                 /*FALLTHROUGH*/
25103 
25104         case CMD_TIMEOUT:
25105         default:
25106                 /*
25107                  * The lun may still be running the command, so a lun reset
25108                  * should be attempted. If the lun reset fails or cannot be
25109                  * issued, than try a target reset. Lastly try a bus reset.
25110                  */
25111                 if ((pkt->pkt_statistics &
25112                     (STAT_BUS_RESET|STAT_DEV_RESET|STAT_ABORTED)) == 0) {
25113                         int reset_retval = 0;
25114                         mutex_exit(SD_MUTEX(un));
25115                         if (un->un_f_allow_bus_device_reset == TRUE) {
25116                                 if (un->un_f_lun_reset_enabled == TRUE) {
25117                                         reset_retval =
25118                                             scsi_reset(SD_ADDRESS(un),
25119                                             RESET_LUN);
25120                                 }
25121                                 if (reset_retval == 0) {
25122                                         reset_retval =
25123                                             scsi_reset(SD_ADDRESS(un),
25124                                             RESET_TARGET);
25125                                 }
25126                         }
25127                         if (reset_retval == 0) {
25128                                 (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
25129                         }
25130                         mutex_enter(SD_MUTEX(un));
25131                 }
25132                 break;
25133         }
25134 
25135         /* A device/bus reset has occurred; update the reservation status. */
25136         if ((pkt->pkt_reason == CMD_RESET) || (pkt->pkt_statistics &
25137             (STAT_BUS_RESET | STAT_DEV_RESET))) {
25138                 if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) {
25139                         un->un_resvd_status |=
25140                             (SD_LOST_RESERVE | SD_WANT_RESERVE);
25141                         SD_INFO(SD_LOG_IOCTL_MHD, un,
25142                             "sd_mhd_watch_incomplete: Lost Reservation\n");
25143                 }
25144         }
25145 
25146         /*
25147          * The disk has been turned off; Update the device state.
25148          *
25149          * Note: Should we be offlining the disk here?
25150          */
25151         if (pkt->pkt_state == STATE_GOT_BUS) {
25152                 SD_INFO(SD_LOG_IOCTL_MHD, un, "sd_mhd_watch_incomplete: "
25153                     "Disk not responding to selection\n");
25154                 if (un->un_state != SD_STATE_OFFLINE) {
25155                         New_state(un, SD_STATE_OFFLINE);
25156                 }
25157         } else if (be_chatty) {
25158                 /*
25159                  * suppress messages if they are all the same pkt reason;
25160                  * with TQ, many (up to 256) are returned with the same
25161                  * pkt_reason
25162                  */
25163                 if (pkt->pkt_reason != un->un_last_pkt_reason) {
25164                         SD_ERROR(SD_LOG_IOCTL_MHD, un,
25165                             "sd_mhd_watch_incomplete: "
25166                             "SCSI transport failed: reason '%s'\n",
25167                             scsi_rname(pkt->pkt_reason));
25168                 }
25169         }
25170         un->un_last_pkt_reason = pkt->pkt_reason;
25171         mutex_exit(SD_MUTEX(un));
25172 }
25173 
25174 
25175 /*
25176  *    Function: sd_sname()
25177  *
25178  * Description: This is a simple little routine to return a string containing
25179  *              a printable description of command status byte for use in
25180  *              logging.
25181  *
25182  *   Arguments: status - pointer to a status byte
25183  *
25184  * Return Code: char * - string containing status description.
25185  */
25186 
25187 static char *
25188 sd_sname(uchar_t status)
25189 {
25190         switch (status & STATUS_MASK) {
25191         case STATUS_GOOD:
25192                 return ("good status");
25193         case STATUS_CHECK:
25194                 return ("check condition");
25195         case STATUS_MET:
25196                 return ("condition met");
25197         case STATUS_BUSY:
25198                 return ("busy");
25199         case STATUS_INTERMEDIATE:
25200                 return ("intermediate");
25201         case STATUS_INTERMEDIATE_MET:
25202                 return ("intermediate - condition met");
25203         case STATUS_RESERVATION_CONFLICT:
25204                 return ("reservation_conflict");
25205         case STATUS_TERMINATED:
25206                 return ("command terminated");
25207         case STATUS_QFULL:
25208                 return ("queue full");
25209         default:
25210                 return ("<unknown status>");
25211         }
25212 }
25213 
25214 
25215 /*
25216  *    Function: sd_mhd_resvd_recover()
25217  *
25218  * Description: This function adds a reservation entry to the
25219  *              sd_resv_reclaim_request list and signals the reservation
25220  *              reclaim thread that there is work pending. If the reservation
25221  *              reclaim thread has not been previously created this function
25222  *              will kick it off.
25223  *
25224  *   Arguments: arg -   the device 'dev_t' is used for context to discriminate
25225  *                      among multiple watches that share this callback function
25226  *
25227  *     Context: This routine is called by timeout() and is run in interrupt
25228  *              context. It must not sleep or call other functions which may
25229  *              sleep.
25230  */
25231 
25232 static void
25233 sd_mhd_resvd_recover(void *arg)
25234 {
25235         dev_t                   dev = (dev_t)arg;
25236         struct sd_lun           *un;
25237         struct sd_thr_request   *sd_treq = NULL;
25238         struct sd_thr_request   *sd_cur = NULL;
25239         struct sd_thr_request   *sd_prev = NULL;
25240         int                     already_there = 0;
25241 
25242         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
25243                 return;
25244         }
25245 
25246         mutex_enter(SD_MUTEX(un));
25247         un->un_resvd_timeid = NULL;
25248         if (un->un_resvd_status & SD_WANT_RESERVE) {
25249                 /*
25250                  * There was a reset so don't issue the reserve, allow the
25251                  * sd_mhd_watch_cb callback function to notice this and
25252                  * reschedule the timeout for reservation.
25253                  */
25254                 mutex_exit(SD_MUTEX(un));
25255                 return;
25256         }
25257         mutex_exit(SD_MUTEX(un));
25258 
25259         /*
25260          * Add this device to the sd_resv_reclaim_request list and the
25261          * sd_resv_reclaim_thread should take care of the rest.
25262          *
25263          * Note: We can't sleep in this context so if the memory allocation
25264          * fails allow the sd_mhd_watch_cb callback function to notice this and
25265          * reschedule the timeout for reservation.  (4378460)
25266          */
25267         sd_treq = (struct sd_thr_request *)
25268             kmem_zalloc(sizeof (struct sd_thr_request), KM_NOSLEEP);
25269         if (sd_treq == NULL) {
25270                 return;
25271         }
25272 
25273         sd_treq->sd_thr_req_next = NULL;
25274         sd_treq->dev = dev;
25275         mutex_enter(&sd_tr.srq_resv_reclaim_mutex);
25276         if (sd_tr.srq_thr_req_head == NULL) {
25277                 sd_tr.srq_thr_req_head = sd_treq;
25278         } else {
25279                 sd_cur = sd_prev = sd_tr.srq_thr_req_head;
25280                 for (; sd_cur != NULL; sd_cur = sd_cur->sd_thr_req_next) {
25281                         if (sd_cur->dev == dev) {
25282                                 /*
25283                                  * already in Queue so don't log
25284                                  * another request for the device
25285                                  */
25286                                 already_there = 1;
25287                                 break;
25288                         }
25289                         sd_prev = sd_cur;
25290                 }
25291                 if (!already_there) {
25292                         SD_INFO(SD_LOG_IOCTL_MHD, un, "sd_mhd_resvd_recover: "
25293                             "logging request for %lx\n", dev);
25294                         sd_prev->sd_thr_req_next = sd_treq;
25295                 } else {
25296                         kmem_free(sd_treq, sizeof (struct sd_thr_request));
25297                 }
25298         }
25299 
25300         /*
25301          * Create a kernel thread to do the reservation reclaim and free up this
25302          * thread. We cannot block this thread while we go away to do the
25303          * reservation reclaim
25304          */
25305         if (sd_tr.srq_resv_reclaim_thread == NULL)
25306                 sd_tr.srq_resv_reclaim_thread = thread_create(NULL, 0,
25307                     sd_resv_reclaim_thread, NULL,
25308                     0, &p0, TS_RUN, v.v_maxsyspri - 2);
25309 
25310         /* Tell the reservation reclaim thread that it has work to do */
25311         cv_signal(&sd_tr.srq_resv_reclaim_cv);
25312         mutex_exit(&sd_tr.srq_resv_reclaim_mutex);
25313 }
25314 
25315 /*
25316  *    Function: sd_resv_reclaim_thread()
25317  *
25318  * Description: This function implements the reservation reclaim operations
25319  *
25320  *   Arguments: arg - the device 'dev_t' is used for context to discriminate
25321  *                    among multiple watches that share this callback function
25322  */
25323 
25324 static void
25325 sd_resv_reclaim_thread()
25326 {
25327         struct sd_lun           *un;
25328         struct sd_thr_request   *sd_mhreq;
25329 
25330         /* Wait for work */
25331         mutex_enter(&sd_tr.srq_resv_reclaim_mutex);
25332         if (sd_tr.srq_thr_req_head == NULL) {
25333                 cv_wait(&sd_tr.srq_resv_reclaim_cv,
25334                     &sd_tr.srq_resv_reclaim_mutex);
25335         }
25336 
25337         /* Loop while we have work */
25338         while ((sd_tr.srq_thr_cur_req = sd_tr.srq_thr_req_head) != NULL) {
25339                 un = ddi_get_soft_state(sd_state,
25340                     SDUNIT(sd_tr.srq_thr_cur_req->dev));
25341                 if (un == NULL) {
25342                         /*
25343                          * softstate structure is NULL so just
25344                          * dequeue the request and continue
25345                          */
25346                         sd_tr.srq_thr_req_head =
25347                             sd_tr.srq_thr_cur_req->sd_thr_req_next;
25348                         kmem_free(sd_tr.srq_thr_cur_req,
25349                             sizeof (struct sd_thr_request));
25350                         continue;
25351                 }
25352 
25353                 /* dequeue the request */
25354                 sd_mhreq = sd_tr.srq_thr_cur_req;
25355                 sd_tr.srq_thr_req_head =
25356                     sd_tr.srq_thr_cur_req->sd_thr_req_next;
25357                 mutex_exit(&sd_tr.srq_resv_reclaim_mutex);
25358 
25359                 /*
25360                  * Reclaim reservation only if SD_RESERVE is still set. There
25361                  * may have been a call to MHIOCRELEASE before we got here.
25362                  */
25363                 mutex_enter(SD_MUTEX(un));
25364                 if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) {
25365                         /*
25366                          * Note: The SD_LOST_RESERVE flag is cleared before
25367                          * reclaiming the reservation. If this is done after the
25368                          * call to sd_reserve_release a reservation loss in the
25369                          * window between pkt completion of reserve cmd and
25370                          * mutex_enter below may not be recognized
25371                          */
25372                         un->un_resvd_status &= ~SD_LOST_RESERVE;
25373                         mutex_exit(SD_MUTEX(un));
25374 
25375                         if (sd_reserve_release(sd_mhreq->dev,
25376                             SD_RESERVE) == 0) {
25377                                 mutex_enter(SD_MUTEX(un));
25378                                 un->un_resvd_status |= SD_RESERVE;
25379                                 mutex_exit(SD_MUTEX(un));
25380                                 SD_INFO(SD_LOG_IOCTL_MHD, un,
25381                                     "sd_resv_reclaim_thread: "
25382                                     "Reservation Recovered\n");
25383                         } else {
25384                                 mutex_enter(SD_MUTEX(un));
25385                                 un->un_resvd_status |= SD_LOST_RESERVE;
25386                                 mutex_exit(SD_MUTEX(un));
25387                                 SD_INFO(SD_LOG_IOCTL_MHD, un,
25388                                     "sd_resv_reclaim_thread: Failed "
25389                                     "Reservation Recovery\n");
25390                         }
25391                 } else {
25392                         mutex_exit(SD_MUTEX(un));
25393                 }
25394                 mutex_enter(&sd_tr.srq_resv_reclaim_mutex);
25395                 ASSERT(sd_mhreq == sd_tr.srq_thr_cur_req);
25396                 kmem_free(sd_mhreq, sizeof (struct sd_thr_request));
25397                 sd_mhreq = sd_tr.srq_thr_cur_req = NULL;
25398                 /*
25399                  * wakeup the destroy thread if anyone is waiting on
25400                  * us to complete.
25401                  */
25402                 cv_signal(&sd_tr.srq_inprocess_cv);
25403                 SD_TRACE(SD_LOG_IOCTL_MHD, un,
25404                     "sd_resv_reclaim_thread: cv_signalling current request \n");
25405         }
25406 
25407         /*
25408          * cleanup the sd_tr structure now that this thread will not exist
25409          */
25410         ASSERT(sd_tr.srq_thr_req_head == NULL);
25411         ASSERT(sd_tr.srq_thr_cur_req == NULL);
25412         sd_tr.srq_resv_reclaim_thread = NULL;
25413         mutex_exit(&sd_tr.srq_resv_reclaim_mutex);
25414         thread_exit();
25415 }
25416 
25417 
25418 /*
25419  *    Function: sd_rmv_resv_reclaim_req()
25420  *
25421  * Description: This function removes any pending reservation reclaim requests
25422  *              for the specified device.
25423  *
25424  *   Arguments: dev - the device 'dev_t'
25425  */
25426 
25427 static void
25428 sd_rmv_resv_reclaim_req(dev_t dev)
25429 {
25430         struct sd_thr_request *sd_mhreq;
25431         struct sd_thr_request *sd_prev;
25432 
25433         /* Remove a reservation reclaim request from the list */
25434         mutex_enter(&sd_tr.srq_resv_reclaim_mutex);
25435         if (sd_tr.srq_thr_cur_req && sd_tr.srq_thr_cur_req->dev == dev) {
25436                 /*
25437                  * We are attempting to reinstate reservation for
25438                  * this device. We wait for sd_reserve_release()
25439                  * to return before we return.
25440                  */
25441                 cv_wait(&sd_tr.srq_inprocess_cv,
25442                     &sd_tr.srq_resv_reclaim_mutex);
25443         } else {
25444                 sd_prev = sd_mhreq = sd_tr.srq_thr_req_head;
25445                 if (sd_mhreq && sd_mhreq->dev == dev) {
25446                         sd_tr.srq_thr_req_head = sd_mhreq->sd_thr_req_next;
25447                         kmem_free(sd_mhreq, sizeof (struct sd_thr_request));
25448                         mutex_exit(&sd_tr.srq_resv_reclaim_mutex);
25449                         return;
25450                 }
25451                 for (; sd_mhreq != NULL; sd_mhreq = sd_mhreq->sd_thr_req_next) {
25452                         if (sd_mhreq && sd_mhreq->dev == dev) {
25453                                 break;
25454                         }
25455                         sd_prev = sd_mhreq;
25456                 }
25457                 if (sd_mhreq != NULL) {
25458                         sd_prev->sd_thr_req_next = sd_mhreq->sd_thr_req_next;
25459                         kmem_free(sd_mhreq, sizeof (struct sd_thr_request));
25460                 }
25461         }
25462         mutex_exit(&sd_tr.srq_resv_reclaim_mutex);
25463 }
25464 
25465 
25466 /*
25467  *    Function: sd_mhd_reset_notify_cb()
25468  *
25469  * Description: This is a call back function for scsi_reset_notify. This
25470  *              function updates the softstate reserved status and logs the
25471  *              reset. The driver scsi watch facility callback function
25472  *              (sd_mhd_watch_cb) and reservation reclaim thread functionality
25473  *              will reclaim the reservation.
25474  *
25475  *   Arguments: arg  - driver soft state (unit) structure
25476  */
25477 
25478 static void
25479 sd_mhd_reset_notify_cb(caddr_t arg)
25480 {
25481         struct sd_lun *un = (struct sd_lun *)arg;
25482 
25483         mutex_enter(SD_MUTEX(un));
25484         if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) {
25485                 un->un_resvd_status |= (SD_LOST_RESERVE | SD_WANT_RESERVE);
25486                 SD_INFO(SD_LOG_IOCTL_MHD, un,
25487                     "sd_mhd_reset_notify_cb: Lost Reservation\n");
25488         }
25489         mutex_exit(SD_MUTEX(un));
25490 }
25491 
25492 
25493 /*
25494  *    Function: sd_take_ownership()
25495  *
25496  * Description: This routine implements an algorithm to achieve a stable
25497  *              reservation on disks which don't implement priority reserve,
25498  *              and makes sure that other host lose re-reservation attempts.
25499  *              This algorithm contains of a loop that keeps issuing the RESERVE
25500  *              for some period of time (min_ownership_delay, default 6 seconds)
25501  *              During that loop, it looks to see if there has been a bus device
25502  *              reset or bus reset (both of which cause an existing reservation
25503  *              to be lost). If the reservation is lost issue RESERVE until a
25504  *              period of min_ownership_delay with no resets has gone by, or
25505  *              until max_ownership_delay has expired. This loop ensures that
25506  *              the host really did manage to reserve the device, in spite of
25507  *              resets. The looping for min_ownership_delay (default six
25508  *              seconds) is important to early generation clustering products,
25509  *              Solstice HA 1.x and Sun Cluster 2.x. Those products use an
25510  *              MHIOCENFAILFAST periodic timer of two seconds. By having
25511  *              MHIOCTKOWN issue Reserves in a loop for six seconds, and having
25512  *              MHIOCENFAILFAST poll every two seconds, the idea is that by the
25513  *              time the MHIOCTKOWN ioctl returns, the other host (if any) will
25514  *              have already noticed, via the MHIOCENFAILFAST polling, that it
25515  *              no longer "owns" the disk and will have panicked itself.  Thus,
25516  *              the host issuing the MHIOCTKOWN is assured (with timing
25517  *              dependencies) that by the time it actually starts to use the
25518  *              disk for real work, the old owner is no longer accessing it.
25519  *
25520  *              min_ownership_delay is the minimum amount of time for which the
25521  *              disk must be reserved continuously devoid of resets before the
25522  *              MHIOCTKOWN ioctl will return success.
25523  *
25524  *              max_ownership_delay indicates the amount of time by which the
25525  *              take ownership should succeed or timeout with an error.
25526  *
25527  *   Arguments: dev - the device 'dev_t'
25528  *              *p  - struct containing timing info.
25529  *
25530  * Return Code: 0 for success or error code
25531  */
25532 
25533 static int
25534 sd_take_ownership(dev_t dev, struct mhioctkown *p)
25535 {
25536         struct sd_lun   *un;
25537         int             rval;
25538         int             err;
25539         int             reservation_count   = 0;
25540         int             min_ownership_delay =  6000000; /* in usec */
25541         int             max_ownership_delay = 30000000; /* in usec */
25542         clock_t         start_time;     /* starting time of this algorithm */
25543         clock_t         end_time;       /* time limit for giving up */
25544         clock_t         ownership_time; /* time limit for stable ownership */
25545         clock_t         current_time;
25546         clock_t         previous_current_time;
25547 
25548         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
25549                 return (ENXIO);
25550         }
25551 
25552         /*
25553          * Attempt a device reservation. A priority reservation is requested.
25554          */
25555         if ((rval = sd_reserve_release(dev, SD_PRIORITY_RESERVE))
25556             != SD_SUCCESS) {
25557                 SD_ERROR(SD_LOG_IOCTL_MHD, un,
25558                     "sd_take_ownership: return(1)=%d\n", rval);
25559                 return (rval);
25560         }
25561 
25562         /* Update the softstate reserved status to indicate the reservation */
25563         mutex_enter(SD_MUTEX(un));
25564         un->un_resvd_status |= SD_RESERVE;
25565         un->un_resvd_status &=
25566             ~(SD_LOST_RESERVE | SD_WANT_RESERVE | SD_RESERVATION_CONFLICT);
25567         mutex_exit(SD_MUTEX(un));
25568 
25569         if (p != NULL) {
25570                 if (p->min_ownership_delay != 0) {
25571                         min_ownership_delay = p->min_ownership_delay * 1000;
25572                 }
25573                 if (p->max_ownership_delay != 0) {
25574                         max_ownership_delay = p->max_ownership_delay * 1000;
25575                 }
25576         }
25577         SD_INFO(SD_LOG_IOCTL_MHD, un,
25578             "sd_take_ownership: min, max delays: %d, %d\n",
25579             min_ownership_delay, max_ownership_delay);
25580 
25581         start_time = ddi_get_lbolt();
25582         current_time    = start_time;
25583         ownership_time  = current_time + drv_usectohz(min_ownership_delay);
25584         end_time        = start_time + drv_usectohz(max_ownership_delay);
25585 
25586         while (current_time - end_time < 0) {
25587                 delay(drv_usectohz(500000));
25588 
25589                 if ((err = sd_reserve_release(dev, SD_RESERVE)) != 0) {
25590                         if ((sd_reserve_release(dev, SD_RESERVE)) != 0) {
25591                                 mutex_enter(SD_MUTEX(un));
25592                                 rval = (un->un_resvd_status &
25593                                     SD_RESERVATION_CONFLICT) ? EACCES : EIO;
25594                                 mutex_exit(SD_MUTEX(un));
25595                                 break;
25596                         }
25597                 }
25598                 previous_current_time = current_time;
25599                 current_time = ddi_get_lbolt();
25600                 mutex_enter(SD_MUTEX(un));
25601                 if (err || (un->un_resvd_status & SD_LOST_RESERVE)) {
25602                         ownership_time = ddi_get_lbolt() +
25603                             drv_usectohz(min_ownership_delay);
25604                         reservation_count = 0;
25605                 } else {
25606                         reservation_count++;
25607                 }
25608                 un->un_resvd_status |= SD_RESERVE;
25609                 un->un_resvd_status &= ~(SD_LOST_RESERVE | SD_WANT_RESERVE);
25610                 mutex_exit(SD_MUTEX(un));
25611 
25612                 SD_INFO(SD_LOG_IOCTL_MHD, un,
25613                     "sd_take_ownership: ticks for loop iteration=%ld, "
25614                     "reservation=%s\n", (current_time - previous_current_time),
25615                     reservation_count ? "ok" : "reclaimed");
25616 
25617                 if (current_time - ownership_time >= 0 &&
25618                     reservation_count >= 4) {
25619                         rval = 0; /* Achieved a stable ownership */
25620                         break;
25621                 }
25622                 if (current_time - end_time >= 0) {
25623                         rval = EACCES; /* No ownership in max possible time */
25624                         break;
25625                 }
25626         }
25627         SD_TRACE(SD_LOG_IOCTL_MHD, un,
25628             "sd_take_ownership: return(2)=%d\n", rval);
25629         return (rval);
25630 }
25631 
25632 
25633 /*
25634  *    Function: sd_reserve_release()
25635  *
25636  * Description: This function builds and sends scsi RESERVE, RELEASE, and
25637  *              PRIORITY RESERVE commands based on a user specified command type
25638  *
25639  *   Arguments: dev - the device 'dev_t'
25640  *              cmd - user specified command type; one of SD_PRIORITY_RESERVE,
25641  *                    SD_RESERVE, SD_RELEASE
25642  *
25643  * Return Code: 0 or Error Code
25644  */
25645 
25646 static int
25647 sd_reserve_release(dev_t dev, int cmd)
25648 {
25649         struct uscsi_cmd        *com = NULL;
25650         struct sd_lun           *un = NULL;
25651         char                    cdb[CDB_GROUP0];
25652         int                     rval;
25653 
25654         ASSERT((cmd == SD_RELEASE) || (cmd == SD_RESERVE) ||
25655             (cmd == SD_PRIORITY_RESERVE));
25656 
25657         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
25658                 return (ENXIO);
25659         }
25660 
25661         /* instantiate and initialize the command and cdb */
25662         com = kmem_zalloc(sizeof (*com), KM_SLEEP);
25663         bzero(cdb, CDB_GROUP0);
25664         com->uscsi_flags   = USCSI_SILENT;
25665         com->uscsi_timeout = un->un_reserve_release_time;
25666         com->uscsi_cdblen  = CDB_GROUP0;
25667         com->uscsi_cdb          = cdb;
25668         if (cmd == SD_RELEASE) {
25669                 cdb[0] = SCMD_RELEASE;
25670         } else {
25671                 cdb[0] = SCMD_RESERVE;
25672         }
25673 
25674         /* Send the command. */
25675         rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
25676             SD_PATH_STANDARD);
25677 
25678         /*
25679          * "break" a reservation that is held by another host, by issuing a
25680          * reset if priority reserve is desired, and we could not get the
25681          * device.
25682          */
25683         if ((cmd == SD_PRIORITY_RESERVE) &&
25684             (rval != 0) && (com->uscsi_status == STATUS_RESERVATION_CONFLICT)) {
25685                 /*
25686                  * First try to reset the LUN. If we cannot, then try a target
25687                  * reset, followed by a bus reset if the target reset fails.
25688                  */
25689                 int reset_retval = 0;
25690                 if (un->un_f_lun_reset_enabled == TRUE) {
25691                         reset_retval = scsi_reset(SD_ADDRESS(un), RESET_LUN);
25692                 }
25693                 if (reset_retval == 0) {
25694                         /* The LUN reset either failed or was not issued */
25695                         reset_retval = scsi_reset(SD_ADDRESS(un), RESET_TARGET);
25696                 }
25697                 if ((reset_retval == 0) &&
25698                     (scsi_reset(SD_ADDRESS(un), RESET_ALL) == 0)) {
25699                         rval = EIO;
25700                         kmem_free(com, sizeof (*com));
25701                         return (rval);
25702                 }
25703 
25704                 bzero(com, sizeof (struct uscsi_cmd));
25705                 com->uscsi_flags   = USCSI_SILENT;
25706                 com->uscsi_cdb          = cdb;
25707                 com->uscsi_cdblen  = CDB_GROUP0;
25708                 com->uscsi_timeout = 5;
25709 
25710                 /*
25711                  * Reissue the last reserve command, this time without request
25712                  * sense.  Assume that it is just a regular reserve command.
25713                  */
25714                 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
25715                     SD_PATH_STANDARD);
25716         }
25717 
25718         /* Return an error if still getting a reservation conflict. */
25719         if ((rval != 0) && (com->uscsi_status == STATUS_RESERVATION_CONFLICT)) {
25720                 rval = EACCES;
25721         }
25722 
25723         kmem_free(com, sizeof (*com));
25724         return (rval);
25725 }
25726 
25727 
25728 #define SD_NDUMP_RETRIES        12
25729 /*
25730  *      System Crash Dump routine
25731  */
25732 
25733 static int
25734 sddump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk)
25735 {
25736         int             instance;
25737         int             partition;
25738         int             i;
25739         int             err;
25740         struct sd_lun   *un;
25741         struct scsi_pkt *wr_pktp;
25742         struct buf      *wr_bp;
25743         struct buf      wr_buf;
25744         daddr_t         tgt_byte_offset; /* rmw - byte offset for target */
25745         daddr_t         tgt_blkno;      /* rmw - blkno for target */
25746         size_t          tgt_byte_count; /* rmw -  # of bytes to xfer */
25747         size_t          tgt_nblk; /* rmw -  # of tgt blks to xfer */
25748         size_t          io_start_offset;
25749         int             doing_rmw = FALSE;
25750         int             rval;
25751         ssize_t         dma_resid;
25752         daddr_t         oblkno;
25753         diskaddr_t      nblks = 0;
25754         diskaddr_t      start_block;
25755 
25756         instance = SDUNIT(dev);
25757         if (((un = ddi_get_soft_state(sd_state, instance)) == NULL) ||
25758             !SD_IS_VALID_LABEL(un) || ISCD(un)) {
25759                 return (ENXIO);
25760         }
25761 
25762         _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*un))
25763 
25764         SD_TRACE(SD_LOG_DUMP, un, "sddump: entry\n");
25765 
25766         partition = SDPART(dev);
25767         SD_INFO(SD_LOG_DUMP, un, "sddump: partition = %d\n", partition);
25768 
25769         if (!(NOT_DEVBSIZE(un))) {
25770                 int secmask = 0;
25771                 int blknomask = 0;
25772 
25773                 blknomask = (un->un_tgt_blocksize / DEV_BSIZE) - 1;
25774                 secmask = un->un_tgt_blocksize - 1;
25775 
25776                 if (blkno & blknomask) {
25777                         SD_TRACE(SD_LOG_DUMP, un,
25778                             "sddump: dump start block not modulo %d\n",
25779                             un->un_tgt_blocksize);
25780                         return (EINVAL);
25781                 }
25782 
25783                 if ((nblk * DEV_BSIZE) & secmask) {
25784                         SD_TRACE(SD_LOG_DUMP, un,
25785                             "sddump: dump length not modulo %d\n",
25786                             un->un_tgt_blocksize);
25787                         return (EINVAL);
25788                 }
25789 
25790         }
25791 
25792         /* Validate blocks to dump at against partition size. */
25793 
25794         (void) cmlb_partinfo(un->un_cmlbhandle, partition,
25795             &nblks, &start_block, NULL, NULL, (void *)SD_PATH_DIRECT);
25796 
25797         if (NOT_DEVBSIZE(un)) {
25798                 if ((blkno + nblk) > nblks) {
25799                         SD_TRACE(SD_LOG_DUMP, un,
25800                             "sddump: dump range larger than partition: "
25801                             "blkno = 0x%x, nblk = 0x%x, dkl_nblk = 0x%x\n",
25802                             blkno, nblk, nblks);
25803                         return (EINVAL);
25804                 }
25805         } else {
25806                 if (((blkno / (un->un_tgt_blocksize / DEV_BSIZE)) +
25807                     (nblk / (un->un_tgt_blocksize / DEV_BSIZE))) > nblks) {
25808                         SD_TRACE(SD_LOG_DUMP, un,
25809                             "sddump: dump range larger than partition: "
25810                             "blkno = 0x%x, nblk = 0x%x, dkl_nblk = 0x%x\n",
25811                             blkno, nblk, nblks);
25812                         return (EINVAL);
25813                 }
25814         }
25815 
25816         mutex_enter(&un->un_pm_mutex);
25817         if (SD_DEVICE_IS_IN_LOW_POWER(un)) {
25818                 struct scsi_pkt *start_pktp;
25819 
25820                 mutex_exit(&un->un_pm_mutex);
25821 
25822                 /*
25823                  * use pm framework to power on HBA 1st
25824                  */
25825                 (void) pm_raise_power(SD_DEVINFO(un), 0,
25826                     SD_PM_STATE_ACTIVE(un));
25827 
25828                 /*
25829                  * Dump no long uses sdpower to power on a device, it's
25830                  * in-line here so it can be done in polled mode.
25831                  */
25832 
25833                 SD_INFO(SD_LOG_DUMP, un, "sddump: starting device\n");
25834 
25835                 start_pktp = scsi_init_pkt(SD_ADDRESS(un), NULL, NULL,
25836                     CDB_GROUP0, un->un_status_len, 0, 0, NULL_FUNC, NULL);
25837 
25838                 if (start_pktp == NULL) {
25839                         /* We were not given a SCSI packet, fail. */
25840                         return (EIO);
25841                 }
25842                 bzero(start_pktp->pkt_cdbp, CDB_GROUP0);
25843                 start_pktp->pkt_cdbp[0] = SCMD_START_STOP;
25844                 start_pktp->pkt_cdbp[4] = SD_TARGET_START;
25845                 start_pktp->pkt_flags = FLAG_NOINTR;
25846 
25847                 mutex_enter(SD_MUTEX(un));
25848                 SD_FILL_SCSI1_LUN(un, start_pktp);
25849                 mutex_exit(SD_MUTEX(un));
25850                 /*
25851                  * Scsi_poll returns 0 (success) if the command completes and
25852                  * the status block is STATUS_GOOD.
25853                  */
25854                 if (sd_scsi_poll(un, start_pktp) != 0) {
25855                         scsi_destroy_pkt(start_pktp);
25856                         return (EIO);
25857                 }
25858                 scsi_destroy_pkt(start_pktp);
25859                 (void) sd_pm_state_change(un, SD_PM_STATE_ACTIVE(un),
25860                     SD_PM_STATE_CHANGE);
25861         } else {
25862                 mutex_exit(&un->un_pm_mutex);
25863         }
25864 
25865         mutex_enter(SD_MUTEX(un));
25866         un->un_throttle = 0;
25867 
25868         /*
25869          * The first time through, reset the specific target device.
25870          * However, when cpr calls sddump we know that sd is in a
25871          * a good state so no bus reset is required.
25872          * Clear sense data via Request Sense cmd.
25873          * In sddump we don't care about allow_bus_device_reset anymore
25874          */
25875 
25876         if ((un->un_state != SD_STATE_SUSPENDED) &&
25877             (un->un_state != SD_STATE_DUMPING)) {
25878 
25879                 New_state(un, SD_STATE_DUMPING);
25880 
25881                 if (un->un_f_is_fibre == FALSE) {
25882                         mutex_exit(SD_MUTEX(un));
25883                         /*
25884                          * Attempt a bus reset for parallel scsi.
25885                          *
25886                          * Note: A bus reset is required because on some host
25887                          * systems (i.e. E420R) a bus device reset is
25888                          * insufficient to reset the state of the target.
25889                          *
25890                          * Note: Don't issue the reset for fibre-channel,
25891                          * because this tends to hang the bus (loop) for
25892                          * too long while everyone is logging out and in
25893                          * and the deadman timer for dumping will fire
25894                          * before the dump is complete.
25895                          */
25896                         if (scsi_reset(SD_ADDRESS(un), RESET_ALL) == 0) {
25897                                 mutex_enter(SD_MUTEX(un));
25898                                 Restore_state(un);
25899                                 mutex_exit(SD_MUTEX(un));
25900                                 return (EIO);
25901                         }
25902 
25903                         /* Delay to give the device some recovery time. */
25904                         drv_usecwait(10000);
25905 
25906                         if (sd_send_polled_RQS(un) == SD_FAILURE) {
25907                                 SD_INFO(SD_LOG_DUMP, un,
25908                                     "sddump: sd_send_polled_RQS failed\n");
25909                         }
25910                         mutex_enter(SD_MUTEX(un));
25911                 }
25912         }
25913 
25914         /*
25915          * Convert the partition-relative block number to a
25916          * disk physical block number.
25917          */
25918         if (NOT_DEVBSIZE(un)) {
25919                 blkno += start_block;
25920         } else {
25921                 blkno = blkno / (un->un_tgt_blocksize / DEV_BSIZE);
25922                 blkno += start_block;
25923         }
25924 
25925         SD_INFO(SD_LOG_DUMP, un, "sddump: disk blkno = 0x%x\n", blkno);
25926 
25927 
25928         /*
25929          * Check if the device has a non-512 block size.
25930          */
25931         wr_bp = NULL;
25932         if (NOT_DEVBSIZE(un)) {
25933                 tgt_byte_offset = blkno * un->un_sys_blocksize;
25934                 tgt_byte_count = nblk * un->un_sys_blocksize;
25935                 if ((tgt_byte_offset % un->un_tgt_blocksize) ||
25936                     (tgt_byte_count % un->un_tgt_blocksize)) {
25937                         doing_rmw = TRUE;
25938                         /*
25939                          * Calculate the block number and number of block
25940                          * in terms of the media block size.
25941                          */
25942                         tgt_blkno = tgt_byte_offset / un->un_tgt_blocksize;
25943                         tgt_nblk =
25944                             ((tgt_byte_offset + tgt_byte_count +
25945                             (un->un_tgt_blocksize - 1)) /
25946                             un->un_tgt_blocksize) - tgt_blkno;
25947 
25948                         /*
25949                          * Invoke the routine which is going to do read part
25950                          * of read-modify-write.
25951                          * Note that this routine returns a pointer to
25952                          * a valid bp in wr_bp.
25953                          */
25954                         err = sddump_do_read_of_rmw(un, tgt_blkno, tgt_nblk,
25955                             &wr_bp);
25956                         if (err) {
25957                                 mutex_exit(SD_MUTEX(un));
25958                                 return (err);
25959                         }
25960                         /*
25961                          * Offset is being calculated as -
25962                          * (original block # * system block size) -
25963                          * (new block # * target block size)
25964                          */
25965                         io_start_offset =
25966                             ((uint64_t)(blkno * un->un_sys_blocksize)) -
25967                             ((uint64_t)(tgt_blkno * un->un_tgt_blocksize));
25968 
25969                         ASSERT((io_start_offset >= 0) &&
25970                             (io_start_offset < un->un_tgt_blocksize));
25971                         /*
25972                          * Do the modify portion of read modify write.
25973                          */
25974                         bcopy(addr, &wr_bp->b_un.b_addr[io_start_offset],
25975                             (size_t)nblk * un->un_sys_blocksize);
25976                 } else {
25977                         doing_rmw = FALSE;
25978                         tgt_blkno = tgt_byte_offset / un->un_tgt_blocksize;
25979                         tgt_nblk = tgt_byte_count / un->un_tgt_blocksize;
25980                 }
25981 
25982                 /* Convert blkno and nblk to target blocks */
25983                 blkno = tgt_blkno;
25984                 nblk = tgt_nblk;
25985         } else {
25986                 wr_bp = &wr_buf;
25987                 bzero(wr_bp, sizeof (struct buf));
25988                 wr_bp->b_flags               = B_BUSY;
25989                 wr_bp->b_un.b_addr   = addr;
25990                 wr_bp->b_bcount              = nblk << DEV_BSHIFT;
25991                 wr_bp->b_resid               = 0;
25992         }
25993 
25994         mutex_exit(SD_MUTEX(un));
25995 
25996         /*
25997          * Obtain a SCSI packet for the write command.
25998          * It should be safe to call the allocator here without
25999          * worrying about being locked for DVMA mapping because
26000          * the address we're passed is already a DVMA mapping
26001          *
26002          * We are also not going to worry about semaphore ownership
26003          * in the dump buffer. Dumping is single threaded at present.
26004          */
26005 
26006         wr_pktp = NULL;
26007 
26008         dma_resid = wr_bp->b_bcount;
26009         oblkno = blkno;
26010 
26011         if (!(NOT_DEVBSIZE(un))) {
26012                 nblk = nblk / (un->un_tgt_blocksize / DEV_BSIZE);
26013         }
26014 
26015         while (dma_resid != 0) {
26016 
26017         for (i = 0; i < SD_NDUMP_RETRIES; i++) {
26018                 wr_bp->b_flags &= ~B_ERROR;
26019 
26020                 if (un->un_partial_dma_supported == 1) {
26021                         blkno = oblkno +
26022                             ((wr_bp->b_bcount - dma_resid) /
26023                             un->un_tgt_blocksize);
26024                         nblk = dma_resid / un->un_tgt_blocksize;
26025 
26026                         if (wr_pktp) {
26027                                 /*
26028                                  * Partial DMA transfers after initial transfer
26029                                  */
26030                                 rval = sd_setup_next_rw_pkt(un, wr_pktp, wr_bp,
26031                                     blkno, nblk);
26032                         } else {
26033                                 /* Initial transfer */
26034                                 rval = sd_setup_rw_pkt(un, &wr_pktp, wr_bp,
26035                                     un->un_pkt_flags, NULL_FUNC, NULL,
26036                                     blkno, nblk);
26037                         }
26038                 } else {
26039                         rval = sd_setup_rw_pkt(un, &wr_pktp, wr_bp,
26040                             0, NULL_FUNC, NULL, blkno, nblk);
26041                 }
26042 
26043                 if (rval == 0) {
26044                         /* We were given a SCSI packet, continue. */
26045                         break;
26046                 }
26047 
26048                 if (i == 0) {
26049                         if (wr_bp->b_flags & B_ERROR) {
26050                                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26051                                     "no resources for dumping; "
26052                                     "error code: 0x%x, retrying",
26053                                     geterror(wr_bp));
26054                         } else {
26055                                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26056                                     "no resources for dumping; retrying");
26057                         }
26058                 } else if (i != (SD_NDUMP_RETRIES - 1)) {
26059                         if (wr_bp->b_flags & B_ERROR) {
26060                                 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
26061                                     "no resources for dumping; error code: "
26062                                     "0x%x, retrying\n", geterror(wr_bp));
26063                         }
26064                 } else {
26065                         if (wr_bp->b_flags & B_ERROR) {
26066                                 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
26067                                     "no resources for dumping; "
26068                                     "error code: 0x%x, retries failed, "
26069                                     "giving up.\n", geterror(wr_bp));
26070                         } else {
26071                                 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT,
26072                                     "no resources for dumping; "
26073                                     "retries failed, giving up.\n");
26074                         }
26075                         mutex_enter(SD_MUTEX(un));
26076                         Restore_state(un);
26077                         if (NOT_DEVBSIZE(un) && (doing_rmw == TRUE)) {
26078                                 mutex_exit(SD_MUTEX(un));
26079                                 scsi_free_consistent_buf(wr_bp);
26080                         } else {
26081                                 mutex_exit(SD_MUTEX(un));
26082                         }
26083                         return (EIO);
26084                 }
26085                 drv_usecwait(10000);
26086         }
26087 
26088         if (un->un_partial_dma_supported == 1) {
26089                 /*
26090                  * save the resid from PARTIAL_DMA
26091                  */
26092                 dma_resid = wr_pktp->pkt_resid;
26093                 if (dma_resid != 0)
26094                         nblk -= SD_BYTES2TGTBLOCKS(un, dma_resid);
26095                 wr_pktp->pkt_resid = 0;
26096         } else {
26097                 dma_resid = 0;
26098         }
26099 
26100         /* SunBug 1222170 */
26101         wr_pktp->pkt_flags = FLAG_NOINTR;
26102 
26103         err = EIO;
26104         for (i = 0; i < SD_NDUMP_RETRIES; i++) {
26105 
26106                 /*
26107                  * Scsi_poll returns 0 (success) if the command completes and
26108                  * the status block is STATUS_GOOD.  We should only check
26109                  * errors if this condition is not true.  Even then we should
26110                  * send our own request sense packet only if we have a check
26111                  * condition and auto request sense has not been performed by
26112                  * the hba.
26113                  */
26114                 SD_TRACE(SD_LOG_DUMP, un, "sddump: sending write\n");
26115 
26116                 if ((sd_scsi_poll(un, wr_pktp) == 0) &&
26117                     (wr_pktp->pkt_resid == 0)) {
26118                         err = SD_SUCCESS;
26119                         break;
26120                 }
26121 
26122                 /*
26123                  * Check CMD_DEV_GONE 1st, give up if device is gone.
26124                  */
26125                 if (wr_pktp->pkt_reason == CMD_DEV_GONE) {
26126                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26127                             "Error while dumping state...Device is gone\n");
26128                         break;
26129                 }
26130 
26131                 if (SD_GET_PKT_STATUS(wr_pktp) == STATUS_CHECK) {
26132                         SD_INFO(SD_LOG_DUMP, un,
26133                             "sddump: write failed with CHECK, try # %d\n", i);
26134                         if (((wr_pktp->pkt_state & STATE_ARQ_DONE) == 0)) {
26135                                 (void) sd_send_polled_RQS(un);
26136                         }
26137 
26138                         continue;
26139                 }
26140 
26141                 if (SD_GET_PKT_STATUS(wr_pktp) == STATUS_BUSY) {
26142                         int reset_retval = 0;
26143 
26144                         SD_INFO(SD_LOG_DUMP, un,
26145                             "sddump: write failed with BUSY, try # %d\n", i);
26146 
26147                         if (un->un_f_lun_reset_enabled == TRUE) {
26148                                 reset_retval = scsi_reset(SD_ADDRESS(un),
26149                                     RESET_LUN);
26150                         }
26151                         if (reset_retval == 0) {
26152                                 (void) scsi_reset(SD_ADDRESS(un), RESET_TARGET);
26153                         }
26154                         (void) sd_send_polled_RQS(un);
26155 
26156                 } else {
26157                         SD_INFO(SD_LOG_DUMP, un,
26158                             "sddump: write failed with 0x%x, try # %d\n",
26159                             SD_GET_PKT_STATUS(wr_pktp), i);
26160                         mutex_enter(SD_MUTEX(un));
26161                         sd_reset_target(un, wr_pktp);
26162                         mutex_exit(SD_MUTEX(un));
26163                 }
26164 
26165                 /*
26166                  * If we are not getting anywhere with lun/target resets,
26167                  * let's reset the bus.
26168                  */
26169                 if (i == SD_NDUMP_RETRIES/2) {
26170                         (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
26171                         (void) sd_send_polled_RQS(un);
26172                 }
26173         }
26174         }
26175 
26176         scsi_destroy_pkt(wr_pktp);
26177         mutex_enter(SD_MUTEX(un));
26178         if ((NOT_DEVBSIZE(un)) && (doing_rmw == TRUE)) {
26179                 mutex_exit(SD_MUTEX(un));
26180                 scsi_free_consistent_buf(wr_bp);
26181         } else {
26182                 mutex_exit(SD_MUTEX(un));
26183         }
26184         SD_TRACE(SD_LOG_DUMP, un, "sddump: exit: err = %d\n", err);
26185         return (err);
26186 }
26187 
26188 /*
26189  *    Function: sd_scsi_poll()
26190  *
26191  * Description: This is a wrapper for the scsi_poll call.
26192  *
26193  *   Arguments: sd_lun - The unit structure
26194  *              scsi_pkt - The scsi packet being sent to the device.
26195  *
26196  * Return Code: 0 - Command completed successfully with good status
26197  *             -1 - Command failed.  This could indicate a check condition
26198  *                  or other status value requiring recovery action.
26199  *
26200  * NOTE: This code is only called off sddump().
26201  */
26202 
26203 static int
26204 sd_scsi_poll(struct sd_lun *un, struct scsi_pkt *pktp)
26205 {
26206         int status;
26207 
26208         ASSERT(un != NULL);
26209         ASSERT(!mutex_owned(SD_MUTEX(un)));
26210         ASSERT(pktp != NULL);
26211 
26212         status = SD_SUCCESS;
26213 
26214         if (scsi_ifgetcap(&pktp->pkt_address, "tagged-qing", 1) == 1) {
26215                 pktp->pkt_flags |= un->un_tagflags;
26216                 pktp->pkt_flags &= ~FLAG_NODISCON;
26217         }
26218 
26219         status = sd_ddi_scsi_poll(pktp);
26220         /*
26221          * Scsi_poll returns 0 (success) if the command completes and the
26222          * status block is STATUS_GOOD.  We should only check errors if this
26223          * condition is not true.  Even then we should send our own request
26224          * sense packet only if we have a check condition and auto
26225          * request sense has not been performed by the hba.
26226          * Don't get RQS data if pkt_reason is CMD_DEV_GONE.
26227          */
26228         if ((status != SD_SUCCESS) &&
26229             (SD_GET_PKT_STATUS(pktp) == STATUS_CHECK) &&
26230             (pktp->pkt_state & STATE_ARQ_DONE) == 0 &&
26231             (pktp->pkt_reason != CMD_DEV_GONE))
26232                 (void) sd_send_polled_RQS(un);
26233 
26234         return (status);
26235 }
26236 
26237 /*
26238  *    Function: sd_send_polled_RQS()
26239  *
26240  * Description: This sends the request sense command to a device.
26241  *
26242  *   Arguments: sd_lun - The unit structure
26243  *
26244  * Return Code: 0 - Command completed successfully with good status
26245  *             -1 - Command failed.
26246  *
26247  */
26248 
26249 static int
26250 sd_send_polled_RQS(struct sd_lun *un)
26251 {
26252         int     ret_val;
26253         struct  scsi_pkt        *rqs_pktp;
26254         struct  buf             *rqs_bp;
26255 
26256         ASSERT(un != NULL);
26257         ASSERT(!mutex_owned(SD_MUTEX(un)));
26258 
26259         ret_val = SD_SUCCESS;
26260 
26261         rqs_pktp = un->un_rqs_pktp;
26262         rqs_bp   = un->un_rqs_bp;
26263 
26264         mutex_enter(SD_MUTEX(un));
26265 
26266         if (un->un_sense_isbusy) {
26267                 ret_val = SD_FAILURE;
26268                 mutex_exit(SD_MUTEX(un));
26269                 return (ret_val);
26270         }
26271 
26272         /*
26273          * If the request sense buffer (and packet) is not in use,
26274          * let's set the un_sense_isbusy and send our packet
26275          */
26276         un->un_sense_isbusy  = 1;
26277         rqs_pktp->pkt_resid          = 0;
26278         rqs_pktp->pkt_reason         = 0;
26279         rqs_pktp->pkt_flags |= FLAG_NOINTR;
26280         bzero(rqs_bp->b_un.b_addr, SENSE_LENGTH);
26281 
26282         mutex_exit(SD_MUTEX(un));
26283 
26284         SD_INFO(SD_LOG_COMMON, un, "sd_send_polled_RQS: req sense buf at"
26285             " 0x%p\n", rqs_bp->b_un.b_addr);
26286 
26287         /*
26288          * Can't send this to sd_scsi_poll, we wrap ourselves around the
26289          * axle - it has a call into us!
26290          */
26291         if ((ret_val = sd_ddi_scsi_poll(rqs_pktp)) != 0) {
26292                 SD_INFO(SD_LOG_COMMON, un,
26293                     "sd_send_polled_RQS: RQS failed\n");
26294         }
26295 
26296         SD_DUMP_MEMORY(un, SD_LOG_COMMON, "sd_send_polled_RQS:",
26297             (uchar_t *)rqs_bp->b_un.b_addr, SENSE_LENGTH, SD_LOG_HEX);
26298 
26299         mutex_enter(SD_MUTEX(un));
26300         un->un_sense_isbusy = 0;
26301         mutex_exit(SD_MUTEX(un));
26302 
26303         return (ret_val);
26304 }
26305 
26306 /*
26307  * Defines needed for localized version of the scsi_poll routine.
26308  */
26309 #define CSEC            10000                   /* usecs */
26310 #define SEC_TO_CSEC     (1000000/CSEC)
26311 
26312 /*
26313  *    Function: sd_ddi_scsi_poll()
26314  *
26315  * Description: Localized version of the scsi_poll routine.  The purpose is to
26316  *              send a scsi_pkt to a device as a polled command.  This version
26317  *              is to ensure more robust handling of transport errors.
26318  *              Specifically this routine cures not ready, coming ready
26319  *              transition for power up and reset of sonoma's.  This can take
26320  *              up to 45 seconds for power-on and 20 seconds for reset of a
26321  *              sonoma lun.
26322  *
26323  *   Arguments: scsi_pkt - The scsi_pkt being sent to a device
26324  *
26325  * Return Code: 0 - Command completed successfully with good status
26326  *             -1 - Command failed.
26327  *
26328  * NOTE: This code is almost identical to scsi_poll, however before 6668774 can
26329  * be fixed (removing this code), we need to determine how to handle the
26330  * KEY_UNIT_ATTENTION condition below in conditions not as limited as sddump().
26331  *
26332  * NOTE: This code is only called off sddump().
26333  */
26334 static int
26335 sd_ddi_scsi_poll(struct scsi_pkt *pkt)
26336 {
26337         int                     rval = -1;
26338         int                     savef;
26339         long                    savet;
26340         void                    (*savec)();
26341         int                     timeout;
26342         int                     busy_count;
26343         int                     poll_delay;
26344         int                     rc;
26345         uint8_t                 *sensep;
26346         struct scsi_arq_status  *arqstat;
26347         extern int              do_polled_io;
26348 
26349         ASSERT(pkt->pkt_scbp);
26350 
26351         /*
26352          * save old flags..
26353          */
26354         savef = pkt->pkt_flags;
26355         savec = pkt->pkt_comp;
26356         savet = pkt->pkt_time;
26357 
26358         pkt->pkt_flags |= FLAG_NOINTR;
26359 
26360         /*
26361          * XXX there is nothing in the SCSA spec that states that we should not
26362          * do a callback for polled cmds; however, removing this will break sd
26363          * and probably other target drivers
26364          */
26365         pkt->pkt_comp = NULL;
26366 
26367         /*
26368          * we don't like a polled command without timeout.
26369          * 60 seconds seems long enough.
26370          */
26371         if (pkt->pkt_time == 0)
26372                 pkt->pkt_time = SCSI_POLL_TIMEOUT;
26373 
26374         /*
26375          * Send polled cmd.
26376          *
26377          * We do some error recovery for various errors.  Tran_busy,
26378          * queue full, and non-dispatched commands are retried every 10 msec.
26379          * as they are typically transient failures.  Busy status and Not
26380          * Ready are retried every second as this status takes a while to
26381          * change.
26382          */
26383         timeout = pkt->pkt_time * SEC_TO_CSEC;
26384 
26385         for (busy_count = 0; busy_count < timeout; busy_count++) {
26386                 /*
26387                  * Initialize pkt status variables.
26388                  */
26389                 *pkt->pkt_scbp = pkt->pkt_reason = pkt->pkt_state = 0;
26390 
26391                 if ((rc = scsi_transport(pkt)) != TRAN_ACCEPT) {
26392                         if (rc != TRAN_BUSY) {
26393                                 /* Transport failed - give up. */
26394                                 break;
26395                         } else {
26396                                 /* Transport busy - try again. */
26397                                 poll_delay = 1 * CSEC;          /* 10 msec. */
26398                         }
26399                 } else {
26400                         /*
26401                          * Transport accepted - check pkt status.
26402                          */
26403                         rc = (*pkt->pkt_scbp) & STATUS_MASK;
26404                         if ((pkt->pkt_reason == CMD_CMPLT) &&
26405                             (rc == STATUS_CHECK) &&
26406                             (pkt->pkt_state & STATE_ARQ_DONE)) {
26407                                 arqstat =
26408                                     (struct scsi_arq_status *)(pkt->pkt_scbp);
26409                                 sensep = (uint8_t *)&arqstat->sts_sensedata;
26410                         } else {
26411                                 sensep = NULL;
26412                         }
26413 
26414                         if ((pkt->pkt_reason == CMD_CMPLT) &&
26415                             (rc == STATUS_GOOD)) {
26416                                 /* No error - we're done */
26417                                 rval = 0;
26418                                 break;
26419 
26420                         } else if (pkt->pkt_reason == CMD_DEV_GONE) {
26421                                 /* Lost connection - give up */
26422                                 break;
26423 
26424                         } else if ((pkt->pkt_reason == CMD_INCOMPLETE) &&
26425                             (pkt->pkt_state == 0)) {
26426                                 /* Pkt not dispatched - try again. */
26427                                 poll_delay = 1 * CSEC;          /* 10 msec. */
26428 
26429                         } else if ((pkt->pkt_reason == CMD_CMPLT) &&
26430                             (rc == STATUS_QFULL)) {
26431                                 /* Queue full - try again. */
26432                                 poll_delay = 1 * CSEC;          /* 10 msec. */
26433 
26434                         } else if ((pkt->pkt_reason == CMD_CMPLT) &&
26435                             (rc == STATUS_BUSY)) {
26436                                 /* Busy - try again. */
26437                                 poll_delay = 100 * CSEC;        /* 1 sec. */
26438                                 busy_count += (SEC_TO_CSEC - 1);
26439 
26440                         } else if ((sensep != NULL) &&
26441                             (scsi_sense_key(sensep) == KEY_UNIT_ATTENTION)) {
26442                                 /*
26443                                  * Unit Attention - try again.
26444                                  * Pretend it took 1 sec.
26445                                  * NOTE: 'continue' avoids poll_delay
26446                                  */
26447                                 busy_count += (SEC_TO_CSEC - 1);
26448                                 continue;
26449 
26450                         } else if ((sensep != NULL) &&
26451                             (scsi_sense_key(sensep) == KEY_NOT_READY) &&
26452                             (scsi_sense_asc(sensep) == 0x04) &&
26453                             (scsi_sense_ascq(sensep) == 0x01)) {
26454                                 /*
26455                                  * Not ready -> ready - try again.
26456                                  * 04h/01h: LUN IS IN PROCESS OF BECOMING READY
26457                                  * ...same as STATUS_BUSY
26458                                  */
26459                                 poll_delay = 100 * CSEC;        /* 1 sec. */
26460                                 busy_count += (SEC_TO_CSEC - 1);
26461 
26462                         } else {
26463                                 /* BAD status - give up. */
26464                                 break;
26465                         }
26466                 }
26467 
26468                 if (((curthread->t_flag & T_INTR_THREAD) == 0) &&
26469                     !do_polled_io) {
26470                         delay(drv_usectohz(poll_delay));
26471                 } else {
26472                         /* we busy wait during cpr_dump or interrupt threads */
26473                         drv_usecwait(poll_delay);
26474                 }
26475         }
26476 
26477         pkt->pkt_flags = savef;
26478         pkt->pkt_comp = savec;
26479         pkt->pkt_time = savet;
26480 
26481         /* return on error */
26482         if (rval)
26483                 return (rval);
26484 
26485         /*
26486          * This is not a performance critical code path.
26487          *
26488          * As an accommodation for scsi_poll callers, to avoid ddi_dma_sync()
26489          * issues associated with looking at DMA memory prior to
26490          * scsi_pkt_destroy(), we scsi_sync_pkt() prior to return.
26491          */
26492         scsi_sync_pkt(pkt);
26493         return (0);
26494 }
26495 
26496 
26497 
26498 /*
26499  *    Function: sd_persistent_reservation_in_read_keys
26500  *
26501  * Description: This routine is the driver entry point for handling CD-ROM
26502  *              multi-host persistent reservation requests (MHIOCGRP_INKEYS)
26503  *              by sending the SCSI-3 PRIN commands to the device.
26504  *              Processes the read keys command response by copying the
26505  *              reservation key information into the user provided buffer.
26506  *              Support for the 32/64 bit _MULTI_DATAMODEL is implemented.
26507  *
26508  *   Arguments: un   -  Pointer to soft state struct for the target.
26509  *              usrp -  user provided pointer to multihost Persistent In Read
26510  *                      Keys structure (mhioc_inkeys_t)
26511  *              flag -  this argument is a pass through to ddi_copyxxx()
26512  *                      directly from the mode argument of ioctl().
26513  *
26514  * Return Code: 0   - Success
26515  *              EACCES
26516  *              ENOTSUP
26517  *              errno return code from sd_send_scsi_cmd()
26518  *
26519  *     Context: Can sleep. Does not return until command is completed.
26520  */
26521 
26522 static int
26523 sd_persistent_reservation_in_read_keys(struct sd_lun *un,
26524     mhioc_inkeys_t *usrp, int flag)
26525 {
26526 #ifdef _MULTI_DATAMODEL
26527         struct mhioc_key_list32 li32;
26528 #endif
26529         sd_prin_readkeys_t      *in;
26530         mhioc_inkeys_t          *ptr;
26531         mhioc_key_list_t        li;
26532         uchar_t                 *data_bufp;
26533         int                     data_len;
26534         int                     rval = 0;
26535         size_t                  copysz;
26536         sd_ssc_t                *ssc;
26537 
26538         if ((ptr = (mhioc_inkeys_t *)usrp) == NULL) {
26539                 return (EINVAL);
26540         }
26541         bzero(&li, sizeof (mhioc_key_list_t));
26542 
26543         ssc = sd_ssc_init(un);
26544 
26545         /*
26546          * Get the listsize from user
26547          */
26548 #ifdef _MULTI_DATAMODEL
26549 
26550         switch (ddi_model_convert_from(flag & FMODELS)) {
26551         case DDI_MODEL_ILP32:
26552                 copysz = sizeof (struct mhioc_key_list32);
26553                 if (ddi_copyin(ptr->li, &li32, copysz, flag)) {
26554                         SD_ERROR(SD_LOG_IOCTL_MHD, un,
26555                             "sd_persistent_reservation_in_read_keys: "
26556                             "failed ddi_copyin: mhioc_key_list32_t\n");
26557                         rval = EFAULT;
26558                         goto done;
26559                 }
26560                 li.listsize = li32.listsize;
26561                 li.list = (mhioc_resv_key_t *)(uintptr_t)li32.list;
26562                 break;
26563 
26564         case DDI_MODEL_NONE:
26565                 copysz = sizeof (mhioc_key_list_t);
26566                 if (ddi_copyin(ptr->li, &li, copysz, flag)) {
26567                         SD_ERROR(SD_LOG_IOCTL_MHD, un,
26568                             "sd_persistent_reservation_in_read_keys: "
26569                             "failed ddi_copyin: mhioc_key_list_t\n");
26570                         rval = EFAULT;
26571                         goto done;
26572                 }
26573                 break;
26574         }
26575 
26576 #else /* ! _MULTI_DATAMODEL */
26577         copysz = sizeof (mhioc_key_list_t);
26578         if (ddi_copyin(ptr->li, &li, copysz, flag)) {
26579                 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26580                     "sd_persistent_reservation_in_read_keys: "
26581                     "failed ddi_copyin: mhioc_key_list_t\n");
26582                 rval = EFAULT;
26583                 goto done;
26584         }
26585 #endif
26586 
26587         data_len  = li.listsize * MHIOC_RESV_KEY_SIZE;
26588         data_len += (sizeof (sd_prin_readkeys_t) - sizeof (caddr_t));
26589         data_bufp = kmem_zalloc(data_len, KM_SLEEP);
26590 
26591         rval = sd_send_scsi_PERSISTENT_RESERVE_IN(ssc, SD_READ_KEYS,
26592             data_len, data_bufp);
26593         if (rval != 0) {
26594                 if (rval == EIO)
26595                         sd_ssc_assessment(ssc, SD_FMT_IGNORE_COMPROMISE);
26596                 else
26597                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
26598                 goto done;
26599         }
26600         in = (sd_prin_readkeys_t *)data_bufp;
26601         ptr->generation = BE_32(in->generation);
26602         li.listlen = BE_32(in->len) / MHIOC_RESV_KEY_SIZE;
26603 
26604         /*
26605          * Return the min(listsize, listlen) keys
26606          */
26607 #ifdef _MULTI_DATAMODEL
26608 
26609         switch (ddi_model_convert_from(flag & FMODELS)) {
26610         case DDI_MODEL_ILP32:
26611                 li32.listlen = li.listlen;
26612                 if (ddi_copyout(&li32, ptr->li, copysz, flag)) {
26613                         SD_ERROR(SD_LOG_IOCTL_MHD, un,
26614                             "sd_persistent_reservation_in_read_keys: "
26615                             "failed ddi_copyout: mhioc_key_list32_t\n");
26616                         rval = EFAULT;
26617                         goto done;
26618                 }
26619                 break;
26620 
26621         case DDI_MODEL_NONE:
26622                 if (ddi_copyout(&li, ptr->li, copysz, flag)) {
26623                         SD_ERROR(SD_LOG_IOCTL_MHD, un,
26624                             "sd_persistent_reservation_in_read_keys: "
26625                             "failed ddi_copyout: mhioc_key_list_t\n");
26626                         rval = EFAULT;
26627                         goto done;
26628                 }
26629                 break;
26630         }
26631 
26632 #else /* ! _MULTI_DATAMODEL */
26633 
26634         if (ddi_copyout(&li, ptr->li, copysz, flag)) {
26635                 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26636                     "sd_persistent_reservation_in_read_keys: "
26637                     "failed ddi_copyout: mhioc_key_list_t\n");
26638                 rval = EFAULT;
26639                 goto done;
26640         }
26641 
26642 #endif /* _MULTI_DATAMODEL */
26643 
26644         copysz = min(li.listlen * MHIOC_RESV_KEY_SIZE,
26645             li.listsize * MHIOC_RESV_KEY_SIZE);
26646         if (ddi_copyout(&in->keylist, li.list, copysz, flag)) {
26647                 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26648                     "sd_persistent_reservation_in_read_keys: "
26649                     "failed ddi_copyout: keylist\n");
26650                 rval = EFAULT;
26651         }
26652 done:
26653         sd_ssc_fini(ssc);
26654         kmem_free(data_bufp, data_len);
26655         return (rval);
26656 }
26657 
26658 
26659 /*
26660  *    Function: sd_persistent_reservation_in_read_resv
26661  *
26662  * Description: This routine is the driver entry point for handling CD-ROM
26663  *              multi-host persistent reservation requests (MHIOCGRP_INRESV)
26664  *              by sending the SCSI-3 PRIN commands to the device.
26665  *              Process the read persistent reservations command response by
26666  *              copying the reservation information into the user provided
26667  *              buffer. Support for the 32/64 _MULTI_DATAMODEL is implemented.
26668  *
26669  *   Arguments: un   -  Pointer to soft state struct for the target.
26670  *              usrp -  user provided pointer to multihost Persistent In Read
26671  *                      Keys structure (mhioc_inkeys_t)
26672  *              flag -  this argument is a pass through to ddi_copyxxx()
26673  *                      directly from the mode argument of ioctl().
26674  *
26675  * Return Code: 0   - Success
26676  *              EACCES
26677  *              ENOTSUP
26678  *              errno return code from sd_send_scsi_cmd()
26679  *
26680  *     Context: Can sleep. Does not return until command is completed.
26681  */
26682 
26683 static int
26684 sd_persistent_reservation_in_read_resv(struct sd_lun *un,
26685     mhioc_inresvs_t *usrp, int flag)
26686 {
26687 #ifdef _MULTI_DATAMODEL
26688         struct mhioc_resv_desc_list32 resvlist32;
26689 #endif
26690         sd_prin_readresv_t      *in;
26691         mhioc_inresvs_t         *ptr;
26692         sd_readresv_desc_t      *readresv_ptr;
26693         mhioc_resv_desc_list_t  resvlist;
26694         mhioc_resv_desc_t       resvdesc;
26695         uchar_t                 *data_bufp = NULL;
26696         int                     data_len;
26697         int                     rval = 0;
26698         int                     i;
26699         size_t                  copysz;
26700         mhioc_resv_desc_t       *bufp;
26701         sd_ssc_t                *ssc;
26702 
26703         if ((ptr = usrp) == NULL) {
26704                 return (EINVAL);
26705         }
26706 
26707         ssc = sd_ssc_init(un);
26708 
26709         /*
26710          * Get the listsize from user
26711          */
26712 #ifdef _MULTI_DATAMODEL
26713         switch (ddi_model_convert_from(flag & FMODELS)) {
26714         case DDI_MODEL_ILP32:
26715                 copysz = sizeof (struct mhioc_resv_desc_list32);
26716                 if (ddi_copyin(ptr->li, &resvlist32, copysz, flag)) {
26717                         SD_ERROR(SD_LOG_IOCTL_MHD, un,
26718                             "sd_persistent_reservation_in_read_resv: "
26719                             "failed ddi_copyin: mhioc_resv_desc_list_t\n");
26720                         rval = EFAULT;
26721                         goto done;
26722                 }
26723                 resvlist.listsize = resvlist32.listsize;
26724                 resvlist.list = (mhioc_resv_desc_t *)(uintptr_t)resvlist32.list;
26725                 break;
26726 
26727         case DDI_MODEL_NONE:
26728                 copysz = sizeof (mhioc_resv_desc_list_t);
26729                 if (ddi_copyin(ptr->li, &resvlist, copysz, flag)) {
26730                         SD_ERROR(SD_LOG_IOCTL_MHD, un,
26731                             "sd_persistent_reservation_in_read_resv: "
26732                             "failed ddi_copyin: mhioc_resv_desc_list_t\n");
26733                         rval = EFAULT;
26734                         goto done;
26735                 }
26736                 break;
26737         }
26738 #else /* ! _MULTI_DATAMODEL */
26739         copysz = sizeof (mhioc_resv_desc_list_t);
26740         if (ddi_copyin(ptr->li, &resvlist, copysz, flag)) {
26741                 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26742                     "sd_persistent_reservation_in_read_resv: "
26743                     "failed ddi_copyin: mhioc_resv_desc_list_t\n");
26744                 rval = EFAULT;
26745                 goto done;
26746         }
26747 #endif /* ! _MULTI_DATAMODEL */
26748 
26749         data_len  = resvlist.listsize * SCSI3_RESV_DESC_LEN;
26750         data_len += (sizeof (sd_prin_readresv_t) - sizeof (caddr_t));
26751         data_bufp = kmem_zalloc(data_len, KM_SLEEP);
26752 
26753         rval = sd_send_scsi_PERSISTENT_RESERVE_IN(ssc, SD_READ_RESV,
26754             data_len, data_bufp);
26755         if (rval != 0) {
26756                 if (rval == EIO)
26757                         sd_ssc_assessment(ssc, SD_FMT_IGNORE_COMPROMISE);
26758                 else
26759                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
26760                 goto done;
26761         }
26762         in = (sd_prin_readresv_t *)data_bufp;
26763         ptr->generation = BE_32(in->generation);
26764         resvlist.listlen = BE_32(in->len) / SCSI3_RESV_DESC_LEN;
26765 
26766         /*
26767          * Return the min(listsize, listlen( keys
26768          */
26769 #ifdef _MULTI_DATAMODEL
26770 
26771         switch (ddi_model_convert_from(flag & FMODELS)) {
26772         case DDI_MODEL_ILP32:
26773                 resvlist32.listlen = resvlist.listlen;
26774                 if (ddi_copyout(&resvlist32, ptr->li, copysz, flag)) {
26775                         SD_ERROR(SD_LOG_IOCTL_MHD, un,
26776                             "sd_persistent_reservation_in_read_resv: "
26777                             "failed ddi_copyout: mhioc_resv_desc_list_t\n");
26778                         rval = EFAULT;
26779                         goto done;
26780                 }
26781                 break;
26782 
26783         case DDI_MODEL_NONE:
26784                 if (ddi_copyout(&resvlist, ptr->li, copysz, flag)) {
26785                         SD_ERROR(SD_LOG_IOCTL_MHD, un,
26786                             "sd_persistent_reservation_in_read_resv: "
26787                             "failed ddi_copyout: mhioc_resv_desc_list_t\n");
26788                         rval = EFAULT;
26789                         goto done;
26790                 }
26791                 break;
26792         }
26793 
26794 #else /* ! _MULTI_DATAMODEL */
26795 
26796         if (ddi_copyout(&resvlist, ptr->li, copysz, flag)) {
26797                 SD_ERROR(SD_LOG_IOCTL_MHD, un,
26798                     "sd_persistent_reservation_in_read_resv: "
26799                     "failed ddi_copyout: mhioc_resv_desc_list_t\n");
26800                 rval = EFAULT;
26801                 goto done;
26802         }
26803 
26804 #endif /* ! _MULTI_DATAMODEL */
26805 
26806         readresv_ptr = (sd_readresv_desc_t *)&in->readresv_desc;
26807         bufp = resvlist.list;
26808         copysz = sizeof (mhioc_resv_desc_t);
26809         for (i = 0; i < min(resvlist.listlen, resvlist.listsize);
26810             i++, readresv_ptr++, bufp++) {
26811 
26812                 bcopy(&readresv_ptr->resvkey, &resvdesc.key,
26813                     MHIOC_RESV_KEY_SIZE);
26814                 resvdesc.type  = readresv_ptr->type;
26815                 resvdesc.scope = readresv_ptr->scope;
26816                 resvdesc.scope_specific_addr =
26817                     BE_32(readresv_ptr->scope_specific_addr);
26818 
26819                 if (ddi_copyout(&resvdesc, bufp, copysz, flag)) {
26820                         SD_ERROR(SD_LOG_IOCTL_MHD, un,
26821                             "sd_persistent_reservation_in_read_resv: "
26822                             "failed ddi_copyout: resvlist\n");
26823                         rval = EFAULT;
26824                         goto done;
26825                 }
26826         }
26827 done:
26828         sd_ssc_fini(ssc);
26829         /* only if data_bufp is allocated, we need to free it */
26830         if (data_bufp) {
26831                 kmem_free(data_bufp, data_len);
26832         }
26833         return (rval);
26834 }
26835 
26836 
26837 /*
26838  *    Function: sr_change_blkmode()
26839  *
26840  * Description: This routine is the driver entry point for handling CD-ROM
26841  *              block mode ioctl requests. Support for returning and changing
26842  *              the current block size in use by the device is implemented. The
26843  *              LBA size is changed via a MODE SELECT Block Descriptor.
26844  *
26845  *              This routine issues a mode sense with an allocation length of
26846  *              12 bytes for the mode page header and a single block descriptor.
26847  *
26848  *   Arguments: dev - the device 'dev_t'
26849  *              cmd - the request type; one of CDROMGBLKMODE (get) or
26850  *                    CDROMSBLKMODE (set)
26851  *              data - current block size or requested block size
26852  *              flag - this argument is a pass through to ddi_copyxxx() directly
26853  *                     from the mode argument of ioctl().
26854  *
26855  * Return Code: the code returned by sd_send_scsi_cmd()
26856  *              EINVAL if invalid arguments are provided
26857  *              EFAULT if ddi_copyxxx() fails
26858  *              ENXIO if fail ddi_get_soft_state
26859  *              EIO if invalid mode sense block descriptor length
26860  *
26861  */
26862 
26863 static int
26864 sr_change_blkmode(dev_t dev, int cmd, intptr_t data, int flag)
26865 {
26866         struct sd_lun                   *un = NULL;
26867         struct mode_header              *sense_mhp, *select_mhp;
26868         struct block_descriptor         *sense_desc, *select_desc;
26869         int                             current_bsize;
26870         int                             rval = EINVAL;
26871         uchar_t                         *sense = NULL;
26872         uchar_t                         *select = NULL;
26873         sd_ssc_t                        *ssc;
26874 
26875         ASSERT((cmd == CDROMGBLKMODE) || (cmd == CDROMSBLKMODE));
26876 
26877         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
26878                 return (ENXIO);
26879         }
26880 
26881         /*
26882          * The block length is changed via the Mode Select block descriptor, the
26883          * "Read/Write Error Recovery" mode page (0x1) contents are not actually
26884          * required as part of this routine. Therefore the mode sense allocation
26885          * length is specified to be the length of a mode page header and a
26886          * block descriptor.
26887          */
26888         sense = kmem_zalloc(BUFLEN_CHG_BLK_MODE, KM_SLEEP);
26889 
26890         ssc = sd_ssc_init(un);
26891         rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, sense,
26892             BUFLEN_CHG_BLK_MODE, MODEPAGE_ERR_RECOV, SD_PATH_STANDARD);
26893         sd_ssc_fini(ssc);
26894         if (rval != 0) {
26895                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26896                     "sr_change_blkmode: Mode Sense Failed\n");
26897                 kmem_free(sense, BUFLEN_CHG_BLK_MODE);
26898                 return (rval);
26899         }
26900 
26901         /* Check the block descriptor len to handle only 1 block descriptor */
26902         sense_mhp = (struct mode_header *)sense;
26903         if ((sense_mhp->bdesc_length == 0) ||
26904             (sense_mhp->bdesc_length > MODE_BLK_DESC_LENGTH)) {
26905                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26906                     "sr_change_blkmode: Mode Sense returned invalid block"
26907                     " descriptor length\n");
26908                 kmem_free(sense, BUFLEN_CHG_BLK_MODE);
26909                 return (EIO);
26910         }
26911         sense_desc = (struct block_descriptor *)(sense + MODE_HEADER_LENGTH);
26912         current_bsize = ((sense_desc->blksize_hi << 16) |
26913             (sense_desc->blksize_mid << 8) | sense_desc->blksize_lo);
26914 
26915         /* Process command */
26916         switch (cmd) {
26917         case CDROMGBLKMODE:
26918                 /* Return the block size obtained during the mode sense */
26919                 if (ddi_copyout(&current_bsize, (void *)data,
26920                     sizeof (int), flag) != 0)
26921                         rval = EFAULT;
26922                 break;
26923         case CDROMSBLKMODE:
26924                 /* Validate the requested block size */
26925                 switch (data) {
26926                 case CDROM_BLK_512:
26927                 case CDROM_BLK_1024:
26928                 case CDROM_BLK_2048:
26929                 case CDROM_BLK_2056:
26930                 case CDROM_BLK_2336:
26931                 case CDROM_BLK_2340:
26932                 case CDROM_BLK_2352:
26933                 case CDROM_BLK_2368:
26934                 case CDROM_BLK_2448:
26935                 case CDROM_BLK_2646:
26936                 case CDROM_BLK_2647:
26937                         break;
26938                 default:
26939                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26940                             "sr_change_blkmode: "
26941                             "Block Size '%ld' Not Supported\n", data);
26942                         kmem_free(sense, BUFLEN_CHG_BLK_MODE);
26943                         return (EINVAL);
26944                 }
26945 
26946                 /*
26947                  * The current block size matches the requested block size so
26948                  * there is no need to send the mode select to change the size
26949                  */
26950                 if (current_bsize == data) {
26951                         break;
26952                 }
26953 
26954                 /* Build the select data for the requested block size */
26955                 select = kmem_zalloc(BUFLEN_CHG_BLK_MODE, KM_SLEEP);
26956                 select_mhp = (struct mode_header *)select;
26957                 select_desc =
26958                     (struct block_descriptor *)(select + MODE_HEADER_LENGTH);
26959                 /*
26960                  * The LBA size is changed via the block descriptor, so the
26961                  * descriptor is built according to the user data
26962                  */
26963                 select_mhp->bdesc_length = MODE_BLK_DESC_LENGTH;
26964                 select_desc->blksize_hi  = (char)(((data) & 0x00ff0000) >> 16);
26965                 select_desc->blksize_mid = (char)(((data) & 0x0000ff00) >> 8);
26966                 select_desc->blksize_lo  = (char)((data) & 0x000000ff);
26967 
26968                 /* Send the mode select for the requested block size */
26969                 ssc = sd_ssc_init(un);
26970                 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0,
26971                     select, BUFLEN_CHG_BLK_MODE, SD_DONTSAVE_PAGE,
26972                     SD_PATH_STANDARD);
26973                 sd_ssc_fini(ssc);
26974                 if (rval != 0) {
26975                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
26976                             "sr_change_blkmode: Mode Select Failed\n");
26977                         /*
26978                          * The mode select failed for the requested block size,
26979                          * so reset the data for the original block size and
26980                          * send it to the target. The error is indicated by the
26981                          * return value for the failed mode select.
26982                          */
26983                         select_desc->blksize_hi  = sense_desc->blksize_hi;
26984                         select_desc->blksize_mid = sense_desc->blksize_mid;
26985                         select_desc->blksize_lo  = sense_desc->blksize_lo;
26986                         ssc = sd_ssc_init(un);
26987                         (void) sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0,
26988                             select, BUFLEN_CHG_BLK_MODE, SD_DONTSAVE_PAGE,
26989                             SD_PATH_STANDARD);
26990                         sd_ssc_fini(ssc);
26991                 } else {
26992                         ASSERT(!mutex_owned(SD_MUTEX(un)));
26993                         mutex_enter(SD_MUTEX(un));
26994                         sd_update_block_info(un, (uint32_t)data, 0);
26995                         mutex_exit(SD_MUTEX(un));
26996                 }
26997                 break;
26998         default:
26999                 /* should not reach here, but check anyway */
27000                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27001                     "sr_change_blkmode: Command '%x' Not Supported\n", cmd);
27002                 rval = EINVAL;
27003                 break;
27004         }
27005 
27006         if (select) {
27007                 kmem_free(select, BUFLEN_CHG_BLK_MODE);
27008         }
27009         if (sense) {
27010                 kmem_free(sense, BUFLEN_CHG_BLK_MODE);
27011         }
27012         return (rval);
27013 }
27014 
27015 
27016 /*
27017  * Note: The following sr_change_speed() and sr_atapi_change_speed() routines
27018  * implement driver support for getting and setting the CD speed. The command
27019  * set used will be based on the device type. If the device has not been
27020  * identified as MMC the Toshiba vendor specific mode page will be used. If
27021  * the device is MMC but does not support the Real Time Streaming feature
27022  * the SET CD SPEED command will be used to set speed and mode page 0x2A will
27023  * be used to read the speed.
27024  */
27025 
27026 /*
27027  *    Function: sr_change_speed()
27028  *
27029  * Description: This routine is the driver entry point for handling CD-ROM
27030  *              drive speed ioctl requests for devices supporting the Toshiba
27031  *              vendor specific drive speed mode page. Support for returning
27032  *              and changing the current drive speed in use by the device is
27033  *              implemented.
27034  *
27035  *   Arguments: dev - the device 'dev_t'
27036  *              cmd - the request type; one of CDROMGDRVSPEED (get) or
27037  *                    CDROMSDRVSPEED (set)
27038  *              data - current drive speed or requested drive speed
27039  *              flag - this argument is a pass through to ddi_copyxxx() directly
27040  *                     from the mode argument of ioctl().
27041  *
27042  * Return Code: the code returned by sd_send_scsi_cmd()
27043  *              EINVAL if invalid arguments are provided
27044  *              EFAULT if ddi_copyxxx() fails
27045  *              ENXIO if fail ddi_get_soft_state
27046  *              EIO if invalid mode sense block descriptor length
27047  */
27048 
27049 static int
27050 sr_change_speed(dev_t dev, int cmd, intptr_t data, int flag)
27051 {
27052         struct sd_lun                   *un = NULL;
27053         struct mode_header              *sense_mhp, *select_mhp;
27054         struct mode_speed               *sense_page, *select_page;
27055         int                             current_speed;
27056         int                             rval = EINVAL;
27057         int                             bd_len;
27058         uchar_t                         *sense = NULL;
27059         uchar_t                         *select = NULL;
27060         sd_ssc_t                        *ssc;
27061 
27062         ASSERT((cmd == CDROMGDRVSPEED) || (cmd == CDROMSDRVSPEED));
27063         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27064                 return (ENXIO);
27065         }
27066 
27067         /*
27068          * Note: The drive speed is being modified here according to a Toshiba
27069          * vendor specific mode page (0x31).
27070          */
27071         sense = kmem_zalloc(BUFLEN_MODE_CDROM_SPEED, KM_SLEEP);
27072 
27073         ssc = sd_ssc_init(un);
27074         rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, sense,
27075             BUFLEN_MODE_CDROM_SPEED, CDROM_MODE_SPEED,
27076             SD_PATH_STANDARD);
27077         sd_ssc_fini(ssc);
27078         if (rval != 0) {
27079                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27080                     "sr_change_speed: Mode Sense Failed\n");
27081                 kmem_free(sense, BUFLEN_MODE_CDROM_SPEED);
27082                 return (rval);
27083         }
27084         sense_mhp  = (struct mode_header *)sense;
27085 
27086         /* Check the block descriptor len to handle only 1 block descriptor */
27087         bd_len = sense_mhp->bdesc_length;
27088         if (bd_len > MODE_BLK_DESC_LENGTH) {
27089                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27090                     "sr_change_speed: Mode Sense returned invalid block "
27091                     "descriptor length\n");
27092                 kmem_free(sense, BUFLEN_MODE_CDROM_SPEED);
27093                 return (EIO);
27094         }
27095 
27096         sense_page = (struct mode_speed *)
27097             (sense + MODE_HEADER_LENGTH + sense_mhp->bdesc_length);
27098         current_speed = sense_page->speed;
27099 
27100         /* Process command */
27101         switch (cmd) {
27102         case CDROMGDRVSPEED:
27103                 /* Return the drive speed obtained during the mode sense */
27104                 if (current_speed == 0x2) {
27105                         current_speed = CDROM_TWELVE_SPEED;
27106                 }
27107                 if (ddi_copyout(&current_speed, (void *)data,
27108                     sizeof (int), flag) != 0) {
27109                         rval = EFAULT;
27110                 }
27111                 break;
27112         case CDROMSDRVSPEED:
27113                 /* Validate the requested drive speed */
27114                 switch ((uchar_t)data) {
27115                 case CDROM_TWELVE_SPEED:
27116                         data = 0x2;
27117                         /*FALLTHROUGH*/
27118                 case CDROM_NORMAL_SPEED:
27119                 case CDROM_DOUBLE_SPEED:
27120                 case CDROM_QUAD_SPEED:
27121                 case CDROM_MAXIMUM_SPEED:
27122                         break;
27123                 default:
27124                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27125                             "sr_change_speed: "
27126                             "Drive Speed '%d' Not Supported\n", (uchar_t)data);
27127                         kmem_free(sense, BUFLEN_MODE_CDROM_SPEED);
27128                         return (EINVAL);
27129                 }
27130 
27131                 /*
27132                  * The current drive speed matches the requested drive speed so
27133                  * there is no need to send the mode select to change the speed
27134                  */
27135                 if (current_speed == data) {
27136                         break;
27137                 }
27138 
27139                 /* Build the select data for the requested drive speed */
27140                 select = kmem_zalloc(BUFLEN_MODE_CDROM_SPEED, KM_SLEEP);
27141                 select_mhp = (struct mode_header *)select;
27142                 select_mhp->bdesc_length = 0;
27143                 select_page =
27144                     (struct mode_speed *)(select + MODE_HEADER_LENGTH);
27145                 select_page =
27146                     (struct mode_speed *)(select + MODE_HEADER_LENGTH);
27147                 select_page->mode_page.code = CDROM_MODE_SPEED;
27148                 select_page->mode_page.length = 2;
27149                 select_page->speed = (uchar_t)data;
27150 
27151                 /* Send the mode select for the requested block size */
27152                 ssc = sd_ssc_init(un);
27153                 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, select,
27154                     MODEPAGE_CDROM_SPEED_LEN + MODE_HEADER_LENGTH,
27155                     SD_DONTSAVE_PAGE, SD_PATH_STANDARD);
27156                 sd_ssc_fini(ssc);
27157                 if (rval != 0) {
27158                         /*
27159                          * The mode select failed for the requested drive speed,
27160                          * so reset the data for the original drive speed and
27161                          * send it to the target. The error is indicated by the
27162                          * return value for the failed mode select.
27163                          */
27164                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27165                             "sr_drive_speed: Mode Select Failed\n");
27166                         select_page->speed = sense_page->speed;
27167                         ssc = sd_ssc_init(un);
27168                         (void) sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, select,
27169                             MODEPAGE_CDROM_SPEED_LEN + MODE_HEADER_LENGTH,
27170                             SD_DONTSAVE_PAGE, SD_PATH_STANDARD);
27171                         sd_ssc_fini(ssc);
27172                 }
27173                 break;
27174         default:
27175                 /* should not reach here, but check anyway */
27176                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27177                     "sr_change_speed: Command '%x' Not Supported\n", cmd);
27178                 rval = EINVAL;
27179                 break;
27180         }
27181 
27182         if (select) {
27183                 kmem_free(select, BUFLEN_MODE_CDROM_SPEED);
27184         }
27185         if (sense) {
27186                 kmem_free(sense, BUFLEN_MODE_CDROM_SPEED);
27187         }
27188 
27189         return (rval);
27190 }
27191 
27192 
27193 /*
27194  *    Function: sr_atapi_change_speed()
27195  *
27196  * Description: This routine is the driver entry point for handling CD-ROM
27197  *              drive speed ioctl requests for MMC devices that do not support
27198  *              the Real Time Streaming feature (0x107).
27199  *
27200  *              Note: This routine will use the SET SPEED command which may not
27201  *              be supported by all devices.
27202  *
27203  *   Arguments: dev- the device 'dev_t'
27204  *              cmd- the request type; one of CDROMGDRVSPEED (get) or
27205  *                   CDROMSDRVSPEED (set)
27206  *              data- current drive speed or requested drive speed
27207  *              flag- this argument is a pass through to ddi_copyxxx() directly
27208  *                    from the mode argument of ioctl().
27209  *
27210  * Return Code: the code returned by sd_send_scsi_cmd()
27211  *              EINVAL if invalid arguments are provided
27212  *              EFAULT if ddi_copyxxx() fails
27213  *              ENXIO if fail ddi_get_soft_state
27214  *              EIO if invalid mode sense block descriptor length
27215  */
27216 
27217 static int
27218 sr_atapi_change_speed(dev_t dev, int cmd, intptr_t data, int flag)
27219 {
27220         struct sd_lun                   *un;
27221         struct uscsi_cmd                *com = NULL;
27222         struct mode_header_grp2         *sense_mhp;
27223         uchar_t                         *sense_page;
27224         uchar_t                         *sense = NULL;
27225         char                            cdb[CDB_GROUP5];
27226         int                             bd_len;
27227         int                             current_speed = 0;
27228         int                             max_speed = 0;
27229         int                             rval;
27230         sd_ssc_t                        *ssc;
27231 
27232         ASSERT((cmd == CDROMGDRVSPEED) || (cmd == CDROMSDRVSPEED));
27233 
27234         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27235                 return (ENXIO);
27236         }
27237 
27238         sense = kmem_zalloc(BUFLEN_MODE_CDROM_CAP, KM_SLEEP);
27239 
27240         ssc = sd_ssc_init(un);
27241         rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, sense,
27242             BUFLEN_MODE_CDROM_CAP, MODEPAGE_CDROM_CAP,
27243             SD_PATH_STANDARD);
27244         sd_ssc_fini(ssc);
27245         if (rval != 0) {
27246                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27247                     "sr_atapi_change_speed: Mode Sense Failed\n");
27248                 kmem_free(sense, BUFLEN_MODE_CDROM_CAP);
27249                 return (rval);
27250         }
27251 
27252         /* Check the block descriptor len to handle only 1 block descriptor */
27253         sense_mhp = (struct mode_header_grp2 *)sense;
27254         bd_len = (sense_mhp->bdesc_length_hi << 8) | sense_mhp->bdesc_length_lo;
27255         if (bd_len > MODE_BLK_DESC_LENGTH) {
27256                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27257                     "sr_atapi_change_speed: Mode Sense returned invalid "
27258                     "block descriptor length\n");
27259                 kmem_free(sense, BUFLEN_MODE_CDROM_CAP);
27260                 return (EIO);
27261         }
27262 
27263         /* Calculate the current and maximum drive speeds */
27264         sense_page = (uchar_t *)(sense + MODE_HEADER_LENGTH_GRP2 + bd_len);
27265         current_speed = (sense_page[14] << 8) | sense_page[15];
27266         max_speed = (sense_page[8] << 8) | sense_page[9];
27267 
27268         /* Process the command */
27269         switch (cmd) {
27270         case CDROMGDRVSPEED:
27271                 current_speed /= SD_SPEED_1X;
27272                 if (ddi_copyout(&current_speed, (void *)data,
27273                     sizeof (int), flag) != 0)
27274                         rval = EFAULT;
27275                 break;
27276         case CDROMSDRVSPEED:
27277                 /* Convert the speed code to KB/sec */
27278                 switch ((uchar_t)data) {
27279                 case CDROM_NORMAL_SPEED:
27280                         current_speed = SD_SPEED_1X;
27281                         break;
27282                 case CDROM_DOUBLE_SPEED:
27283                         current_speed = 2 * SD_SPEED_1X;
27284                         break;
27285                 case CDROM_QUAD_SPEED:
27286                         current_speed = 4 * SD_SPEED_1X;
27287                         break;
27288                 case CDROM_TWELVE_SPEED:
27289                         current_speed = 12 * SD_SPEED_1X;
27290                         break;
27291                 case CDROM_MAXIMUM_SPEED:
27292                         current_speed = 0xffff;
27293                         break;
27294                 default:
27295                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27296                             "sr_atapi_change_speed: invalid drive speed %d\n",
27297                             (uchar_t)data);
27298                         kmem_free(sense, BUFLEN_MODE_CDROM_CAP);
27299                         return (EINVAL);
27300                 }
27301 
27302                 /* Check the request against the drive's max speed. */
27303                 if (current_speed != 0xffff) {
27304                         if (current_speed > max_speed) {
27305                                 kmem_free(sense, BUFLEN_MODE_CDROM_CAP);
27306                                 return (EINVAL);
27307                         }
27308                 }
27309 
27310                 /*
27311                  * Build and send the SET SPEED command
27312                  *
27313                  * Note: The SET SPEED (0xBB) command used in this routine is
27314                  * obsolete per the SCSI MMC spec but still supported in the
27315                  * MT FUJI vendor spec. Most equipment is adhereing to MT FUJI
27316                  * therefore the command is still implemented in this routine.
27317                  */
27318                 bzero(cdb, sizeof (cdb));
27319                 cdb[0] = (char)SCMD_SET_CDROM_SPEED;
27320                 cdb[2] = (uchar_t)(current_speed >> 8);
27321                 cdb[3] = (uchar_t)current_speed;
27322                 com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27323                 com->uscsi_cdb          = (caddr_t)cdb;
27324                 com->uscsi_cdblen  = CDB_GROUP5;
27325                 com->uscsi_bufaddr = NULL;
27326                 com->uscsi_buflen  = 0;
27327                 com->uscsi_flags   = USCSI_DIAGNOSE|USCSI_SILENT;
27328                 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, 0, SD_PATH_STANDARD);
27329                 break;
27330         default:
27331                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27332                     "sr_atapi_change_speed: Command '%x' Not Supported\n", cmd);
27333                 rval = EINVAL;
27334         }
27335 
27336         if (sense) {
27337                 kmem_free(sense, BUFLEN_MODE_CDROM_CAP);
27338         }
27339         if (com) {
27340                 kmem_free(com, sizeof (*com));
27341         }
27342         return (rval);
27343 }
27344 
27345 
27346 /*
27347  *    Function: sr_pause_resume()
27348  *
27349  * Description: This routine is the driver entry point for handling CD-ROM
27350  *              pause/resume ioctl requests. This only affects the audio play
27351  *              operation.
27352  *
27353  *   Arguments: dev - the device 'dev_t'
27354  *              cmd - the request type; one of CDROMPAUSE or CDROMRESUME, used
27355  *                    for setting the resume bit of the cdb.
27356  *
27357  * Return Code: the code returned by sd_send_scsi_cmd()
27358  *              EINVAL if invalid mode specified
27359  *
27360  */
27361 
27362 static int
27363 sr_pause_resume(dev_t dev, int cmd)
27364 {
27365         struct sd_lun           *un;
27366         struct uscsi_cmd        *com;
27367         char                    cdb[CDB_GROUP1];
27368         int                     rval;
27369 
27370         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27371                 return (ENXIO);
27372         }
27373 
27374         com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27375         bzero(cdb, CDB_GROUP1);
27376         cdb[0] = SCMD_PAUSE_RESUME;
27377         switch (cmd) {
27378         case CDROMRESUME:
27379                 cdb[8] = 1;
27380                 break;
27381         case CDROMPAUSE:
27382                 cdb[8] = 0;
27383                 break;
27384         default:
27385                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, "sr_pause_resume:"
27386                     " Command '%x' Not Supported\n", cmd);
27387                 rval = EINVAL;
27388                 goto done;
27389         }
27390 
27391         com->uscsi_cdb    = cdb;
27392         com->uscsi_cdblen = CDB_GROUP1;
27393         com->uscsi_flags  = USCSI_DIAGNOSE|USCSI_SILENT;
27394 
27395         rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27396             SD_PATH_STANDARD);
27397 
27398 done:
27399         kmem_free(com, sizeof (*com));
27400         return (rval);
27401 }
27402 
27403 
27404 /*
27405  *    Function: sr_play_msf()
27406  *
27407  * Description: This routine is the driver entry point for handling CD-ROM
27408  *              ioctl requests to output the audio signals at the specified
27409  *              starting address and continue the audio play until the specified
27410  *              ending address (CDROMPLAYMSF) The address is in Minute Second
27411  *              Frame (MSF) format.
27412  *
27413  *   Arguments: dev     - the device 'dev_t'
27414  *              data    - pointer to user provided audio msf structure,
27415  *                        specifying start/end addresses.
27416  *              flag    - this argument is a pass through to ddi_copyxxx()
27417  *                        directly from the mode argument of ioctl().
27418  *
27419  * Return Code: the code returned by sd_send_scsi_cmd()
27420  *              EFAULT if ddi_copyxxx() fails
27421  *              ENXIO if fail ddi_get_soft_state
27422  *              EINVAL if data pointer is NULL
27423  */
27424 
27425 static int
27426 sr_play_msf(dev_t dev, caddr_t data, int flag)
27427 {
27428         struct sd_lun           *un;
27429         struct uscsi_cmd        *com;
27430         struct cdrom_msf        msf_struct;
27431         struct cdrom_msf        *msf = &msf_struct;
27432         char                    cdb[CDB_GROUP1];
27433         int                     rval;
27434 
27435         if (data == NULL) {
27436                 return (EINVAL);
27437         }
27438 
27439         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27440                 return (ENXIO);
27441         }
27442 
27443         if (ddi_copyin(data, msf, sizeof (struct cdrom_msf), flag)) {
27444                 return (EFAULT);
27445         }
27446 
27447         com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27448         bzero(cdb, CDB_GROUP1);
27449         cdb[0] = SCMD_PLAYAUDIO_MSF;
27450         if (un->un_f_cfg_playmsf_bcd == TRUE) {
27451                 cdb[3] = BYTE_TO_BCD(msf->cdmsf_min0);
27452                 cdb[4] = BYTE_TO_BCD(msf->cdmsf_sec0);
27453                 cdb[5] = BYTE_TO_BCD(msf->cdmsf_frame0);
27454                 cdb[6] = BYTE_TO_BCD(msf->cdmsf_min1);
27455                 cdb[7] = BYTE_TO_BCD(msf->cdmsf_sec1);
27456                 cdb[8] = BYTE_TO_BCD(msf->cdmsf_frame1);
27457         } else {
27458                 cdb[3] = msf->cdmsf_min0;
27459                 cdb[4] = msf->cdmsf_sec0;
27460                 cdb[5] = msf->cdmsf_frame0;
27461                 cdb[6] = msf->cdmsf_min1;
27462                 cdb[7] = msf->cdmsf_sec1;
27463                 cdb[8] = msf->cdmsf_frame1;
27464         }
27465         com->uscsi_cdb    = cdb;
27466         com->uscsi_cdblen = CDB_GROUP1;
27467         com->uscsi_flags  = USCSI_DIAGNOSE|USCSI_SILENT;
27468         rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27469             SD_PATH_STANDARD);
27470         kmem_free(com, sizeof (*com));
27471         return (rval);
27472 }
27473 
27474 
27475 /*
27476  *    Function: sr_play_trkind()
27477  *
27478  * Description: This routine is the driver entry point for handling CD-ROM
27479  *              ioctl requests to output the audio signals at the specified
27480  *              starting address and continue the audio play until the specified
27481  *              ending address (CDROMPLAYTRKIND). The address is in Track Index
27482  *              format.
27483  *
27484  *   Arguments: dev     - the device 'dev_t'
27485  *              data    - pointer to user provided audio track/index structure,
27486  *                        specifying start/end addresses.
27487  *              flag    - this argument is a pass through to ddi_copyxxx()
27488  *                        directly from the mode argument of ioctl().
27489  *
27490  * Return Code: the code returned by sd_send_scsi_cmd()
27491  *              EFAULT if ddi_copyxxx() fails
27492  *              ENXIO if fail ddi_get_soft_state
27493  *              EINVAL if data pointer is NULL
27494  */
27495 
27496 static int
27497 sr_play_trkind(dev_t dev, caddr_t data, int flag)
27498 {
27499         struct cdrom_ti         ti_struct;
27500         struct cdrom_ti         *ti = &ti_struct;
27501         struct uscsi_cmd        *com = NULL;
27502         char                    cdb[CDB_GROUP1];
27503         int                     rval;
27504 
27505         if (data == NULL) {
27506                 return (EINVAL);
27507         }
27508 
27509         if (ddi_copyin(data, ti, sizeof (struct cdrom_ti), flag)) {
27510                 return (EFAULT);
27511         }
27512 
27513         com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27514         bzero(cdb, CDB_GROUP1);
27515         cdb[0] = SCMD_PLAYAUDIO_TI;
27516         cdb[4] = ti->cdti_trk0;
27517         cdb[5] = ti->cdti_ind0;
27518         cdb[7] = ti->cdti_trk1;
27519         cdb[8] = ti->cdti_ind1;
27520         com->uscsi_cdb    = cdb;
27521         com->uscsi_cdblen = CDB_GROUP1;
27522         com->uscsi_flags  = USCSI_DIAGNOSE|USCSI_SILENT;
27523         rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27524             SD_PATH_STANDARD);
27525         kmem_free(com, sizeof (*com));
27526         return (rval);
27527 }
27528 
27529 
27530 /*
27531  *    Function: sr_read_all_subcodes()
27532  *
27533  * Description: This routine is the driver entry point for handling CD-ROM
27534  *              ioctl requests to return raw subcode data while the target is
27535  *              playing audio (CDROMSUBCODE).
27536  *
27537  *   Arguments: dev     - the device 'dev_t'
27538  *              data    - pointer to user provided cdrom subcode structure,
27539  *                        specifying the transfer length and address.
27540  *              flag    - this argument is a pass through to ddi_copyxxx()
27541  *                        directly from the mode argument of ioctl().
27542  *
27543  * Return Code: the code returned by sd_send_scsi_cmd()
27544  *              EFAULT if ddi_copyxxx() fails
27545  *              ENXIO if fail ddi_get_soft_state
27546  *              EINVAL if data pointer is NULL
27547  */
27548 
27549 static int
27550 sr_read_all_subcodes(dev_t dev, caddr_t data, int flag)
27551 {
27552         struct sd_lun           *un = NULL;
27553         struct uscsi_cmd        *com = NULL;
27554         struct cdrom_subcode    *subcode = NULL;
27555         int                     rval;
27556         size_t                  buflen;
27557         char                    cdb[CDB_GROUP5];
27558 
27559 #ifdef _MULTI_DATAMODEL
27560         /* To support ILP32 applications in an LP64 world */
27561         struct cdrom_subcode32          cdrom_subcode32;
27562         struct cdrom_subcode32          *cdsc32 = &cdrom_subcode32;
27563 #endif
27564         if (data == NULL) {
27565                 return (EINVAL);
27566         }
27567 
27568         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
27569                 return (ENXIO);
27570         }
27571 
27572         subcode = kmem_zalloc(sizeof (struct cdrom_subcode), KM_SLEEP);
27573 
27574 #ifdef _MULTI_DATAMODEL
27575         switch (ddi_model_convert_from(flag & FMODELS)) {
27576         case DDI_MODEL_ILP32:
27577                 if (ddi_copyin(data, cdsc32, sizeof (*cdsc32), flag)) {
27578                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27579                             "sr_read_all_subcodes: ddi_copyin Failed\n");
27580                         kmem_free(subcode, sizeof (struct cdrom_subcode));
27581                         return (EFAULT);
27582                 }
27583                 /* Convert the ILP32 uscsi data from the application to LP64 */
27584                 cdrom_subcode32tocdrom_subcode(cdsc32, subcode);
27585                 break;
27586         case DDI_MODEL_NONE:
27587                 if (ddi_copyin(data, subcode,
27588                     sizeof (struct cdrom_subcode), flag)) {
27589                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27590                             "sr_read_all_subcodes: ddi_copyin Failed\n");
27591                         kmem_free(subcode, sizeof (struct cdrom_subcode));
27592                         return (EFAULT);
27593                 }
27594                 break;
27595         }
27596 #else /* ! _MULTI_DATAMODEL */
27597         if (ddi_copyin(data, subcode, sizeof (struct cdrom_subcode), flag)) {
27598                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27599                     "sr_read_all_subcodes: ddi_copyin Failed\n");
27600                 kmem_free(subcode, sizeof (struct cdrom_subcode));
27601                 return (EFAULT);
27602         }
27603 #endif /* _MULTI_DATAMODEL */
27604 
27605         /*
27606          * Since MMC-2 expects max 3 bytes for length, check if the
27607          * length input is greater than 3 bytes
27608          */
27609         if ((subcode->cdsc_length & 0xFF000000) != 0) {
27610                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
27611                     "sr_read_all_subcodes: "
27612                     "cdrom transfer length too large: %d (limit %d)\n",
27613                     subcode->cdsc_length, 0xFFFFFF);
27614                 kmem_free(subcode, sizeof (struct cdrom_subcode));
27615                 return (EINVAL);
27616         }
27617 
27618         buflen = CDROM_BLK_SUBCODE * subcode->cdsc_length;
27619         com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27620         bzero(cdb, CDB_GROUP5);
27621 
27622         if (un->un_f_mmc_cap == TRUE) {
27623                 cdb[0] = (char)SCMD_READ_CD;
27624                 cdb[2] = (char)0xff;
27625                 cdb[3] = (char)0xff;
27626                 cdb[4] = (char)0xff;
27627                 cdb[5] = (char)0xff;
27628                 cdb[6] = (((subcode->cdsc_length) & 0x00ff0000) >> 16);
27629                 cdb[7] = (((subcode->cdsc_length) & 0x0000ff00) >> 8);
27630                 cdb[8] = ((subcode->cdsc_length) & 0x000000ff);
27631                 cdb[10] = 1;
27632         } else {
27633                 /*
27634                  * Note: A vendor specific command (0xDF) is being used her to
27635                  * request a read of all subcodes.
27636                  */
27637                 cdb[0] = (char)SCMD_READ_ALL_SUBCODES;
27638                 cdb[6] = (((subcode->cdsc_length) & 0xff000000) >> 24);
27639                 cdb[7] = (((subcode->cdsc_length) & 0x00ff0000) >> 16);
27640                 cdb[8] = (((subcode->cdsc_length) & 0x0000ff00) >> 8);
27641                 cdb[9] = ((subcode->cdsc_length) & 0x000000ff);
27642         }
27643         com->uscsi_cdb          = cdb;
27644         com->uscsi_cdblen  = CDB_GROUP5;
27645         com->uscsi_bufaddr = (caddr_t)subcode->cdsc_addr;
27646         com->uscsi_buflen  = buflen;
27647         com->uscsi_flags   = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
27648         rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_USERSPACE,
27649             SD_PATH_STANDARD);
27650         kmem_free(subcode, sizeof (struct cdrom_subcode));
27651         kmem_free(com, sizeof (*com));
27652         return (rval);
27653 }
27654 
27655 
27656 /*
27657  *    Function: sr_read_subchannel()
27658  *
27659  * Description: This routine is the driver entry point for handling CD-ROM
27660  *              ioctl requests to return the Q sub-channel data of the CD
27661  *              current position block. (CDROMSUBCHNL) The data includes the
27662  *              track number, index number, absolute CD-ROM address (LBA or MSF
27663  *              format per the user) , track relative CD-ROM address (LBA or MSF
27664  *              format per the user), control data and audio status.
27665  *
27666  *   Arguments: dev     - the device 'dev_t'
27667  *              data    - pointer to user provided cdrom sub-channel structure
27668  *              flag    - this argument is a pass through to ddi_copyxxx()
27669  *                        directly from the mode argument of ioctl().
27670  *
27671  * Return Code: the code returned by sd_send_scsi_cmd()
27672  *              EFAULT if ddi_copyxxx() fails
27673  *              ENXIO if fail ddi_get_soft_state
27674  *              EINVAL if data pointer is NULL
27675  */
27676 
27677 static int
27678 sr_read_subchannel(dev_t dev, caddr_t data, int flag)
27679 {
27680         struct sd_lun           *un;
27681         struct uscsi_cmd        *com;
27682         struct cdrom_subchnl    subchanel;
27683         struct cdrom_subchnl    *subchnl = &subchanel;
27684         char                    cdb[CDB_GROUP1];
27685         caddr_t                 buffer;
27686         int                     rval;
27687 
27688         if (data == NULL) {
27689                 return (EINVAL);
27690         }
27691 
27692         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
27693             (un->un_state == SD_STATE_OFFLINE)) {
27694                 return (ENXIO);
27695         }
27696 
27697         if (ddi_copyin(data, subchnl, sizeof (struct cdrom_subchnl), flag)) {
27698                 return (EFAULT);
27699         }
27700 
27701         buffer = kmem_zalloc((size_t)16, KM_SLEEP);
27702         bzero(cdb, CDB_GROUP1);
27703         cdb[0] = SCMD_READ_SUBCHANNEL;
27704         /* Set the MSF bit based on the user requested address format */
27705         cdb[1] = (subchnl->cdsc_format & CDROM_LBA) ? 0 : 0x02;
27706         /*
27707          * Set the Q bit in byte 2 to indicate that Q sub-channel data be
27708          * returned
27709          */
27710         cdb[2] = 0x40;
27711         /*
27712          * Set byte 3 to specify the return data format. A value of 0x01
27713          * indicates that the CD-ROM current position should be returned.
27714          */
27715         cdb[3] = 0x01;
27716         cdb[8] = 0x10;
27717         com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27718         com->uscsi_cdb          = cdb;
27719         com->uscsi_cdblen  = CDB_GROUP1;
27720         com->uscsi_bufaddr = buffer;
27721         com->uscsi_buflen  = 16;
27722         com->uscsi_flags   = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
27723         rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27724             SD_PATH_STANDARD);
27725         if (rval != 0) {
27726                 kmem_free(buffer, 16);
27727                 kmem_free(com, sizeof (*com));
27728                 return (rval);
27729         }
27730 
27731         /* Process the returned Q sub-channel data */
27732         subchnl->cdsc_audiostatus = buffer[1];
27733         subchnl->cdsc_adr    = (buffer[5] & 0xF0) >> 4;
27734         subchnl->cdsc_ctrl   = (buffer[5] & 0x0F);
27735         subchnl->cdsc_trk    = buffer[6];
27736         subchnl->cdsc_ind    = buffer[7];
27737         if (subchnl->cdsc_format & CDROM_LBA) {
27738                 subchnl->cdsc_absaddr.lba =
27739                     ((uchar_t)buffer[8] << 24) + ((uchar_t)buffer[9] << 16) +
27740                     ((uchar_t)buffer[10] << 8) + ((uchar_t)buffer[11]);
27741                 subchnl->cdsc_reladdr.lba =
27742                     ((uchar_t)buffer[12] << 24) + ((uchar_t)buffer[13] << 16) +
27743                     ((uchar_t)buffer[14] << 8) + ((uchar_t)buffer[15]);
27744         } else if (un->un_f_cfg_readsub_bcd == TRUE) {
27745                 subchnl->cdsc_absaddr.msf.minute = BCD_TO_BYTE(buffer[9]);
27746                 subchnl->cdsc_absaddr.msf.second = BCD_TO_BYTE(buffer[10]);
27747                 subchnl->cdsc_absaddr.msf.frame  = BCD_TO_BYTE(buffer[11]);
27748                 subchnl->cdsc_reladdr.msf.minute = BCD_TO_BYTE(buffer[13]);
27749                 subchnl->cdsc_reladdr.msf.second = BCD_TO_BYTE(buffer[14]);
27750                 subchnl->cdsc_reladdr.msf.frame  = BCD_TO_BYTE(buffer[15]);
27751         } else {
27752                 subchnl->cdsc_absaddr.msf.minute = buffer[9];
27753                 subchnl->cdsc_absaddr.msf.second = buffer[10];
27754                 subchnl->cdsc_absaddr.msf.frame  = buffer[11];
27755                 subchnl->cdsc_reladdr.msf.minute = buffer[13];
27756                 subchnl->cdsc_reladdr.msf.second = buffer[14];
27757                 subchnl->cdsc_reladdr.msf.frame  = buffer[15];
27758         }
27759         kmem_free(buffer, 16);
27760         kmem_free(com, sizeof (*com));
27761         if (ddi_copyout(subchnl, data, sizeof (struct cdrom_subchnl), flag)
27762             != 0) {
27763                 return (EFAULT);
27764         }
27765         return (rval);
27766 }
27767 
27768 
27769 /*
27770  *    Function: sr_read_tocentry()
27771  *
27772  * Description: This routine is the driver entry point for handling CD-ROM
27773  *              ioctl requests to read from the Table of Contents (TOC)
27774  *              (CDROMREADTOCENTRY). This routine provides the ADR and CTRL
27775  *              fields, the starting address (LBA or MSF format per the user)
27776  *              and the data mode if the user specified track is a data track.
27777  *
27778  *              Note: The READ HEADER (0x44) command used in this routine is
27779  *              obsolete per the SCSI MMC spec but still supported in the
27780  *              MT FUJI vendor spec. Most equipment is adhereing to MT FUJI
27781  *              therefore the command is still implemented in this routine.
27782  *
27783  *   Arguments: dev     - the device 'dev_t'
27784  *              data    - pointer to user provided toc entry structure,
27785  *                        specifying the track # and the address format
27786  *                        (LBA or MSF).
27787  *              flag    - this argument is a pass through to ddi_copyxxx()
27788  *                        directly from the mode argument of ioctl().
27789  *
27790  * Return Code: the code returned by sd_send_scsi_cmd()
27791  *              EFAULT if ddi_copyxxx() fails
27792  *              ENXIO if fail ddi_get_soft_state
27793  *              EINVAL if data pointer is NULL
27794  */
27795 
27796 static int
27797 sr_read_tocentry(dev_t dev, caddr_t data, int flag)
27798 {
27799         struct sd_lun           *un = NULL;
27800         struct uscsi_cmd        *com;
27801         struct cdrom_tocentry   toc_entry;
27802         struct cdrom_tocentry   *entry = &toc_entry;
27803         caddr_t                 buffer;
27804         int                     rval;
27805         char                    cdb[CDB_GROUP1];
27806 
27807         if (data == NULL) {
27808                 return (EINVAL);
27809         }
27810 
27811         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
27812             (un->un_state == SD_STATE_OFFLINE)) {
27813                 return (ENXIO);
27814         }
27815 
27816         if (ddi_copyin(data, entry, sizeof (struct cdrom_tocentry), flag)) {
27817                 return (EFAULT);
27818         }
27819 
27820         /* Validate the requested track and address format */
27821         if (!(entry->cdte_format & (CDROM_LBA | CDROM_MSF))) {
27822                 return (EINVAL);
27823         }
27824 
27825         if (entry->cdte_track == 0) {
27826                 return (EINVAL);
27827         }
27828 
27829         buffer = kmem_zalloc((size_t)12, KM_SLEEP);
27830         com = kmem_zalloc(sizeof (*com), KM_SLEEP);
27831         bzero(cdb, CDB_GROUP1);
27832 
27833         cdb[0] = SCMD_READ_TOC;
27834         /* Set the MSF bit based on the user requested address format  */
27835         cdb[1] = ((entry->cdte_format & CDROM_LBA) ? 0 : 2);
27836         if (un->un_f_cfg_read_toc_trk_bcd == TRUE) {
27837                 cdb[6] = BYTE_TO_BCD(entry->cdte_track);
27838         } else {
27839                 cdb[6] = entry->cdte_track;
27840         }
27841 
27842         /*
27843          * Bytes 7 & 8 are the 12 byte allocation length for a single entry.
27844          * (4 byte TOC response header + 8 byte track descriptor)
27845          */
27846         cdb[8] = 12;
27847         com->uscsi_cdb          = cdb;
27848         com->uscsi_cdblen  = CDB_GROUP1;
27849         com->uscsi_bufaddr = buffer;
27850         com->uscsi_buflen  = 0x0C;
27851         com->uscsi_flags   = (USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ);
27852         rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27853             SD_PATH_STANDARD);
27854         if (rval != 0) {
27855                 kmem_free(buffer, 12);
27856                 kmem_free(com, sizeof (*com));
27857                 return (rval);
27858         }
27859 
27860         /* Process the toc entry */
27861         entry->cdte_adr              = (buffer[5] & 0xF0) >> 4;
27862         entry->cdte_ctrl     = (buffer[5] & 0x0F);
27863         if (entry->cdte_format & CDROM_LBA) {
27864                 entry->cdte_addr.lba =
27865                     ((uchar_t)buffer[8] << 24) + ((uchar_t)buffer[9] << 16) +
27866                     ((uchar_t)buffer[10] << 8) + ((uchar_t)buffer[11]);
27867         } else if (un->un_f_cfg_read_toc_addr_bcd == TRUE) {
27868                 entry->cdte_addr.msf.minute  = BCD_TO_BYTE(buffer[9]);
27869                 entry->cdte_addr.msf.second  = BCD_TO_BYTE(buffer[10]);
27870                 entry->cdte_addr.msf.frame   = BCD_TO_BYTE(buffer[11]);
27871                 /*
27872                  * Send a READ TOC command using the LBA address format to get
27873                  * the LBA for the track requested so it can be used in the
27874                  * READ HEADER request
27875                  *
27876                  * Note: The MSF bit of the READ HEADER command specifies the
27877                  * output format. The block address specified in that command
27878                  * must be in LBA format.
27879                  */
27880                 cdb[1] = 0;
27881                 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27882                     SD_PATH_STANDARD);
27883                 if (rval != 0) {
27884                         kmem_free(buffer, 12);
27885                         kmem_free(com, sizeof (*com));
27886                         return (rval);
27887                 }
27888         } else {
27889                 entry->cdte_addr.msf.minute  = buffer[9];
27890                 entry->cdte_addr.msf.second  = buffer[10];
27891                 entry->cdte_addr.msf.frame   = buffer[11];
27892                 /*
27893                  * Send a READ TOC command using the LBA address format to get
27894                  * the LBA for the track requested so it can be used in the
27895                  * READ HEADER request
27896                  *
27897                  * Note: The MSF bit of the READ HEADER command specifies the
27898                  * output format. The block address specified in that command
27899                  * must be in LBA format.
27900                  */
27901                 cdb[1] = 0;
27902                 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27903                     SD_PATH_STANDARD);
27904                 if (rval != 0) {
27905                         kmem_free(buffer, 12);
27906                         kmem_free(com, sizeof (*com));
27907                         return (rval);
27908                 }
27909         }
27910 
27911         /*
27912          * Build and send the READ HEADER command to determine the data mode of
27913          * the user specified track.
27914          */
27915         if ((entry->cdte_ctrl & CDROM_DATA_TRACK) &&
27916             (entry->cdte_track != CDROM_LEADOUT)) {
27917                 bzero(cdb, CDB_GROUP1);
27918                 cdb[0] = SCMD_READ_HEADER;
27919                 cdb[2] = buffer[8];
27920                 cdb[3] = buffer[9];
27921                 cdb[4] = buffer[10];
27922                 cdb[5] = buffer[11];
27923                 cdb[8] = 0x08;
27924                 com->uscsi_buflen = 0x08;
27925                 rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
27926                     SD_PATH_STANDARD);
27927                 if (rval == 0) {
27928                         entry->cdte_datamode = buffer[0];
27929                 } else {
27930                         /*
27931                          * READ HEADER command failed, since this is
27932                          * obsoleted in one spec, its better to return
27933                          * -1 for an invlid track so that we can still
27934                          * receive the rest of the TOC data.
27935                          */
27936                         entry->cdte_datamode = (uchar_t)-1;
27937                 }
27938         } else {
27939                 entry->cdte_datamode = (uchar_t)-1;
27940         }
27941 
27942         kmem_free(buffer, 12);
27943         kmem_free(com, sizeof (*com));
27944         if (ddi_copyout(entry, data, sizeof (struct cdrom_tocentry), flag) != 0)
27945                 return (EFAULT);
27946 
27947         return (rval);
27948 }
27949 
27950 
27951 /*
27952  *    Function: sr_read_tochdr()
27953  *
27954  * Description: This routine is the driver entry point for handling CD-ROM
27955  *              ioctl requests to read the Table of Contents (TOC) header
27956  *              (CDROMREADTOHDR). The TOC header consists of the disk starting
27957  *              and ending track numbers
27958  *
27959  *   Arguments: dev     - the device 'dev_t'
27960  *              data    - pointer to user provided toc header structure,
27961  *                        specifying the starting and ending track numbers.
27962  *              flag    - this argument is a pass through to ddi_copyxxx()
27963  *                        directly from the mode argument of ioctl().
27964  *
27965  * Return Code: the code returned by sd_send_scsi_cmd()
27966  *              EFAULT if ddi_copyxxx() fails
27967  *              ENXIO if fail ddi_get_soft_state
27968  *              EINVAL if data pointer is NULL
27969  */
27970 
27971 static int
27972 sr_read_tochdr(dev_t dev, caddr_t data, int flag)
27973 {
27974         struct sd_lun           *un;
27975         struct uscsi_cmd        *com;
27976         struct cdrom_tochdr     toc_header;
27977         struct cdrom_tochdr     *hdr = &toc_header;
27978         char                    cdb[CDB_GROUP1];
27979         int                     rval;
27980         caddr_t                 buffer;
27981 
27982         if (data == NULL) {
27983                 return (EINVAL);
27984         }
27985 
27986         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
27987             (un->un_state == SD_STATE_OFFLINE)) {
27988                 return (ENXIO);
27989         }
27990 
27991         buffer = kmem_zalloc(4, KM_SLEEP);
27992         bzero(cdb, CDB_GROUP1);
27993         cdb[0] = SCMD_READ_TOC;
27994         /*
27995          * Specifying a track number of 0x00 in the READ TOC command indicates
27996          * that the TOC header should be returned
27997          */
27998         cdb[6] = 0x00;
27999         /*
28000          * Bytes 7 & 8 are the 4 byte allocation length for TOC header.
28001          * (2 byte data len + 1 byte starting track # + 1 byte ending track #)
28002          */
28003         cdb[8] = 0x04;
28004         com = kmem_zalloc(sizeof (*com), KM_SLEEP);
28005         com->uscsi_cdb          = cdb;
28006         com->uscsi_cdblen  = CDB_GROUP1;
28007         com->uscsi_bufaddr = buffer;
28008         com->uscsi_buflen  = 0x04;
28009         com->uscsi_timeout = 300;
28010         com->uscsi_flags   = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
28011 
28012         rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
28013             SD_PATH_STANDARD);
28014         if (un->un_f_cfg_read_toc_trk_bcd == TRUE) {
28015                 hdr->cdth_trk0 = BCD_TO_BYTE(buffer[2]);
28016                 hdr->cdth_trk1 = BCD_TO_BYTE(buffer[3]);
28017         } else {
28018                 hdr->cdth_trk0 = buffer[2];
28019                 hdr->cdth_trk1 = buffer[3];
28020         }
28021         kmem_free(buffer, 4);
28022         kmem_free(com, sizeof (*com));
28023         if (ddi_copyout(hdr, data, sizeof (struct cdrom_tochdr), flag) != 0) {
28024                 return (EFAULT);
28025         }
28026         return (rval);
28027 }
28028 
28029 
28030 /*
28031  * Note: The following sr_read_mode1(), sr_read_cd_mode2(), sr_read_mode2(),
28032  * sr_read_cdda(), sr_read_cdxa(), routines implement driver support for
28033  * handling CDROMREAD ioctl requests for mode 1 user data, mode 2 user data,
28034  * digital audio and extended architecture digital audio. These modes are
28035  * defined in the IEC908 (Red Book), ISO10149 (Yellow Book), and the SCSI3
28036  * MMC specs.
28037  *
28038  * In addition to support for the various data formats these routines also
28039  * include support for devices that implement only the direct access READ
28040  * commands (0x08, 0x28), devices that implement the READ_CD commands
28041  * (0xBE, 0xD4), and devices that implement the vendor unique READ CDDA and
28042  * READ CDXA commands (0xD8, 0xDB)
28043  */
28044 
28045 /*
28046  *    Function: sr_read_mode1()
28047  *
28048  * Description: This routine is the driver entry point for handling CD-ROM
28049  *              ioctl read mode1 requests (CDROMREADMODE1).
28050  *
28051  *   Arguments: dev     - the device 'dev_t'
28052  *              data    - pointer to user provided cd read structure specifying
28053  *                        the lba buffer address and length.
28054  *              flag    - this argument is a pass through to ddi_copyxxx()
28055  *                        directly from the mode argument of ioctl().
28056  *
28057  * Return Code: the code returned by sd_send_scsi_cmd()
28058  *              EFAULT if ddi_copyxxx() fails
28059  *              ENXIO if fail ddi_get_soft_state
28060  *              EINVAL if data pointer is NULL
28061  */
28062 
28063 static int
28064 sr_read_mode1(dev_t dev, caddr_t data, int flag)
28065 {
28066         struct sd_lun           *un;
28067         struct cdrom_read       mode1_struct;
28068         struct cdrom_read       *mode1 = &mode1_struct;
28069         int                     rval;
28070         sd_ssc_t                *ssc;
28071 
28072 #ifdef _MULTI_DATAMODEL
28073         /* To support ILP32 applications in an LP64 world */
28074         struct cdrom_read32     cdrom_read32;
28075         struct cdrom_read32     *cdrd32 = &cdrom_read32;
28076 #endif /* _MULTI_DATAMODEL */
28077 
28078         if (data == NULL) {
28079                 return (EINVAL);
28080         }
28081 
28082         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28083             (un->un_state == SD_STATE_OFFLINE)) {
28084                 return (ENXIO);
28085         }
28086 
28087         SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28088             "sd_read_mode1: entry: un:0x%p\n", un);
28089 
28090 #ifdef _MULTI_DATAMODEL
28091         switch (ddi_model_convert_from(flag & FMODELS)) {
28092         case DDI_MODEL_ILP32:
28093                 if (ddi_copyin(data, cdrd32, sizeof (*cdrd32), flag) != 0) {
28094                         return (EFAULT);
28095                 }
28096                 /* Convert the ILP32 uscsi data from the application to LP64 */
28097                 cdrom_read32tocdrom_read(cdrd32, mode1);
28098                 break;
28099         case DDI_MODEL_NONE:
28100                 if (ddi_copyin(data, mode1, sizeof (struct cdrom_read), flag)) {
28101                         return (EFAULT);
28102                 }
28103         }
28104 #else /* ! _MULTI_DATAMODEL */
28105         if (ddi_copyin(data, mode1, sizeof (struct cdrom_read), flag)) {
28106                 return (EFAULT);
28107         }
28108 #endif /* _MULTI_DATAMODEL */
28109 
28110         ssc = sd_ssc_init(un);
28111         rval = sd_send_scsi_READ(ssc, mode1->cdread_bufaddr,
28112             mode1->cdread_buflen, mode1->cdread_lba, SD_PATH_STANDARD);
28113         sd_ssc_fini(ssc);
28114 
28115         SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28116             "sd_read_mode1: exit: un:0x%p\n", un);
28117 
28118         return (rval);
28119 }
28120 
28121 
28122 /*
28123  *    Function: sr_read_cd_mode2()
28124  *
28125  * Description: This routine is the driver entry point for handling CD-ROM
28126  *              ioctl read mode2 requests (CDROMREADMODE2) for devices that
28127  *              support the READ CD (0xBE) command or the 1st generation
28128  *              READ CD (0xD4) command.
28129  *
28130  *   Arguments: dev     - the device 'dev_t'
28131  *              data    - pointer to user provided cd read structure specifying
28132  *                        the lba buffer address and length.
28133  *              flag    - this argument is a pass through to ddi_copyxxx()
28134  *                        directly from the mode argument of ioctl().
28135  *
28136  * Return Code: the code returned by sd_send_scsi_cmd()
28137  *              EFAULT if ddi_copyxxx() fails
28138  *              ENXIO if fail ddi_get_soft_state
28139  *              EINVAL if data pointer is NULL
28140  */
28141 
28142 static int
28143 sr_read_cd_mode2(dev_t dev, caddr_t data, int flag)
28144 {
28145         struct sd_lun           *un;
28146         struct uscsi_cmd        *com;
28147         struct cdrom_read       mode2_struct;
28148         struct cdrom_read       *mode2 = &mode2_struct;
28149         uchar_t                 cdb[CDB_GROUP5];
28150         int                     nblocks;
28151         int                     rval;
28152 #ifdef _MULTI_DATAMODEL
28153         /*  To support ILP32 applications in an LP64 world */
28154         struct cdrom_read32     cdrom_read32;
28155         struct cdrom_read32     *cdrd32 = &cdrom_read32;
28156 #endif /* _MULTI_DATAMODEL */
28157 
28158         if (data == NULL) {
28159                 return (EINVAL);
28160         }
28161 
28162         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28163             (un->un_state == SD_STATE_OFFLINE)) {
28164                 return (ENXIO);
28165         }
28166 
28167 #ifdef _MULTI_DATAMODEL
28168         switch (ddi_model_convert_from(flag & FMODELS)) {
28169         case DDI_MODEL_ILP32:
28170                 if (ddi_copyin(data, cdrd32, sizeof (*cdrd32), flag) != 0) {
28171                         return (EFAULT);
28172                 }
28173                 /* Convert the ILP32 uscsi data from the application to LP64 */
28174                 cdrom_read32tocdrom_read(cdrd32, mode2);
28175                 break;
28176         case DDI_MODEL_NONE:
28177                 if (ddi_copyin(data, mode2, sizeof (*mode2), flag) != 0) {
28178                         return (EFAULT);
28179                 }
28180                 break;
28181         }
28182 
28183 #else /* ! _MULTI_DATAMODEL */
28184         if (ddi_copyin(data, mode2, sizeof (*mode2), flag) != 0) {
28185                 return (EFAULT);
28186         }
28187 #endif /* _MULTI_DATAMODEL */
28188 
28189         bzero(cdb, sizeof (cdb));
28190         if (un->un_f_cfg_read_cd_xd4 == TRUE) {
28191                 /* Read command supported by 1st generation atapi drives */
28192                 cdb[0] = SCMD_READ_CDD4;
28193         } else {
28194                 /* Universal CD Access Command */
28195                 cdb[0] = SCMD_READ_CD;
28196         }
28197 
28198         /*
28199          * Set expected sector type to: 2336s byte, Mode 2 Yellow Book
28200          */
28201         cdb[1] = CDROM_SECTOR_TYPE_MODE2;
28202 
28203         /* set the start address */
28204         cdb[2] = (uchar_t)((mode2->cdread_lba >> 24) & 0XFF);
28205         cdb[3] = (uchar_t)((mode2->cdread_lba >> 16) & 0XFF);
28206         cdb[4] = (uchar_t)((mode2->cdread_lba >> 8) & 0xFF);
28207         cdb[5] = (uchar_t)(mode2->cdread_lba & 0xFF);
28208 
28209         /* set the transfer length */
28210         nblocks = mode2->cdread_buflen / 2336;
28211         cdb[6] = (uchar_t)(nblocks >> 16);
28212         cdb[7] = (uchar_t)(nblocks >> 8);
28213         cdb[8] = (uchar_t)nblocks;
28214 
28215         /* set the filter bits */
28216         cdb[9] = CDROM_READ_CD_USERDATA;
28217 
28218         com = kmem_zalloc(sizeof (*com), KM_SLEEP);
28219         com->uscsi_cdb = (caddr_t)cdb;
28220         com->uscsi_cdblen = sizeof (cdb);
28221         com->uscsi_bufaddr = mode2->cdread_bufaddr;
28222         com->uscsi_buflen = mode2->cdread_buflen;
28223         com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
28224 
28225         rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_USERSPACE,
28226             SD_PATH_STANDARD);
28227         kmem_free(com, sizeof (*com));
28228         return (rval);
28229 }
28230 
28231 
28232 /*
28233  *    Function: sr_read_mode2()
28234  *
28235  * Description: This routine is the driver entry point for handling CD-ROM
28236  *              ioctl read mode2 requests (CDROMREADMODE2) for devices that
28237  *              do not support the READ CD (0xBE) command.
28238  *
28239  *   Arguments: dev     - the device 'dev_t'
28240  *              data    - pointer to user provided cd read structure specifying
28241  *                        the lba buffer address and length.
28242  *              flag    - this argument is a pass through to ddi_copyxxx()
28243  *                        directly from the mode argument of ioctl().
28244  *
28245  * Return Code: the code returned by sd_send_scsi_cmd()
28246  *              EFAULT if ddi_copyxxx() fails
28247  *              ENXIO if fail ddi_get_soft_state
28248  *              EINVAL if data pointer is NULL
28249  *              EIO if fail to reset block size
28250  *              EAGAIN if commands are in progress in the driver
28251  */
28252 
28253 static int
28254 sr_read_mode2(dev_t dev, caddr_t data, int flag)
28255 {
28256         struct sd_lun           *un;
28257         struct cdrom_read       mode2_struct;
28258         struct cdrom_read       *mode2 = &mode2_struct;
28259         int                     rval;
28260         uint32_t                restore_blksize;
28261         struct uscsi_cmd        *com;
28262         uchar_t                 cdb[CDB_GROUP0];
28263         int                     nblocks;
28264 
28265 #ifdef _MULTI_DATAMODEL
28266         /* To support ILP32 applications in an LP64 world */
28267         struct cdrom_read32     cdrom_read32;
28268         struct cdrom_read32     *cdrd32 = &cdrom_read32;
28269 #endif /* _MULTI_DATAMODEL */
28270 
28271         if (data == NULL) {
28272                 return (EINVAL);
28273         }
28274 
28275         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28276             (un->un_state == SD_STATE_OFFLINE)) {
28277                 return (ENXIO);
28278         }
28279 
28280         /*
28281          * Because this routine will update the device and driver block size
28282          * being used we want to make sure there are no commands in progress.
28283          * If commands are in progress the user will have to try again.
28284          *
28285          * We check for 1 instead of 0 because we increment un_ncmds_in_driver
28286          * in sdioctl to protect commands from sdioctl through to the top of
28287          * sd_uscsi_strategy. See sdioctl for details.
28288          */
28289         mutex_enter(SD_MUTEX(un));
28290         if (un->un_ncmds_in_driver != 1) {
28291                 mutex_exit(SD_MUTEX(un));
28292                 return (EAGAIN);
28293         }
28294         mutex_exit(SD_MUTEX(un));
28295 
28296         SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28297             "sd_read_mode2: entry: un:0x%p\n", un);
28298 
28299 #ifdef _MULTI_DATAMODEL
28300         switch (ddi_model_convert_from(flag & FMODELS)) {
28301         case DDI_MODEL_ILP32:
28302                 if (ddi_copyin(data, cdrd32, sizeof (*cdrd32), flag) != 0) {
28303                         return (EFAULT);
28304                 }
28305                 /* Convert the ILP32 uscsi data from the application to LP64 */
28306                 cdrom_read32tocdrom_read(cdrd32, mode2);
28307                 break;
28308         case DDI_MODEL_NONE:
28309                 if (ddi_copyin(data, mode2, sizeof (*mode2), flag) != 0) {
28310                         return (EFAULT);
28311                 }
28312                 break;
28313         }
28314 #else /* ! _MULTI_DATAMODEL */
28315         if (ddi_copyin(data, mode2, sizeof (*mode2), flag)) {
28316                 return (EFAULT);
28317         }
28318 #endif /* _MULTI_DATAMODEL */
28319 
28320         /* Store the current target block size for restoration later */
28321         restore_blksize = un->un_tgt_blocksize;
28322 
28323         /* Change the device and soft state target block size to 2336 */
28324         if (sr_sector_mode(dev, SD_MODE2_BLKSIZE) != 0) {
28325                 rval = EIO;
28326                 goto done;
28327         }
28328 
28329 
28330         bzero(cdb, sizeof (cdb));
28331 
28332         /* set READ operation */
28333         cdb[0] = SCMD_READ;
28334 
28335         /* adjust lba for 2kbyte blocks from 512 byte blocks */
28336         mode2->cdread_lba >>= 2;
28337 
28338         /* set the start address */
28339         cdb[1] = (uchar_t)((mode2->cdread_lba >> 16) & 0X1F);
28340         cdb[2] = (uchar_t)((mode2->cdread_lba >> 8) & 0xFF);
28341         cdb[3] = (uchar_t)(mode2->cdread_lba & 0xFF);
28342 
28343         /* set the transfer length */
28344         nblocks = mode2->cdread_buflen / 2336;
28345         cdb[4] = (uchar_t)nblocks & 0xFF;
28346 
28347         /* build command */
28348         com = kmem_zalloc(sizeof (*com), KM_SLEEP);
28349         com->uscsi_cdb = (caddr_t)cdb;
28350         com->uscsi_cdblen = sizeof (cdb);
28351         com->uscsi_bufaddr = mode2->cdread_bufaddr;
28352         com->uscsi_buflen = mode2->cdread_buflen;
28353         com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
28354 
28355         /*
28356          * Issue SCSI command with user space address for read buffer.
28357          *
28358          * This sends the command through main channel in the driver.
28359          *
28360          * Since this is accessed via an IOCTL call, we go through the
28361          * standard path, so that if the device was powered down, then
28362          * it would be 'awakened' to handle the command.
28363          */
28364         rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_USERSPACE,
28365             SD_PATH_STANDARD);
28366 
28367         kmem_free(com, sizeof (*com));
28368 
28369         /* Restore the device and soft state target block size */
28370         if (sr_sector_mode(dev, restore_blksize) != 0) {
28371                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28372                     "can't do switch back to mode 1\n");
28373                 /*
28374                  * If sd_send_scsi_READ succeeded we still need to report
28375                  * an error because we failed to reset the block size
28376                  */
28377                 if (rval == 0) {
28378                         rval = EIO;
28379                 }
28380         }
28381 
28382 done:
28383         SD_TRACE(SD_LOG_ATTACH_DETACH, un,
28384             "sd_read_mode2: exit: un:0x%p\n", un);
28385 
28386         return (rval);
28387 }
28388 
28389 
28390 /*
28391  *    Function: sr_sector_mode()
28392  *
28393  * Description: This utility function is used by sr_read_mode2 to set the target
28394  *              block size based on the user specified size. This is a legacy
28395  *              implementation based upon a vendor specific mode page
28396  *
28397  *   Arguments: dev     - the device 'dev_t'
28398  *              data    - flag indicating if block size is being set to 2336 or
28399  *                        512.
28400  *
28401  * Return Code: the code returned by sd_send_scsi_cmd()
28402  *              EFAULT if ddi_copyxxx() fails
28403  *              ENXIO if fail ddi_get_soft_state
28404  *              EINVAL if data pointer is NULL
28405  */
28406 
28407 static int
28408 sr_sector_mode(dev_t dev, uint32_t blksize)
28409 {
28410         struct sd_lun   *un;
28411         uchar_t         *sense;
28412         uchar_t         *select;
28413         int             rval;
28414         sd_ssc_t        *ssc;
28415 
28416         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28417             (un->un_state == SD_STATE_OFFLINE)) {
28418                 return (ENXIO);
28419         }
28420 
28421         sense = kmem_zalloc(20, KM_SLEEP);
28422 
28423         /* Note: This is a vendor specific mode page (0x81) */
28424         ssc = sd_ssc_init(un);
28425         rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, sense, 20, 0x81,
28426             SD_PATH_STANDARD);
28427         sd_ssc_fini(ssc);
28428         if (rval != 0) {
28429                 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
28430                     "sr_sector_mode: Mode Sense failed\n");
28431                 kmem_free(sense, 20);
28432                 return (rval);
28433         }
28434         select = kmem_zalloc(20, KM_SLEEP);
28435         select[3] = 0x08;
28436         select[10] = ((blksize >> 8) & 0xff);
28437         select[11] = (blksize & 0xff);
28438         select[12] = 0x01;
28439         select[13] = 0x06;
28440         select[14] = sense[14];
28441         select[15] = sense[15];
28442         if (blksize == SD_MODE2_BLKSIZE) {
28443                 select[14] |= 0x01;
28444         }
28445 
28446         ssc = sd_ssc_init(un);
28447         rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, select, 20,
28448             SD_DONTSAVE_PAGE, SD_PATH_STANDARD);
28449         sd_ssc_fini(ssc);
28450         if (rval != 0) {
28451                 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
28452                     "sr_sector_mode: Mode Select failed\n");
28453         } else {
28454                 /*
28455                  * Only update the softstate block size if we successfully
28456                  * changed the device block mode.
28457                  */
28458                 mutex_enter(SD_MUTEX(un));
28459                 sd_update_block_info(un, blksize, 0);
28460                 mutex_exit(SD_MUTEX(un));
28461         }
28462         kmem_free(sense, 20);
28463         kmem_free(select, 20);
28464         return (rval);
28465 }
28466 
28467 
28468 /*
28469  *    Function: sr_read_cdda()
28470  *
28471  * Description: This routine is the driver entry point for handling CD-ROM
28472  *              ioctl requests to return CD-DA or subcode data. (CDROMCDDA) If
28473  *              the target supports CDDA these requests are handled via a vendor
28474  *              specific command (0xD8) If the target does not support CDDA
28475  *              these requests are handled via the READ CD command (0xBE).
28476  *
28477  *   Arguments: dev     - the device 'dev_t'
28478  *              data    - pointer to user provided CD-DA structure specifying
28479  *                        the track starting address, transfer length, and
28480  *                        subcode options.
28481  *              flag    - this argument is a pass through to ddi_copyxxx()
28482  *                        directly from the mode argument of ioctl().
28483  *
28484  * Return Code: the code returned by sd_send_scsi_cmd()
28485  *              EFAULT if ddi_copyxxx() fails
28486  *              ENXIO if fail ddi_get_soft_state
28487  *              EINVAL if invalid arguments are provided
28488  *              ENOTTY
28489  */
28490 
28491 static int
28492 sr_read_cdda(dev_t dev, caddr_t data, int flag)
28493 {
28494         struct sd_lun                   *un;
28495         struct uscsi_cmd                *com;
28496         struct cdrom_cdda               *cdda;
28497         int                             rval;
28498         size_t                          buflen;
28499         char                            cdb[CDB_GROUP5];
28500 
28501 #ifdef _MULTI_DATAMODEL
28502         /* To support ILP32 applications in an LP64 world */
28503         struct cdrom_cdda32     cdrom_cdda32;
28504         struct cdrom_cdda32     *cdda32 = &cdrom_cdda32;
28505 #endif /* _MULTI_DATAMODEL */
28506 
28507         if (data == NULL) {
28508                 return (EINVAL);
28509         }
28510 
28511         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
28512                 return (ENXIO);
28513         }
28514 
28515         cdda = kmem_zalloc(sizeof (struct cdrom_cdda), KM_SLEEP);
28516 
28517 #ifdef _MULTI_DATAMODEL
28518         switch (ddi_model_convert_from(flag & FMODELS)) {
28519         case DDI_MODEL_ILP32:
28520                 if (ddi_copyin(data, cdda32, sizeof (*cdda32), flag)) {
28521                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28522                             "sr_read_cdda: ddi_copyin Failed\n");
28523                         kmem_free(cdda, sizeof (struct cdrom_cdda));
28524                         return (EFAULT);
28525                 }
28526                 /* Convert the ILP32 uscsi data from the application to LP64 */
28527                 cdrom_cdda32tocdrom_cdda(cdda32, cdda);
28528                 break;
28529         case DDI_MODEL_NONE:
28530                 if (ddi_copyin(data, cdda, sizeof (struct cdrom_cdda), flag)) {
28531                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28532                             "sr_read_cdda: ddi_copyin Failed\n");
28533                         kmem_free(cdda, sizeof (struct cdrom_cdda));
28534                         return (EFAULT);
28535                 }
28536                 break;
28537         }
28538 #else /* ! _MULTI_DATAMODEL */
28539         if (ddi_copyin(data, cdda, sizeof (struct cdrom_cdda), flag)) {
28540                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28541                     "sr_read_cdda: ddi_copyin Failed\n");
28542                 kmem_free(cdda, sizeof (struct cdrom_cdda));
28543                 return (EFAULT);
28544         }
28545 #endif /* _MULTI_DATAMODEL */
28546 
28547         /*
28548          * Since MMC-2 expects max 3 bytes for length, check if the
28549          * length input is greater than 3 bytes
28550          */
28551         if ((cdda->cdda_length & 0xFF000000) != 0) {
28552                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, "sr_read_cdda: "
28553                     "cdrom transfer length too large: %d (limit %d)\n",
28554                     cdda->cdda_length, 0xFFFFFF);
28555                 kmem_free(cdda, sizeof (struct cdrom_cdda));
28556                 return (EINVAL);
28557         }
28558 
28559         switch (cdda->cdda_subcode) {
28560         case CDROM_DA_NO_SUBCODE:
28561                 buflen = CDROM_BLK_2352 * cdda->cdda_length;
28562                 break;
28563         case CDROM_DA_SUBQ:
28564                 buflen = CDROM_BLK_2368 * cdda->cdda_length;
28565                 break;
28566         case CDROM_DA_ALL_SUBCODE:
28567                 buflen = CDROM_BLK_2448 * cdda->cdda_length;
28568                 break;
28569         case CDROM_DA_SUBCODE_ONLY:
28570                 buflen = CDROM_BLK_SUBCODE * cdda->cdda_length;
28571                 break;
28572         default:
28573                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28574                     "sr_read_cdda: Subcode '0x%x' Not Supported\n",
28575                     cdda->cdda_subcode);
28576                 kmem_free(cdda, sizeof (struct cdrom_cdda));
28577                 return (EINVAL);
28578         }
28579 
28580         /* Build and send the command */
28581         com = kmem_zalloc(sizeof (*com), KM_SLEEP);
28582         bzero(cdb, CDB_GROUP5);
28583 
28584         if (un->un_f_cfg_cdda == TRUE) {
28585                 cdb[0] = (char)SCMD_READ_CD;
28586                 cdb[1] = 0x04;
28587                 cdb[2] = (((cdda->cdda_addr) & 0xff000000) >> 24);
28588                 cdb[3] = (((cdda->cdda_addr) & 0x00ff0000) >> 16);
28589                 cdb[4] = (((cdda->cdda_addr) & 0x0000ff00) >> 8);
28590                 cdb[5] = ((cdda->cdda_addr) & 0x000000ff);
28591                 cdb[6] = (((cdda->cdda_length) & 0x00ff0000) >> 16);
28592                 cdb[7] = (((cdda->cdda_length) & 0x0000ff00) >> 8);
28593                 cdb[8] = ((cdda->cdda_length) & 0x000000ff);
28594                 cdb[9] = 0x10;
28595                 switch (cdda->cdda_subcode) {
28596                 case CDROM_DA_NO_SUBCODE :
28597                         cdb[10] = 0x0;
28598                         break;
28599                 case CDROM_DA_SUBQ :
28600                         cdb[10] = 0x2;
28601                         break;
28602                 case CDROM_DA_ALL_SUBCODE :
28603                         cdb[10] = 0x1;
28604                         break;
28605                 case CDROM_DA_SUBCODE_ONLY :
28606                         /* FALLTHROUGH */
28607                 default :
28608                         kmem_free(cdda, sizeof (struct cdrom_cdda));
28609                         kmem_free(com, sizeof (*com));
28610                         return (ENOTTY);
28611                 }
28612         } else {
28613                 cdb[0] = (char)SCMD_READ_CDDA;
28614                 cdb[2] = (((cdda->cdda_addr) & 0xff000000) >> 24);
28615                 cdb[3] = (((cdda->cdda_addr) & 0x00ff0000) >> 16);
28616                 cdb[4] = (((cdda->cdda_addr) & 0x0000ff00) >> 8);
28617                 cdb[5] = ((cdda->cdda_addr) & 0x000000ff);
28618                 cdb[6] = (((cdda->cdda_length) & 0xff000000) >> 24);
28619                 cdb[7] = (((cdda->cdda_length) & 0x00ff0000) >> 16);
28620                 cdb[8] = (((cdda->cdda_length) & 0x0000ff00) >> 8);
28621                 cdb[9] = ((cdda->cdda_length) & 0x000000ff);
28622                 cdb[10] = cdda->cdda_subcode;
28623         }
28624 
28625         com->uscsi_cdb = cdb;
28626         com->uscsi_cdblen = CDB_GROUP5;
28627         com->uscsi_bufaddr = (caddr_t)cdda->cdda_data;
28628         com->uscsi_buflen = buflen;
28629         com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
28630 
28631         rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_USERSPACE,
28632             SD_PATH_STANDARD);
28633 
28634         kmem_free(cdda, sizeof (struct cdrom_cdda));
28635         kmem_free(com, sizeof (*com));
28636         return (rval);
28637 }
28638 
28639 
28640 /*
28641  *    Function: sr_read_cdxa()
28642  *
28643  * Description: This routine is the driver entry point for handling CD-ROM
28644  *              ioctl requests to return CD-XA (Extended Architecture) data.
28645  *              (CDROMCDXA).
28646  *
28647  *   Arguments: dev     - the device 'dev_t'
28648  *              data    - pointer to user provided CD-XA structure specifying
28649  *                        the data starting address, transfer length, and format
28650  *              flag    - this argument is a pass through to ddi_copyxxx()
28651  *                        directly from the mode argument of ioctl().
28652  *
28653  * Return Code: the code returned by sd_send_scsi_cmd()
28654  *              EFAULT if ddi_copyxxx() fails
28655  *              ENXIO if fail ddi_get_soft_state
28656  *              EINVAL if data pointer is NULL
28657  */
28658 
28659 static int
28660 sr_read_cdxa(dev_t dev, caddr_t data, int flag)
28661 {
28662         struct sd_lun           *un;
28663         struct uscsi_cmd        *com;
28664         struct cdrom_cdxa       *cdxa;
28665         int                     rval;
28666         size_t                  buflen;
28667         char                    cdb[CDB_GROUP5];
28668         uchar_t                 read_flags;
28669 
28670 #ifdef _MULTI_DATAMODEL
28671         /* To support ILP32 applications in an LP64 world */
28672         struct cdrom_cdxa32             cdrom_cdxa32;
28673         struct cdrom_cdxa32             *cdxa32 = &cdrom_cdxa32;
28674 #endif /* _MULTI_DATAMODEL */
28675 
28676         if (data == NULL) {
28677                 return (EINVAL);
28678         }
28679 
28680         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
28681                 return (ENXIO);
28682         }
28683 
28684         cdxa = kmem_zalloc(sizeof (struct cdrom_cdxa), KM_SLEEP);
28685 
28686 #ifdef _MULTI_DATAMODEL
28687         switch (ddi_model_convert_from(flag & FMODELS)) {
28688         case DDI_MODEL_ILP32:
28689                 if (ddi_copyin(data, cdxa32, sizeof (*cdxa32), flag)) {
28690                         kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28691                         return (EFAULT);
28692                 }
28693                 /*
28694                  * Convert the ILP32 uscsi data from the
28695                  * application to LP64 for internal use.
28696                  */
28697                 cdrom_cdxa32tocdrom_cdxa(cdxa32, cdxa);
28698                 break;
28699         case DDI_MODEL_NONE:
28700                 if (ddi_copyin(data, cdxa, sizeof (struct cdrom_cdxa), flag)) {
28701                         kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28702                         return (EFAULT);
28703                 }
28704                 break;
28705         }
28706 #else /* ! _MULTI_DATAMODEL */
28707         if (ddi_copyin(data, cdxa, sizeof (struct cdrom_cdxa), flag)) {
28708                 kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28709                 return (EFAULT);
28710         }
28711 #endif /* _MULTI_DATAMODEL */
28712 
28713         /*
28714          * Since MMC-2 expects max 3 bytes for length, check if the
28715          * length input is greater than 3 bytes
28716          */
28717         if ((cdxa->cdxa_length & 0xFF000000) != 0) {
28718                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, "sr_read_cdxa: "
28719                     "cdrom transfer length too large: %d (limit %d)\n",
28720                     cdxa->cdxa_length, 0xFFFFFF);
28721                 kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28722                 return (EINVAL);
28723         }
28724 
28725         switch (cdxa->cdxa_format) {
28726         case CDROM_XA_DATA:
28727                 buflen = CDROM_BLK_2048 * cdxa->cdxa_length;
28728                 read_flags = 0x10;
28729                 break;
28730         case CDROM_XA_SECTOR_DATA:
28731                 buflen = CDROM_BLK_2352 * cdxa->cdxa_length;
28732                 read_flags = 0xf8;
28733                 break;
28734         case CDROM_XA_DATA_W_ERROR:
28735                 buflen = CDROM_BLK_2646 * cdxa->cdxa_length;
28736                 read_flags = 0xfc;
28737                 break;
28738         default:
28739                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
28740                     "sr_read_cdxa: Format '0x%x' Not Supported\n",
28741                     cdxa->cdxa_format);
28742                 kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28743                 return (EINVAL);
28744         }
28745 
28746         com = kmem_zalloc(sizeof (*com), KM_SLEEP);
28747         bzero(cdb, CDB_GROUP5);
28748         if (un->un_f_mmc_cap == TRUE) {
28749                 cdb[0] = (char)SCMD_READ_CD;
28750                 cdb[2] = (((cdxa->cdxa_addr) & 0xff000000) >> 24);
28751                 cdb[3] = (((cdxa->cdxa_addr) & 0x00ff0000) >> 16);
28752                 cdb[4] = (((cdxa->cdxa_addr) & 0x0000ff00) >> 8);
28753                 cdb[5] = ((cdxa->cdxa_addr) & 0x000000ff);
28754                 cdb[6] = (((cdxa->cdxa_length) & 0x00ff0000) >> 16);
28755                 cdb[7] = (((cdxa->cdxa_length) & 0x0000ff00) >> 8);
28756                 cdb[8] = ((cdxa->cdxa_length) & 0x000000ff);
28757                 cdb[9] = (char)read_flags;
28758         } else {
28759                 /*
28760                  * Note: A vendor specific command (0xDB) is being used her to
28761                  * request a read of all subcodes.
28762                  */
28763                 cdb[0] = (char)SCMD_READ_CDXA;
28764                 cdb[2] = (((cdxa->cdxa_addr) & 0xff000000) >> 24);
28765                 cdb[3] = (((cdxa->cdxa_addr) & 0x00ff0000) >> 16);
28766                 cdb[4] = (((cdxa->cdxa_addr) & 0x0000ff00) >> 8);
28767                 cdb[5] = ((cdxa->cdxa_addr) & 0x000000ff);
28768                 cdb[6] = (((cdxa->cdxa_length) & 0xff000000) >> 24);
28769                 cdb[7] = (((cdxa->cdxa_length) & 0x00ff0000) >> 16);
28770                 cdb[8] = (((cdxa->cdxa_length) & 0x0000ff00) >> 8);
28771                 cdb[9] = ((cdxa->cdxa_length) & 0x000000ff);
28772                 cdb[10] = cdxa->cdxa_format;
28773         }
28774         com->uscsi_cdb          = cdb;
28775         com->uscsi_cdblen  = CDB_GROUP5;
28776         com->uscsi_bufaddr = (caddr_t)cdxa->cdxa_data;
28777         com->uscsi_buflen  = buflen;
28778         com->uscsi_flags   = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
28779         rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_USERSPACE,
28780             SD_PATH_STANDARD);
28781         kmem_free(cdxa, sizeof (struct cdrom_cdxa));
28782         kmem_free(com, sizeof (*com));
28783         return (rval);
28784 }
28785 
28786 
28787 /*
28788  *    Function: sr_eject()
28789  *
28790  * Description: This routine is the driver entry point for handling CD-ROM
28791  *              eject ioctl requests (FDEJECT, DKIOCEJECT, CDROMEJECT)
28792  *
28793  *   Arguments: dev     - the device 'dev_t'
28794  *
28795  * Return Code: the code returned by sd_send_scsi_cmd()
28796  */
28797 
28798 static int
28799 sr_eject(dev_t dev)
28800 {
28801         struct sd_lun   *un;
28802         int             rval;
28803         sd_ssc_t        *ssc;
28804 
28805         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
28806             (un->un_state == SD_STATE_OFFLINE)) {
28807                 return (ENXIO);
28808         }
28809 
28810         /*
28811          * To prevent race conditions with the eject
28812          * command, keep track of an eject command as
28813          * it progresses. If we are already handling
28814          * an eject command in the driver for the given
28815          * unit and another request to eject is received
28816          * immediately return EAGAIN so we don't lose
28817          * the command if the current eject command fails.
28818          */
28819         mutex_enter(SD_MUTEX(un));
28820         if (un->un_f_ejecting == TRUE) {
28821                 mutex_exit(SD_MUTEX(un));
28822                 return (EAGAIN);
28823         }
28824         un->un_f_ejecting = TRUE;
28825         mutex_exit(SD_MUTEX(un));
28826 
28827         ssc = sd_ssc_init(un);
28828         rval = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_ALLOW,
28829             SD_PATH_STANDARD);
28830         sd_ssc_fini(ssc);
28831 
28832         if (rval != 0) {
28833                 mutex_enter(SD_MUTEX(un));
28834                 un->un_f_ejecting = FALSE;
28835                 mutex_exit(SD_MUTEX(un));
28836                 return (rval);
28837         }
28838 
28839         ssc = sd_ssc_init(un);
28840         rval = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP,
28841             SD_TARGET_EJECT, SD_PATH_STANDARD);
28842         sd_ssc_fini(ssc);
28843 
28844         if (rval == 0) {
28845                 mutex_enter(SD_MUTEX(un));
28846                 sr_ejected(un);
28847                 un->un_mediastate = DKIO_EJECTED;
28848                 un->un_f_ejecting = FALSE;
28849                 cv_broadcast(&un->un_state_cv);
28850                 mutex_exit(SD_MUTEX(un));
28851         } else {
28852                 mutex_enter(SD_MUTEX(un));
28853                 un->un_f_ejecting = FALSE;
28854                 mutex_exit(SD_MUTEX(un));
28855         }
28856         return (rval);
28857 }
28858 
28859 
28860 /*
28861  *    Function: sr_ejected()
28862  *
28863  * Description: This routine updates the soft state structure to invalidate the
28864  *              geometry information after the media has been ejected or a
28865  *              media eject has been detected.
28866  *
28867  *   Arguments: un - driver soft state (unit) structure
28868  */
28869 
28870 static void
28871 sr_ejected(struct sd_lun *un)
28872 {
28873         struct sd_errstats *stp;
28874 
28875         ASSERT(un != NULL);
28876         ASSERT(mutex_owned(SD_MUTEX(un)));
28877 
28878         un->un_f_blockcount_is_valid = FALSE;
28879         un->un_f_tgt_blocksize_is_valid      = FALSE;
28880         mutex_exit(SD_MUTEX(un));
28881         cmlb_invalidate(un->un_cmlbhandle, (void *)SD_PATH_DIRECT_PRIORITY);
28882         mutex_enter(SD_MUTEX(un));
28883 
28884         if (un->un_errstats != NULL) {
28885                 stp = (struct sd_errstats *)un->un_errstats->ks_data;
28886                 stp->sd_capacity.value.ui64 = 0;
28887         }
28888 }
28889 
28890 
28891 /*
28892  *    Function: sr_check_wp()
28893  *
28894  * Description: This routine checks the write protection of a removable
28895  *      media disk and hotpluggable devices via the write protect bit of
28896  *      the Mode Page Header device specific field. Some devices choke
28897  *      on unsupported mode page. In order to workaround this issue,
28898  *      this routine has been implemented to use 0x3f mode page(request
28899  *      for all pages) for all device types.
28900  *
28901  *   Arguments: dev             - the device 'dev_t'
28902  *
28903  * Return Code: int indicating if the device is write protected (1) or not (0)
28904  *
28905  *     Context: Kernel thread.
28906  *
28907  */
28908 
28909 static int
28910 sr_check_wp(dev_t dev)
28911 {
28912         struct sd_lun   *un;
28913         uchar_t         device_specific;
28914         uchar_t         *sense;
28915         int             hdrlen;
28916         int             rval = FALSE;
28917         int             status;
28918         sd_ssc_t        *ssc;
28919 
28920         /*
28921          * Note: The return codes for this routine should be reworked to
28922          * properly handle the case of a NULL softstate.
28923          */
28924         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) {
28925                 return (FALSE);
28926         }
28927 
28928         if (un->un_f_cfg_is_atapi == TRUE) {
28929                 /*
28930                  * The mode page contents are not required; set the allocation
28931                  * length for the mode page header only
28932                  */
28933                 hdrlen = MODE_HEADER_LENGTH_GRP2;
28934                 sense = kmem_zalloc(hdrlen, KM_SLEEP);
28935                 ssc = sd_ssc_init(un);
28936                 status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, sense, hdrlen,
28937                     MODEPAGE_ALLPAGES, SD_PATH_STANDARD);
28938                 sd_ssc_fini(ssc);
28939                 if (status != 0)
28940                         goto err_exit;
28941                 device_specific =
28942                     ((struct mode_header_grp2 *)sense)->device_specific;
28943         } else {
28944                 hdrlen = MODE_HEADER_LENGTH;
28945                 sense = kmem_zalloc(hdrlen, KM_SLEEP);
28946                 ssc = sd_ssc_init(un);
28947                 status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, sense, hdrlen,
28948                     MODEPAGE_ALLPAGES, SD_PATH_STANDARD);
28949                 sd_ssc_fini(ssc);
28950                 if (status != 0)
28951                         goto err_exit;
28952                 device_specific =
28953                     ((struct mode_header *)sense)->device_specific;
28954         }
28955 
28956 
28957         /*
28958          * Write protect mode sense failed; not all disks
28959          * understand this query. Return FALSE assuming that
28960          * these devices are not writable.
28961          */
28962         if (device_specific & WRITE_PROTECT) {
28963                 rval = TRUE;
28964         }
28965 
28966 err_exit:
28967         kmem_free(sense, hdrlen);
28968         return (rval);
28969 }
28970 
28971 /*
28972  *    Function: sr_volume_ctrl()
28973  *
28974  * Description: This routine is the driver entry point for handling CD-ROM
28975  *              audio output volume ioctl requests. (CDROMVOLCTRL)
28976  *
28977  *   Arguments: dev     - the device 'dev_t'
28978  *              data    - pointer to user audio volume control structure
28979  *              flag    - this argument is a pass through to ddi_copyxxx()
28980  *                        directly from the mode argument of ioctl().
28981  *
28982  * Return Code: the code returned by sd_send_scsi_cmd()
28983  *              EFAULT if ddi_copyxxx() fails
28984  *              ENXIO if fail ddi_get_soft_state
28985  *              EINVAL if data pointer is NULL
28986  *
28987  */
28988 
28989 static int
28990 sr_volume_ctrl(dev_t dev, caddr_t data, int flag)
28991 {
28992         struct sd_lun           *un;
28993         struct cdrom_volctrl    volume;
28994         struct cdrom_volctrl    *vol = &volume;
28995         uchar_t                 *sense_page;
28996         uchar_t                 *select_page;
28997         uchar_t                 *sense;
28998         uchar_t                 *select;
28999         int                     sense_buflen;
29000         int                     select_buflen;
29001         int                     rval;
29002         sd_ssc_t                *ssc;
29003 
29004         if (data == NULL) {
29005                 return (EINVAL);
29006         }
29007 
29008         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
29009             (un->un_state == SD_STATE_OFFLINE)) {
29010                 return (ENXIO);
29011         }
29012 
29013         if (ddi_copyin(data, vol, sizeof (struct cdrom_volctrl), flag)) {
29014                 return (EFAULT);
29015         }
29016 
29017         if ((un->un_f_cfg_is_atapi == TRUE) || (un->un_f_mmc_cap == TRUE)) {
29018                 struct mode_header_grp2         *sense_mhp;
29019                 struct mode_header_grp2         *select_mhp;
29020                 int                             bd_len;
29021 
29022                 sense_buflen = MODE_PARAM_LENGTH_GRP2 + MODEPAGE_AUDIO_CTRL_LEN;
29023                 select_buflen = MODE_HEADER_LENGTH_GRP2 +
29024                     MODEPAGE_AUDIO_CTRL_LEN;
29025                 sense  = kmem_zalloc(sense_buflen, KM_SLEEP);
29026                 select = kmem_zalloc(select_buflen, KM_SLEEP);
29027                 ssc = sd_ssc_init(un);
29028                 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, sense,
29029                     sense_buflen, MODEPAGE_AUDIO_CTRL,
29030                     SD_PATH_STANDARD);
29031                 sd_ssc_fini(ssc);
29032 
29033                 if (rval != 0) {
29034                         SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un,
29035                             "sr_volume_ctrl: Mode Sense Failed\n");
29036                         kmem_free(sense, sense_buflen);
29037                         kmem_free(select, select_buflen);
29038                         return (rval);
29039                 }
29040                 sense_mhp = (struct mode_header_grp2 *)sense;
29041                 select_mhp = (struct mode_header_grp2 *)select;
29042                 bd_len = (sense_mhp->bdesc_length_hi << 8) |
29043                     sense_mhp->bdesc_length_lo;
29044                 if (bd_len > MODE_BLK_DESC_LENGTH) {
29045                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29046                             "sr_volume_ctrl: Mode Sense returned invalid "
29047                             "block descriptor length\n");
29048                         kmem_free(sense, sense_buflen);
29049                         kmem_free(select, select_buflen);
29050                         return (EIO);
29051                 }
29052                 sense_page = (uchar_t *)
29053                     (sense + MODE_HEADER_LENGTH_GRP2 + bd_len);
29054                 select_page = (uchar_t *)(select + MODE_HEADER_LENGTH_GRP2);
29055                 select_mhp->length_msb = 0;
29056                 select_mhp->length_lsb = 0;
29057                 select_mhp->bdesc_length_hi = 0;
29058                 select_mhp->bdesc_length_lo = 0;
29059         } else {
29060                 struct mode_header              *sense_mhp, *select_mhp;
29061 
29062                 sense_buflen = MODE_PARAM_LENGTH + MODEPAGE_AUDIO_CTRL_LEN;
29063                 select_buflen = MODE_HEADER_LENGTH + MODEPAGE_AUDIO_CTRL_LEN;
29064                 sense  = kmem_zalloc(sense_buflen, KM_SLEEP);
29065                 select = kmem_zalloc(select_buflen, KM_SLEEP);
29066                 ssc = sd_ssc_init(un);
29067                 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, sense,
29068                     sense_buflen, MODEPAGE_AUDIO_CTRL,
29069                     SD_PATH_STANDARD);
29070                 sd_ssc_fini(ssc);
29071 
29072                 if (rval != 0) {
29073                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29074                             "sr_volume_ctrl: Mode Sense Failed\n");
29075                         kmem_free(sense, sense_buflen);
29076                         kmem_free(select, select_buflen);
29077                         return (rval);
29078                 }
29079                 sense_mhp  = (struct mode_header *)sense;
29080                 select_mhp = (struct mode_header *)select;
29081                 if (sense_mhp->bdesc_length > MODE_BLK_DESC_LENGTH) {
29082                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29083                             "sr_volume_ctrl: Mode Sense returned invalid "
29084                             "block descriptor length\n");
29085                         kmem_free(sense, sense_buflen);
29086                         kmem_free(select, select_buflen);
29087                         return (EIO);
29088                 }
29089                 sense_page = (uchar_t *)
29090                     (sense + MODE_HEADER_LENGTH + sense_mhp->bdesc_length);
29091                 select_page = (uchar_t *)(select + MODE_HEADER_LENGTH);
29092                 select_mhp->length = 0;
29093                 select_mhp->bdesc_length = 0;
29094         }
29095         /*
29096          * Note: An audio control data structure could be created and overlayed
29097          * on the following in place of the array indexing method implemented.
29098          */
29099 
29100         /* Build the select data for the user volume data */
29101         select_page[0] = MODEPAGE_AUDIO_CTRL;
29102         select_page[1] = 0xE;
29103         /* Set the immediate bit */
29104         select_page[2] = 0x04;
29105         /* Zero out reserved fields */
29106         select_page[3] = 0x00;
29107         select_page[4] = 0x00;
29108         /* Return sense data for fields not to be modified */
29109         select_page[5] = sense_page[5];
29110         select_page[6] = sense_page[6];
29111         select_page[7] = sense_page[7];
29112         /* Set the user specified volume levels for channel 0 and 1 */
29113         select_page[8] = 0x01;
29114         select_page[9] = vol->channel0;
29115         select_page[10] = 0x02;
29116         select_page[11] = vol->channel1;
29117         /* Channel 2 and 3 are currently unsupported so return the sense data */
29118         select_page[12] = sense_page[12];
29119         select_page[13] = sense_page[13];
29120         select_page[14] = sense_page[14];
29121         select_page[15] = sense_page[15];
29122 
29123         ssc = sd_ssc_init(un);
29124         if ((un->un_f_cfg_is_atapi == TRUE) || (un->un_f_mmc_cap == TRUE)) {
29125                 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP1, select,
29126                     select_buflen, SD_DONTSAVE_PAGE, SD_PATH_STANDARD);
29127         } else {
29128                 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, select,
29129                     select_buflen, SD_DONTSAVE_PAGE, SD_PATH_STANDARD);
29130         }
29131         sd_ssc_fini(ssc);
29132 
29133         kmem_free(sense, sense_buflen);
29134         kmem_free(select, select_buflen);
29135         return (rval);
29136 }
29137 
29138 
29139 /*
29140  *    Function: sr_read_sony_session_offset()
29141  *
29142  * Description: This routine is the driver entry point for handling CD-ROM
29143  *              ioctl requests for session offset information. (CDROMREADOFFSET)
29144  *              The address of the first track in the last session of a
29145  *              multi-session CD-ROM is returned
29146  *
29147  *              Note: This routine uses a vendor specific key value in the
29148  *              command control field without implementing any vendor check here
29149  *              or in the ioctl routine.
29150  *
29151  *   Arguments: dev     - the device 'dev_t'
29152  *              data    - pointer to an int to hold the requested address
29153  *              flag    - this argument is a pass through to ddi_copyxxx()
29154  *                        directly from the mode argument of ioctl().
29155  *
29156  * Return Code: the code returned by sd_send_scsi_cmd()
29157  *              EFAULT if ddi_copyxxx() fails
29158  *              ENXIO if fail ddi_get_soft_state
29159  *              EINVAL if data pointer is NULL
29160  */
29161 
29162 static int
29163 sr_read_sony_session_offset(dev_t dev, caddr_t data, int flag)
29164 {
29165         struct sd_lun           *un;
29166         struct uscsi_cmd        *com;
29167         caddr_t                 buffer;
29168         char                    cdb[CDB_GROUP1];
29169         int                     session_offset = 0;
29170         int                     rval;
29171 
29172         if (data == NULL) {
29173                 return (EINVAL);
29174         }
29175 
29176         if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL ||
29177             (un->un_state == SD_STATE_OFFLINE)) {
29178                 return (ENXIO);
29179         }
29180 
29181         buffer = kmem_zalloc((size_t)SONY_SESSION_OFFSET_LEN, KM_SLEEP);
29182         bzero(cdb, CDB_GROUP1);
29183         cdb[0] = SCMD_READ_TOC;
29184         /*
29185          * Bytes 7 & 8 are the 12 byte allocation length for a single entry.
29186          * (4 byte TOC response header + 8 byte response data)
29187          */
29188         cdb[8] = SONY_SESSION_OFFSET_LEN;
29189         /* Byte 9 is the control byte. A vendor specific value is used */
29190         cdb[9] = SONY_SESSION_OFFSET_KEY;
29191         com = kmem_zalloc(sizeof (*com), KM_SLEEP);
29192         com->uscsi_cdb = cdb;
29193         com->uscsi_cdblen = CDB_GROUP1;
29194         com->uscsi_bufaddr = buffer;
29195         com->uscsi_buflen = SONY_SESSION_OFFSET_LEN;
29196         com->uscsi_flags = USCSI_DIAGNOSE|USCSI_SILENT|USCSI_READ;
29197 
29198         rval = sd_send_scsi_cmd(dev, com, FKIOCTL, UIO_SYSSPACE,
29199             SD_PATH_STANDARD);
29200         if (rval != 0) {
29201                 kmem_free(buffer, SONY_SESSION_OFFSET_LEN);
29202                 kmem_free(com, sizeof (*com));
29203                 return (rval);
29204         }
29205         if (buffer[1] == SONY_SESSION_OFFSET_VALID) {
29206                 session_offset =
29207                     ((uchar_t)buffer[8] << 24) + ((uchar_t)buffer[9] << 16) +
29208                     ((uchar_t)buffer[10] << 8) + ((uchar_t)buffer[11]);
29209                 /*
29210                  * Offset returned offset in current lbasize block's. Convert to
29211                  * 2k block's to return to the user
29212                  */
29213                 if (un->un_tgt_blocksize == CDROM_BLK_512) {
29214                         session_offset >>= 2;
29215                 } else if (un->un_tgt_blocksize == CDROM_BLK_1024) {
29216                         session_offset >>= 1;
29217                 }
29218         }
29219 
29220         if (ddi_copyout(&session_offset, data, sizeof (int), flag) != 0) {
29221                 rval = EFAULT;
29222         }
29223 
29224         kmem_free(buffer, SONY_SESSION_OFFSET_LEN);
29225         kmem_free(com, sizeof (*com));
29226         return (rval);
29227 }
29228 
29229 
29230 /*
29231  *    Function: sd_wm_cache_constructor()
29232  *
29233  * Description: Cache Constructor for the wmap cache for the read/modify/write
29234  *              devices.
29235  *
29236  *   Arguments: wm      - A pointer to the sd_w_map to be initialized.
29237  *              un      - sd_lun structure for the device.
29238  *              flag    - the km flags passed to constructor
29239  *
29240  * Return Code: 0 on success.
29241  *              -1 on failure.
29242  */
29243 
29244 /*ARGSUSED*/
29245 static int
29246 sd_wm_cache_constructor(void *wm, void *un, int flags)
29247 {
29248         bzero(wm, sizeof (struct sd_w_map));
29249         cv_init(&((struct sd_w_map *)wm)->wm_avail, NULL, CV_DRIVER, NULL);
29250         return (0);
29251 }
29252 
29253 
29254 /*
29255  *    Function: sd_wm_cache_destructor()
29256  *
29257  * Description: Cache destructor for the wmap cache for the read/modify/write
29258  *              devices.
29259  *
29260  *   Arguments: wm      - A pointer to the sd_w_map to be initialized.
29261  *              un      - sd_lun structure for the device.
29262  */
29263 /*ARGSUSED*/
29264 static void
29265 sd_wm_cache_destructor(void *wm, void *un)
29266 {
29267         cv_destroy(&((struct sd_w_map *)wm)->wm_avail);
29268 }
29269 
29270 
29271 /*
29272  *    Function: sd_range_lock()
29273  *
29274  * Description: Lock the range of blocks specified as parameter to ensure
29275  *              that read, modify write is atomic and no other i/o writes
29276  *              to the same location. The range is specified in terms
29277  *              of start and end blocks. Block numbers are the actual
29278  *              media block numbers and not system.
29279  *
29280  *   Arguments: un      - sd_lun structure for the device.
29281  *              startb - The starting block number
29282  *              endb - The end block number
29283  *              typ - type of i/o - simple/read_modify_write
29284  *
29285  * Return Code: wm  - pointer to the wmap structure.
29286  *
29287  *     Context: This routine can sleep.
29288  */
29289 
29290 static struct sd_w_map *
29291 sd_range_lock(struct sd_lun *un, daddr_t startb, daddr_t endb, ushort_t typ)
29292 {
29293         struct sd_w_map *wmp = NULL;
29294         struct sd_w_map *sl_wmp = NULL;
29295         struct sd_w_map *tmp_wmp;
29296         wm_state state = SD_WM_CHK_LIST;
29297 
29298 
29299         ASSERT(un != NULL);
29300         ASSERT(!mutex_owned(SD_MUTEX(un)));
29301 
29302         mutex_enter(SD_MUTEX(un));
29303 
29304         while (state != SD_WM_DONE) {
29305 
29306                 switch (state) {
29307                 case SD_WM_CHK_LIST:
29308                         /*
29309                          * This is the starting state. Check the wmap list
29310                          * to see if the range is currently available.
29311                          */
29312                         if (!(typ & SD_WTYPE_RMW) && !(un->un_rmw_count)) {
29313                                 /*
29314                                  * If this is a simple write and no rmw
29315                                  * i/o is pending then try to lock the
29316                                  * range as the range should be available.
29317                                  */
29318                                 state = SD_WM_LOCK_RANGE;
29319                         } else {
29320                                 tmp_wmp = sd_get_range(un, startb, endb);
29321                                 if (tmp_wmp != NULL) {
29322                                         if ((wmp != NULL) && ONLIST(un, wmp)) {
29323                                                 /*
29324                                                  * Should not keep onlist wmps
29325                                                  * while waiting this macro
29326                                                  * will also do wmp = NULL;
29327                                                  */
29328                                                 FREE_ONLIST_WMAP(un, wmp);
29329                                         }
29330                                         /*
29331                                          * sl_wmp is the wmap on which wait
29332                                          * is done, since the tmp_wmp points
29333                                          * to the inuse wmap, set sl_wmp to
29334                                          * tmp_wmp and change the state to sleep
29335                                          */
29336                                         sl_wmp = tmp_wmp;
29337                                         state = SD_WM_WAIT_MAP;
29338                                 } else {
29339                                         state = SD_WM_LOCK_RANGE;
29340                                 }
29341 
29342                         }
29343                         break;
29344 
29345                 case SD_WM_LOCK_RANGE:
29346                         ASSERT(un->un_wm_cache);
29347                         /*
29348                          * The range need to be locked, try to get a wmap.
29349                          * First attempt it with NO_SLEEP, want to avoid a sleep
29350                          * if possible as we will have to release the sd mutex
29351                          * if we have to sleep.
29352                          */
29353                         if (wmp == NULL)
29354                                 wmp = kmem_cache_alloc(un->un_wm_cache,
29355                                     KM_NOSLEEP);
29356                         if (wmp == NULL) {
29357                                 mutex_exit(SD_MUTEX(un));
29358                                 _NOTE(DATA_READABLE_WITHOUT_LOCK
29359                                     (sd_lun::un_wm_cache))
29360                                 wmp = kmem_cache_alloc(un->un_wm_cache,
29361                                     KM_SLEEP);
29362                                 mutex_enter(SD_MUTEX(un));
29363                                 /*
29364                                  * we released the mutex so recheck and go to
29365                                  * check list state.
29366                                  */
29367                                 state = SD_WM_CHK_LIST;
29368                         } else {
29369                                 /*
29370                                  * We exit out of state machine since we
29371                                  * have the wmap. Do the housekeeping first.
29372                                  * place the wmap on the wmap list if it is not
29373                                  * on it already and then set the state to done.
29374                                  */
29375                                 wmp->wm_start = startb;
29376                                 wmp->wm_end = endb;
29377                                 wmp->wm_flags = typ | SD_WM_BUSY;
29378                                 if (typ & SD_WTYPE_RMW) {
29379                                         un->un_rmw_count++;
29380                                 }
29381                                 /*
29382                                  * If not already on the list then link
29383                                  */
29384                                 if (!ONLIST(un, wmp)) {
29385                                         wmp->wm_next = un->un_wm;
29386                                         wmp->wm_prev = NULL;
29387                                         if (wmp->wm_next)
29388                                                 wmp->wm_next->wm_prev = wmp;
29389                                         un->un_wm = wmp;
29390                                 }
29391                                 state = SD_WM_DONE;
29392                         }
29393                         break;
29394 
29395                 case SD_WM_WAIT_MAP:
29396                         ASSERT(sl_wmp->wm_flags & SD_WM_BUSY);
29397                         /*
29398                          * Wait is done on sl_wmp, which is set in the
29399                          * check_list state.
29400                          */
29401                         sl_wmp->wm_wanted_count++;
29402                         cv_wait(&sl_wmp->wm_avail, SD_MUTEX(un));
29403                         sl_wmp->wm_wanted_count--;
29404                         /*
29405                          * We can reuse the memory from the completed sl_wmp
29406                          * lock range for our new lock, but only if noone is
29407                          * waiting for it.
29408                          */
29409                         ASSERT(!(sl_wmp->wm_flags & SD_WM_BUSY));
29410                         if (sl_wmp->wm_wanted_count == 0) {
29411                                 if (wmp != NULL)
29412                                         CHK_N_FREEWMP(un, wmp);
29413                                 wmp = sl_wmp;
29414                         }
29415                         sl_wmp = NULL;
29416                         /*
29417                          * After waking up, need to recheck for availability of
29418                          * range.
29419                          */
29420                         state = SD_WM_CHK_LIST;
29421                         break;
29422 
29423                 default:
29424                         panic("sd_range_lock: "
29425                             "Unknown state %d in sd_range_lock", state);
29426                         /*NOTREACHED*/
29427                 } /* switch(state) */
29428 
29429         } /* while(state != SD_WM_DONE) */
29430 
29431         mutex_exit(SD_MUTEX(un));
29432 
29433         ASSERT(wmp != NULL);
29434 
29435         return (wmp);
29436 }
29437 
29438 
29439 /*
29440  *    Function: sd_get_range()
29441  *
29442  * Description: Find if there any overlapping I/O to this one
29443  *              Returns the write-map of 1st such I/O, NULL otherwise.
29444  *
29445  *   Arguments: un      - sd_lun structure for the device.
29446  *              startb - The starting block number
29447  *              endb - The end block number
29448  *
29449  * Return Code: wm  - pointer to the wmap structure.
29450  */
29451 
29452 static struct sd_w_map *
29453 sd_get_range(struct sd_lun *un, daddr_t startb, daddr_t endb)
29454 {
29455         struct sd_w_map *wmp;
29456 
29457         ASSERT(un != NULL);
29458 
29459         for (wmp = un->un_wm; wmp != NULL; wmp = wmp->wm_next) {
29460                 if (!(wmp->wm_flags & SD_WM_BUSY)) {
29461                         continue;
29462                 }
29463                 if ((startb >= wmp->wm_start) && (startb <= wmp->wm_end)) {
29464                         break;
29465                 }
29466                 if ((endb >= wmp->wm_start) && (endb <= wmp->wm_end)) {
29467                         break;
29468                 }
29469         }
29470 
29471         return (wmp);
29472 }
29473 
29474 
29475 /*
29476  *    Function: sd_free_inlist_wmap()
29477  *
29478  * Description: Unlink and free a write map struct.
29479  *
29480  *   Arguments: un      - sd_lun structure for the device.
29481  *              wmp     - sd_w_map which needs to be unlinked.
29482  */
29483 
29484 static void
29485 sd_free_inlist_wmap(struct sd_lun *un, struct sd_w_map *wmp)
29486 {
29487         ASSERT(un != NULL);
29488 
29489         if (un->un_wm == wmp) {
29490                 un->un_wm = wmp->wm_next;
29491         } else {
29492                 wmp->wm_prev->wm_next = wmp->wm_next;
29493         }
29494 
29495         if (wmp->wm_next) {
29496                 wmp->wm_next->wm_prev = wmp->wm_prev;
29497         }
29498 
29499         wmp->wm_next = wmp->wm_prev = NULL;
29500 
29501         kmem_cache_free(un->un_wm_cache, wmp);
29502 }
29503 
29504 
29505 /*
29506  *    Function: sd_range_unlock()
29507  *
29508  * Description: Unlock the range locked by wm.
29509  *              Free write map if nobody else is waiting on it.
29510  *
29511  *   Arguments: un      - sd_lun structure for the device.
29512  *              wmp     - sd_w_map which needs to be unlinked.
29513  */
29514 
29515 static void
29516 sd_range_unlock(struct sd_lun *un, struct sd_w_map *wm)
29517 {
29518         ASSERT(un != NULL);
29519         ASSERT(wm != NULL);
29520         ASSERT(!mutex_owned(SD_MUTEX(un)));
29521 
29522         mutex_enter(SD_MUTEX(un));
29523 
29524         if (wm->wm_flags & SD_WTYPE_RMW) {
29525                 un->un_rmw_count--;
29526         }
29527 
29528         if (wm->wm_wanted_count) {
29529                 wm->wm_flags = 0;
29530                 /*
29531                  * Broadcast that the wmap is available now.
29532                  */
29533                 cv_broadcast(&wm->wm_avail);
29534         } else {
29535                 /*
29536                  * If no one is waiting on the map, it should be free'ed.
29537                  */
29538                 sd_free_inlist_wmap(un, wm);
29539         }
29540 
29541         mutex_exit(SD_MUTEX(un));
29542 }
29543 
29544 
29545 /*
29546  *    Function: sd_read_modify_write_task
29547  *
29548  * Description: Called from a taskq thread to initiate the write phase of
29549  *              a read-modify-write request.  This is used for targets where
29550  *              un->un_sys_blocksize != un->un_tgt_blocksize.
29551  *
29552  *   Arguments: arg - a pointer to the buf(9S) struct for the write command.
29553  *
29554  *     Context: Called under taskq thread context.
29555  */
29556 
29557 static void
29558 sd_read_modify_write_task(void *arg)
29559 {
29560         struct sd_mapblocksize_info     *bsp;
29561         struct buf      *bp;
29562         struct sd_xbuf  *xp;
29563         struct sd_lun   *un;
29564 
29565         bp = arg;       /* The bp is given in arg */
29566         ASSERT(bp != NULL);
29567 
29568         /* Get the pointer to the layer-private data struct */
29569         xp = SD_GET_XBUF(bp);
29570         ASSERT(xp != NULL);
29571         bsp = xp->xb_private;
29572         ASSERT(bsp != NULL);
29573 
29574         un = SD_GET_UN(bp);
29575         ASSERT(un != NULL);
29576         ASSERT(!mutex_owned(SD_MUTEX(un)));
29577 
29578         SD_TRACE(SD_LOG_IO_RMMEDIA, un,
29579             "sd_read_modify_write_task: entry: buf:0x%p\n", bp);
29580 
29581         /*
29582          * This is the write phase of a read-modify-write request, called
29583          * under the context of a taskq thread in response to the completion
29584          * of the read portion of the rmw request completing under interrupt
29585          * context. The write request must be sent from here down the iostart
29586          * chain as if it were being sent from sd_mapblocksize_iostart(), so
29587          * we use the layer index saved in the layer-private data area.
29588          */
29589         SD_NEXT_IOSTART(bsp->mbs_layer_index, un, bp);
29590 
29591         SD_TRACE(SD_LOG_IO_RMMEDIA, un,
29592             "sd_read_modify_write_task: exit: buf:0x%p\n", bp);
29593 }
29594 
29595 
29596 /*
29597  *    Function: sddump_do_read_of_rmw()
29598  *
29599  * Description: This routine will be called from sddump, If sddump is called
29600  *              with an I/O which not aligned on device blocksize boundary
29601  *              then the write has to be converted to read-modify-write.
29602  *              Do the read part here in order to keep sddump simple.
29603  *              Note - That the sd_mutex is held across the call to this
29604  *              routine.
29605  *
29606  *   Arguments: un      - sd_lun
29607  *              blkno   - block number in terms of media block size.
29608  *              nblk    - number of blocks.
29609  *              bpp     - pointer to pointer to the buf structure. On return
29610  *                      from this function, *bpp points to the valid buffer
29611  *                      to which the write has to be done.
29612  *
29613  * Return Code: 0 for success or errno-type return code
29614  */
29615 
29616 static int
29617 sddump_do_read_of_rmw(struct sd_lun *un, uint64_t blkno, uint64_t nblk,
29618         struct buf **bpp)
29619 {
29620         int err;
29621         int i;
29622         int rval;
29623         struct buf *bp;
29624         struct scsi_pkt *pkt = NULL;
29625         uint32_t target_blocksize;
29626 
29627         ASSERT(un != NULL);
29628         ASSERT(mutex_owned(SD_MUTEX(un)));
29629 
29630         target_blocksize = un->un_tgt_blocksize;
29631 
29632         mutex_exit(SD_MUTEX(un));
29633 
29634         bp = scsi_alloc_consistent_buf(SD_ADDRESS(un), (struct buf *)NULL,
29635             (size_t)(nblk * target_blocksize), B_READ, NULL_FUNC, NULL);
29636         if (bp == NULL) {
29637                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29638                     "no resources for dumping; giving up");
29639                 err = ENOMEM;
29640                 goto done;
29641         }
29642 
29643         rval = sd_setup_rw_pkt(un, &pkt, bp, 0, NULL_FUNC, NULL,
29644             blkno, nblk);
29645         if (rval != 0) {
29646                 scsi_free_consistent_buf(bp);
29647                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29648                     "no resources for dumping; giving up");
29649                 err = ENOMEM;
29650                 goto done;
29651         }
29652 
29653         pkt->pkt_flags |= FLAG_NOINTR;
29654 
29655         err = EIO;
29656         for (i = 0; i < SD_NDUMP_RETRIES; i++) {
29657 
29658                 /*
29659                  * Scsi_poll returns 0 (success) if the command completes and
29660                  * the status block is STATUS_GOOD.  We should only check
29661                  * errors if this condition is not true.  Even then we should
29662                  * send our own request sense packet only if we have a check
29663                  * condition and auto request sense has not been performed by
29664                  * the hba.
29665                  */
29666                 SD_TRACE(SD_LOG_DUMP, un, "sddump: sending read\n");
29667 
29668                 if ((sd_scsi_poll(un, pkt) == 0) && (pkt->pkt_resid == 0)) {
29669                         err = 0;
29670                         break;
29671                 }
29672 
29673                 /*
29674                  * Check CMD_DEV_GONE 1st, give up if device is gone,
29675                  * no need to read RQS data.
29676                  */
29677                 if (pkt->pkt_reason == CMD_DEV_GONE) {
29678                         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29679                             "Error while dumping state with rmw..."
29680                             "Device is gone\n");
29681                         break;
29682                 }
29683 
29684                 if (SD_GET_PKT_STATUS(pkt) == STATUS_CHECK) {
29685                         SD_INFO(SD_LOG_DUMP, un,
29686                             "sddump: read failed with CHECK, try # %d\n", i);
29687                         if (((pkt->pkt_state & STATE_ARQ_DONE) == 0)) {
29688                                 (void) sd_send_polled_RQS(un);
29689                         }
29690 
29691                         continue;
29692                 }
29693 
29694                 if (SD_GET_PKT_STATUS(pkt) == STATUS_BUSY) {
29695                         int reset_retval = 0;
29696 
29697                         SD_INFO(SD_LOG_DUMP, un,
29698                             "sddump: read failed with BUSY, try # %d\n", i);
29699 
29700                         if (un->un_f_lun_reset_enabled == TRUE) {
29701                                 reset_retval = scsi_reset(SD_ADDRESS(un),
29702                                     RESET_LUN);
29703                         }
29704                         if (reset_retval == 0) {
29705                                 (void) scsi_reset(SD_ADDRESS(un), RESET_TARGET);
29706                         }
29707                         (void) sd_send_polled_RQS(un);
29708 
29709                 } else {
29710                         SD_INFO(SD_LOG_DUMP, un,
29711                             "sddump: read failed with 0x%x, try # %d\n",
29712                             SD_GET_PKT_STATUS(pkt), i);
29713                         mutex_enter(SD_MUTEX(un));
29714                         sd_reset_target(un, pkt);
29715                         mutex_exit(SD_MUTEX(un));
29716                 }
29717 
29718                 /*
29719                  * If we are not getting anywhere with lun/target resets,
29720                  * let's reset the bus.
29721                  */
29722                 if (i > SD_NDUMP_RETRIES/2) {
29723                         (void) scsi_reset(SD_ADDRESS(un), RESET_ALL);
29724                         (void) sd_send_polled_RQS(un);
29725                 }
29726 
29727         }
29728         scsi_destroy_pkt(pkt);
29729 
29730         if (err != 0) {
29731                 scsi_free_consistent_buf(bp);
29732                 *bpp = NULL;
29733         } else {
29734                 *bpp = bp;
29735         }
29736 
29737 done:
29738         mutex_enter(SD_MUTEX(un));
29739         return (err);
29740 }
29741 
29742 
29743 /*
29744  *    Function: sd_failfast_flushq
29745  *
29746  * Description: Take all bp's on the wait queue that have B_FAILFAST set
29747  *              in b_flags and move them onto the failfast queue, then kick
29748  *              off a thread to return all bp's on the failfast queue to
29749  *              their owners with an error set.
29750  *
29751  *   Arguments: un - pointer to the soft state struct for the instance.
29752  *
29753  *     Context: may execute in interrupt context.
29754  */
29755 
29756 static void
29757 sd_failfast_flushq(struct sd_lun *un)
29758 {
29759         struct buf *bp;
29760         struct buf *next_waitq_bp;
29761         struct buf *prev_waitq_bp = NULL;
29762 
29763         ASSERT(un != NULL);
29764         ASSERT(mutex_owned(SD_MUTEX(un)));
29765         ASSERT(un->un_failfast_state == SD_FAILFAST_ACTIVE);
29766         ASSERT(un->un_failfast_bp == NULL);
29767 
29768         SD_TRACE(SD_LOG_IO_FAILFAST, un,
29769             "sd_failfast_flushq: entry: un:0x%p\n", un);
29770 
29771         /*
29772          * Check if we should flush all bufs when entering failfast state, or
29773          * just those with B_FAILFAST set.
29774          */
29775         if (sd_failfast_flushctl & SD_FAILFAST_FLUSH_ALL_BUFS) {
29776                 /*
29777                  * Move *all* bp's on the wait queue to the failfast flush
29778                  * queue, including those that do NOT have B_FAILFAST set.
29779                  */
29780                 if (un->un_failfast_headp == NULL) {
29781                         ASSERT(un->un_failfast_tailp == NULL);
29782                         un->un_failfast_headp = un->un_waitq_headp;
29783                 } else {
29784                         ASSERT(un->un_failfast_tailp != NULL);
29785                         un->un_failfast_tailp->av_forw = un->un_waitq_headp;
29786                 }
29787 
29788                 un->un_failfast_tailp = un->un_waitq_tailp;
29789 
29790                 /* update kstat for each bp moved out of the waitq */
29791                 for (bp = un->un_waitq_headp; bp != NULL; bp = bp->av_forw) {
29792                         SD_UPDATE_KSTATS(un, kstat_waitq_exit, bp);
29793                 }
29794 
29795                 /* empty the waitq */
29796                 un->un_waitq_headp = un->un_waitq_tailp = NULL;
29797 
29798         } else {
29799                 /*
29800                  * Go thru the wait queue, pick off all entries with
29801                  * B_FAILFAST set, and move these onto the failfast queue.
29802                  */
29803                 for (bp = un->un_waitq_headp; bp != NULL; bp = next_waitq_bp) {
29804                         /*
29805                          * Save the pointer to the next bp on the wait queue,
29806                          * so we get to it on the next iteration of this loop.
29807                          */
29808                         next_waitq_bp = bp->av_forw;
29809 
29810                         /*
29811                          * If this bp from the wait queue does NOT have
29812                          * B_FAILFAST set, just move on to the next element
29813                          * in the wait queue. Note, this is the only place
29814                          * where it is correct to set prev_waitq_bp.
29815                          */
29816                         if ((bp->b_flags & B_FAILFAST) == 0) {
29817                                 prev_waitq_bp = bp;
29818                                 continue;
29819                         }
29820 
29821                         /*
29822                          * Remove the bp from the wait queue.
29823                          */
29824                         if (bp == un->un_waitq_headp) {
29825                                 /* The bp is the first element of the waitq. */
29826                                 un->un_waitq_headp = next_waitq_bp;
29827                                 if (un->un_waitq_headp == NULL) {
29828                                         /* The wait queue is now empty */
29829                                         un->un_waitq_tailp = NULL;
29830                                 }
29831                         } else {
29832                                 /*
29833                                  * The bp is either somewhere in the middle
29834                                  * or at the end of the wait queue.
29835                                  */
29836                                 ASSERT(un->un_waitq_headp != NULL);
29837                                 ASSERT(prev_waitq_bp != NULL);
29838                                 ASSERT((prev_waitq_bp->b_flags & B_FAILFAST)
29839                                     == 0);
29840                                 if (bp == un->un_waitq_tailp) {
29841                                         /* bp is the last entry on the waitq. */
29842                                         ASSERT(next_waitq_bp == NULL);
29843                                         un->un_waitq_tailp = prev_waitq_bp;
29844                                 }
29845                                 prev_waitq_bp->av_forw = next_waitq_bp;
29846                         }
29847                         bp->av_forw = NULL;
29848 
29849                         /*
29850                          * update kstat since the bp is moved out of
29851                          * the waitq
29852                          */
29853                         SD_UPDATE_KSTATS(un, kstat_waitq_exit, bp);
29854 
29855                         /*
29856                          * Now put the bp onto the failfast queue.
29857                          */
29858                         if (un->un_failfast_headp == NULL) {
29859                                 /* failfast queue is currently empty */
29860                                 ASSERT(un->un_failfast_tailp == NULL);
29861                                 un->un_failfast_headp =
29862                                     un->un_failfast_tailp = bp;
29863                         } else {
29864                                 /* Add the bp to the end of the failfast q */
29865                                 ASSERT(un->un_failfast_tailp != NULL);
29866                                 ASSERT(un->un_failfast_tailp->b_flags &
29867                                     B_FAILFAST);
29868                                 un->un_failfast_tailp->av_forw = bp;
29869                                 un->un_failfast_tailp = bp;
29870                         }
29871                 }
29872         }
29873 
29874         /*
29875          * Now return all bp's on the failfast queue to their owners.
29876          */
29877         while ((bp = un->un_failfast_headp) != NULL) {
29878 
29879                 un->un_failfast_headp = bp->av_forw;
29880                 if (un->un_failfast_headp == NULL) {
29881                         un->un_failfast_tailp = NULL;
29882                 }
29883 
29884                 /*
29885                  * We want to return the bp with a failure error code, but
29886                  * we do not want a call to sd_start_cmds() to occur here,
29887                  * so use sd_return_failed_command_no_restart() instead of
29888                  * sd_return_failed_command().
29889                  */
29890                 sd_return_failed_command_no_restart(un, bp, EIO);
29891         }
29892 
29893         /* Flush the xbuf queues if required. */
29894         if (sd_failfast_flushctl & SD_FAILFAST_FLUSH_ALL_QUEUES) {
29895                 ddi_xbuf_flushq(un->un_xbuf_attr, sd_failfast_flushq_callback);
29896         }
29897 
29898         SD_TRACE(SD_LOG_IO_FAILFAST, un,
29899             "sd_failfast_flushq: exit: un:0x%p\n", un);
29900 }
29901 
29902 
29903 /*
29904  *    Function: sd_failfast_flushq_callback
29905  *
29906  * Description: Return TRUE if the given bp meets the criteria for failfast
29907  *              flushing. Used with ddi_xbuf_flushq(9F).
29908  *
29909  *   Arguments: bp - ptr to buf struct to be examined.
29910  *
29911  *     Context: Any
29912  */
29913 
29914 static int
29915 sd_failfast_flushq_callback(struct buf *bp)
29916 {
29917         /*
29918          * Return TRUE if (1) we want to flush ALL bufs when the failfast
29919          * state is entered; OR (2) the given bp has B_FAILFAST set.
29920          */
29921         return (((sd_failfast_flushctl & SD_FAILFAST_FLUSH_ALL_BUFS) ||
29922             (bp->b_flags & B_FAILFAST)) ? TRUE : FALSE);
29923 }
29924 
29925 
29926 
29927 /*
29928  * Function: sd_setup_next_xfer
29929  *
29930  * Description: Prepare next I/O operation using DMA_PARTIAL
29931  *
29932  */
29933 
29934 static int
29935 sd_setup_next_xfer(struct sd_lun *un, struct buf *bp,
29936     struct scsi_pkt *pkt, struct sd_xbuf *xp)
29937 {
29938         ssize_t num_blks_not_xfered;
29939         daddr_t strt_blk_num;
29940         ssize_t bytes_not_xfered;
29941         int     rval;
29942 
29943         ASSERT(pkt->pkt_resid == 0);
29944 
29945         /*
29946          * Calculate next block number and amount to be transferred.
29947          *
29948          * How much data NOT transfered to the HBA yet.
29949          */
29950         bytes_not_xfered = xp->xb_dma_resid;
29951 
29952         /*
29953          * figure how many blocks NOT transfered to the HBA yet.
29954          */
29955         num_blks_not_xfered = SD_BYTES2TGTBLOCKS(un, bytes_not_xfered);
29956 
29957         /*
29958          * set starting block number to the end of what WAS transfered.
29959          */
29960         strt_blk_num = xp->xb_blkno +
29961             SD_BYTES2TGTBLOCKS(un, bp->b_bcount - bytes_not_xfered);
29962 
29963         /*
29964          * Move pkt to the next portion of the xfer.  sd_setup_next_rw_pkt
29965          * will call scsi_initpkt with NULL_FUNC so we do not have to release
29966          * the disk mutex here.
29967          */
29968         rval = sd_setup_next_rw_pkt(un, pkt, bp,
29969             strt_blk_num, num_blks_not_xfered);
29970 
29971         if (rval == 0) {
29972 
29973                 /*
29974                  * Success.
29975                  *
29976                  * Adjust things if there are still more blocks to be
29977                  * transfered.
29978                  */
29979                 xp->xb_dma_resid = pkt->pkt_resid;
29980                 pkt->pkt_resid = 0;
29981 
29982                 return (1);
29983         }
29984 
29985         /*
29986          * There's really only one possible return value from
29987          * sd_setup_next_rw_pkt which occurs when scsi_init_pkt
29988          * returns NULL.
29989          */
29990         ASSERT(rval == SD_PKT_ALLOC_FAILURE);
29991 
29992         bp->b_resid = bp->b_bcount;
29993         bp->b_flags |= B_ERROR;
29994 
29995         scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
29996             "Error setting up next portion of DMA transfer\n");
29997 
29998         return (0);
29999 }
30000 
30001 /*
30002  *    Function: sd_panic_for_res_conflict
30003  *
30004  * Description: Call panic with a string formatted with "Reservation Conflict"
30005  *              and a human readable identifier indicating the SD instance
30006  *              that experienced the reservation conflict.
30007  *
30008  *   Arguments: un - pointer to the soft state struct for the instance.
30009  *
30010  *     Context: may execute in interrupt context.
30011  */
30012 
30013 #define SD_RESV_CONFLICT_FMT_LEN 40
30014 void
30015 sd_panic_for_res_conflict(struct sd_lun *un)
30016 {
30017         char panic_str[SD_RESV_CONFLICT_FMT_LEN+MAXPATHLEN];
30018         char path_str[MAXPATHLEN];
30019 
30020         (void) snprintf(panic_str, sizeof (panic_str),
30021             "Reservation Conflict\nDisk: %s",
30022             ddi_pathname(SD_DEVINFO(un), path_str));
30023 
30024         panic(panic_str);
30025 }
30026 
30027 /*
30028  * Note: The following sd_faultinjection_ioctl( ) routines implement
30029  * driver support for handling fault injection for error analysis
30030  * causing faults in multiple layers of the driver.
30031  *
30032  */
30033 
30034 #ifdef SD_FAULT_INJECTION
30035 static uint_t   sd_fault_injection_on = 0;
30036 
30037 /*
30038  *    Function: sd_faultinjection_ioctl()
30039  *
30040  * Description: This routine is the driver entry point for handling
30041  *              faultinjection ioctls to inject errors into the
30042  *              layer model
30043  *
30044  *   Arguments: cmd     - the ioctl cmd received
30045  *              arg     - the arguments from user and returns
30046  */
30047 
30048 static void
30049 sd_faultinjection_ioctl(int cmd, intptr_t arg,  struct sd_lun *un) {
30050 
30051         uint_t i = 0;
30052         uint_t rval;
30053 
30054         SD_TRACE(SD_LOG_IOERR, un, "sd_faultinjection_ioctl: entry\n");
30055 
30056         mutex_enter(SD_MUTEX(un));
30057 
30058         switch (cmd) {
30059         case SDIOCRUN:
30060                 /* Allow pushed faults to be injected */
30061                 SD_INFO(SD_LOG_SDTEST, un,
30062                     "sd_faultinjection_ioctl: Injecting Fault Run\n");
30063 
30064                 sd_fault_injection_on = 1;
30065 
30066                 SD_INFO(SD_LOG_IOERR, un,
30067                     "sd_faultinjection_ioctl: run finished\n");
30068                 break;
30069 
30070         case SDIOCSTART:
30071                 /* Start Injection Session */
30072                 SD_INFO(SD_LOG_SDTEST, un,
30073                     "sd_faultinjection_ioctl: Injecting Fault Start\n");
30074 
30075                 sd_fault_injection_on = 0;
30076                 un->sd_injection_mask = 0xFFFFFFFF;
30077                 for (i = 0; i < SD_FI_MAX_ERROR; i++) {
30078                         un->sd_fi_fifo_pkt[i] = NULL;
30079                         un->sd_fi_fifo_xb[i] = NULL;
30080                         un->sd_fi_fifo_un[i] = NULL;
30081                         un->sd_fi_fifo_arq[i] = NULL;
30082                 }
30083                 un->sd_fi_fifo_start = 0;
30084                 un->sd_fi_fifo_end = 0;
30085 
30086                 mutex_enter(&(un->un_fi_mutex));
30087                 un->sd_fi_log[0] = '\0';
30088                 un->sd_fi_buf_len = 0;
30089                 mutex_exit(&(un->un_fi_mutex));
30090 
30091                 SD_INFO(SD_LOG_IOERR, un,
30092                     "sd_faultinjection_ioctl: start finished\n");
30093                 break;
30094 
30095         case SDIOCSTOP:
30096                 /* Stop Injection Session */
30097                 SD_INFO(SD_LOG_SDTEST, un,
30098                     "sd_faultinjection_ioctl: Injecting Fault Stop\n");
30099                 sd_fault_injection_on = 0;
30100                 un->sd_injection_mask = 0x0;
30101 
30102                 /* Empty stray or unuseds structs from fifo */
30103                 for (i = 0; i < SD_FI_MAX_ERROR; i++) {
30104                         if (un->sd_fi_fifo_pkt[i] != NULL) {
30105                                 kmem_free(un->sd_fi_fifo_pkt[i],
30106                                     sizeof (struct sd_fi_pkt));
30107                         }
30108                         if (un->sd_fi_fifo_xb[i] != NULL) {
30109                                 kmem_free(un->sd_fi_fifo_xb[i],
30110                                     sizeof (struct sd_fi_xb));
30111                         }
30112                         if (un->sd_fi_fifo_un[i] != NULL) {
30113                                 kmem_free(un->sd_fi_fifo_un[i],
30114                                     sizeof (struct sd_fi_un));
30115                         }
30116                         if (un->sd_fi_fifo_arq[i] != NULL) {
30117                                 kmem_free(un->sd_fi_fifo_arq[i],
30118                                     sizeof (struct sd_fi_arq));
30119                         }
30120                         un->sd_fi_fifo_pkt[i] = NULL;
30121                         un->sd_fi_fifo_un[i] = NULL;
30122                         un->sd_fi_fifo_xb[i] = NULL;
30123                         un->sd_fi_fifo_arq[i] = NULL;
30124                 }
30125                 un->sd_fi_fifo_start = 0;
30126                 un->sd_fi_fifo_end = 0;
30127 
30128                 SD_INFO(SD_LOG_IOERR, un,
30129                     "sd_faultinjection_ioctl: stop finished\n");
30130                 break;
30131 
30132         case SDIOCINSERTPKT:
30133                 /* Store a packet struct to be pushed onto fifo */
30134                 SD_INFO(SD_LOG_SDTEST, un,
30135                     "sd_faultinjection_ioctl: Injecting Fault Insert Pkt\n");
30136 
30137                 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30138 
30139                 sd_fault_injection_on = 0;
30140 
30141                 /* No more that SD_FI_MAX_ERROR allowed in Queue */
30142                 if (un->sd_fi_fifo_pkt[i] != NULL) {
30143                         kmem_free(un->sd_fi_fifo_pkt[i],
30144                             sizeof (struct sd_fi_pkt));
30145                 }
30146                 if (arg != NULL) {
30147                         un->sd_fi_fifo_pkt[i] =
30148                             kmem_alloc(sizeof (struct sd_fi_pkt), KM_NOSLEEP);
30149                         if (un->sd_fi_fifo_pkt[i] == NULL) {
30150                                 /* Alloc failed don't store anything */
30151                                 break;
30152                         }
30153                         rval = ddi_copyin((void *)arg, un->sd_fi_fifo_pkt[i],
30154                             sizeof (struct sd_fi_pkt), 0);
30155                         if (rval == -1) {
30156                                 kmem_free(un->sd_fi_fifo_pkt[i],
30157                                     sizeof (struct sd_fi_pkt));
30158                                 un->sd_fi_fifo_pkt[i] = NULL;
30159                         }
30160                 } else {
30161                         SD_INFO(SD_LOG_IOERR, un,
30162                             "sd_faultinjection_ioctl: pkt null\n");
30163                 }
30164                 break;
30165 
30166         case SDIOCINSERTXB:
30167                 /* Store a xb struct to be pushed onto fifo */
30168                 SD_INFO(SD_LOG_SDTEST, un,
30169                     "sd_faultinjection_ioctl: Injecting Fault Insert XB\n");
30170 
30171                 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30172 
30173                 sd_fault_injection_on = 0;
30174 
30175                 if (un->sd_fi_fifo_xb[i] != NULL) {
30176                         kmem_free(un->sd_fi_fifo_xb[i],
30177                             sizeof (struct sd_fi_xb));
30178                         un->sd_fi_fifo_xb[i] = NULL;
30179                 }
30180                 if (arg != NULL) {
30181                         un->sd_fi_fifo_xb[i] =
30182                             kmem_alloc(sizeof (struct sd_fi_xb), KM_NOSLEEP);
30183                         if (un->sd_fi_fifo_xb[i] == NULL) {
30184                                 /* Alloc failed don't store anything */
30185                                 break;
30186                         }
30187                         rval = ddi_copyin((void *)arg, un->sd_fi_fifo_xb[i],
30188                             sizeof (struct sd_fi_xb), 0);
30189 
30190                         if (rval == -1) {
30191                                 kmem_free(un->sd_fi_fifo_xb[i],
30192                                     sizeof (struct sd_fi_xb));
30193                                 un->sd_fi_fifo_xb[i] = NULL;
30194                         }
30195                 } else {
30196                         SD_INFO(SD_LOG_IOERR, un,
30197                             "sd_faultinjection_ioctl: xb null\n");
30198                 }
30199                 break;
30200 
30201         case SDIOCINSERTUN:
30202                 /* Store a un struct to be pushed onto fifo */
30203                 SD_INFO(SD_LOG_SDTEST, un,
30204                     "sd_faultinjection_ioctl: Injecting Fault Insert UN\n");
30205 
30206                 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30207 
30208                 sd_fault_injection_on = 0;
30209 
30210                 if (un->sd_fi_fifo_un[i] != NULL) {
30211                         kmem_free(un->sd_fi_fifo_un[i],
30212                             sizeof (struct sd_fi_un));
30213                         un->sd_fi_fifo_un[i] = NULL;
30214                 }
30215                 if (arg != NULL) {
30216                         un->sd_fi_fifo_un[i] =
30217                             kmem_alloc(sizeof (struct sd_fi_un), KM_NOSLEEP);
30218                         if (un->sd_fi_fifo_un[i] == NULL) {
30219                                 /* Alloc failed don't store anything */
30220                                 break;
30221                         }
30222                         rval = ddi_copyin((void *)arg, un->sd_fi_fifo_un[i],
30223                             sizeof (struct sd_fi_un), 0);
30224                         if (rval == -1) {
30225                                 kmem_free(un->sd_fi_fifo_un[i],
30226                                     sizeof (struct sd_fi_un));
30227                                 un->sd_fi_fifo_un[i] = NULL;
30228                         }
30229 
30230                 } else {
30231                         SD_INFO(SD_LOG_IOERR, un,
30232                             "sd_faultinjection_ioctl: un null\n");
30233                 }
30234 
30235                 break;
30236 
30237         case SDIOCINSERTARQ:
30238                 /* Store a arq struct to be pushed onto fifo */
30239                 SD_INFO(SD_LOG_SDTEST, un,
30240                     "sd_faultinjection_ioctl: Injecting Fault Insert ARQ\n");
30241                 i = un->sd_fi_fifo_end % SD_FI_MAX_ERROR;
30242 
30243                 sd_fault_injection_on = 0;
30244 
30245                 if (un->sd_fi_fifo_arq[i] != NULL) {
30246                         kmem_free(un->sd_fi_fifo_arq[i],
30247                             sizeof (struct sd_fi_arq));
30248                         un->sd_fi_fifo_arq[i] = NULL;
30249                 }
30250                 if (arg != NULL) {
30251                         un->sd_fi_fifo_arq[i] =
30252                             kmem_alloc(sizeof (struct sd_fi_arq), KM_NOSLEEP);
30253                         if (un->sd_fi_fifo_arq[i] == NULL) {
30254                                 /* Alloc failed don't store anything */
30255                                 break;
30256                         }
30257                         rval = ddi_copyin((void *)arg, un->sd_fi_fifo_arq[i],
30258                             sizeof (struct sd_fi_arq), 0);
30259                         if (rval == -1) {
30260                                 kmem_free(un->sd_fi_fifo_arq[i],
30261                                     sizeof (struct sd_fi_arq));
30262                                 un->sd_fi_fifo_arq[i] = NULL;
30263                         }
30264 
30265                 } else {
30266                         SD_INFO(SD_LOG_IOERR, un,
30267                             "sd_faultinjection_ioctl: arq null\n");
30268                 }
30269 
30270                 break;
30271 
30272         case SDIOCPUSH:
30273                 /* Push stored xb, pkt, un, and arq onto fifo */
30274                 sd_fault_injection_on = 0;
30275 
30276                 if (arg != NULL) {
30277                         rval = ddi_copyin((void *)arg, &i, sizeof (uint_t), 0);
30278                         if (rval != -1 &&
30279                             un->sd_fi_fifo_end + i < SD_FI_MAX_ERROR) {
30280                                 un->sd_fi_fifo_end += i;
30281                         }
30282                 } else {
30283                         SD_INFO(SD_LOG_IOERR, un,
30284                             "sd_faultinjection_ioctl: push arg null\n");
30285                         if (un->sd_fi_fifo_end + i < SD_FI_MAX_ERROR) {
30286                                 un->sd_fi_fifo_end++;
30287                         }
30288                 }
30289                 SD_INFO(SD_LOG_IOERR, un,
30290                     "sd_faultinjection_ioctl: push to end=%d\n",
30291                     un->sd_fi_fifo_end);
30292                 break;
30293 
30294         case SDIOCRETRIEVE:
30295                 /* Return buffer of log from Injection session */
30296                 SD_INFO(SD_LOG_SDTEST, un,
30297                     "sd_faultinjection_ioctl: Injecting Fault Retreive");
30298 
30299                 sd_fault_injection_on = 0;
30300 
30301                 mutex_enter(&(un->un_fi_mutex));
30302                 rval = ddi_copyout(un->sd_fi_log, (void *)arg,
30303                     un->sd_fi_buf_len+1, 0);
30304                 mutex_exit(&(un->un_fi_mutex));
30305 
30306                 if (rval == -1) {
30307                         /*
30308                          * arg is possibly invalid setting
30309                          * it to NULL for return
30310                          */
30311                         arg = NULL;
30312                 }
30313                 break;
30314         }
30315 
30316         mutex_exit(SD_MUTEX(un));
30317         SD_TRACE(SD_LOG_IOERR, un, "sd_faultinjection_ioctl:"
30318                             " exit\n");
30319 }
30320 
30321 
30322 /*
30323  *    Function: sd_injection_log()
30324  *
30325  * Description: This routine adds buff to the already existing injection log
30326  *              for retrieval via faultinjection_ioctl for use in fault
30327  *              detection and recovery
30328  *
30329  *   Arguments: buf - the string to add to the log
30330  */
30331 
30332 static void
30333 sd_injection_log(char *buf, struct sd_lun *un)
30334 {
30335         uint_t len;
30336 
30337         ASSERT(un != NULL);
30338         ASSERT(buf != NULL);
30339 
30340         mutex_enter(&(un->un_fi_mutex));
30341 
30342         len = min(strlen(buf), 255);
30343         /* Add logged value to Injection log to be returned later */
30344         if (len + un->sd_fi_buf_len < SD_FI_MAX_BUF) {
30345                 uint_t  offset = strlen((char *)un->sd_fi_log);
30346                 char *destp = (char *)un->sd_fi_log + offset;
30347                 int i;
30348                 for (i = 0; i < len; i++) {
30349                         *destp++ = *buf++;
30350                 }
30351                 un->sd_fi_buf_len += len;
30352                 un->sd_fi_log[un->sd_fi_buf_len] = '\0';
30353         }
30354 
30355         mutex_exit(&(un->un_fi_mutex));
30356 }
30357 
30358 
30359 /*
30360  *    Function: sd_faultinjection()
30361  *
30362  * Description: This routine takes the pkt and changes its
30363  *              content based on error injection scenerio.
30364  *
30365  *   Arguments: pktp    - packet to be changed
30366  */
30367 
30368 static void
30369 sd_faultinjection(struct scsi_pkt *pktp)
30370 {
30371         uint_t i;
30372         struct sd_fi_pkt *fi_pkt;
30373         struct sd_fi_xb *fi_xb;
30374         struct sd_fi_un *fi_un;
30375         struct sd_fi_arq *fi_arq;
30376         struct buf *bp;
30377         struct sd_xbuf *xb;
30378         struct sd_lun *un;
30379 
30380         ASSERT(pktp != NULL);
30381 
30382         /* pull bp xb and un from pktp */
30383         bp = (struct buf *)pktp->pkt_private;
30384         xb = SD_GET_XBUF(bp);
30385         un = SD_GET_UN(bp);
30386 
30387         ASSERT(un != NULL);
30388 
30389         mutex_enter(SD_MUTEX(un));
30390 
30391         SD_TRACE(SD_LOG_SDTEST, un,
30392             "sd_faultinjection: entry Injection from sdintr\n");
30393 
30394         /* if injection is off return */
30395         if (sd_fault_injection_on == 0 ||
30396             un->sd_fi_fifo_start == un->sd_fi_fifo_end) {
30397                 mutex_exit(SD_MUTEX(un));
30398                 return;
30399         }
30400 
30401         SD_INFO(SD_LOG_SDTEST, un,
30402             "sd_faultinjection: is working for copying\n");
30403 
30404         /* take next set off fifo */
30405         i = un->sd_fi_fifo_start % SD_FI_MAX_ERROR;
30406 
30407         fi_pkt = un->sd_fi_fifo_pkt[i];
30408         fi_xb = un->sd_fi_fifo_xb[i];
30409         fi_un = un->sd_fi_fifo_un[i];
30410         fi_arq = un->sd_fi_fifo_arq[i];
30411 
30412 
30413         /* set variables accordingly */
30414         /* set pkt if it was on fifo */
30415         if (fi_pkt != NULL) {
30416                 SD_CONDSET(pktp, pkt, pkt_flags, "pkt_flags");
30417                 SD_CONDSET(*pktp, pkt, pkt_scbp, "pkt_scbp");
30418                 if (fi_pkt->pkt_cdbp != 0xff)
30419                         SD_CONDSET(*pktp, pkt, pkt_cdbp, "pkt_cdbp");
30420                 SD_CONDSET(pktp, pkt, pkt_state, "pkt_state");
30421                 SD_CONDSET(pktp, pkt, pkt_statistics, "pkt_statistics");
30422                 SD_CONDSET(pktp, pkt, pkt_reason, "pkt_reason");
30423 
30424         }
30425         /* set xb if it was on fifo */
30426         if (fi_xb != NULL) {
30427                 SD_CONDSET(xb, xb, xb_blkno, "xb_blkno");
30428                 SD_CONDSET(xb, xb, xb_dma_resid, "xb_dma_resid");
30429                 if (fi_xb->xb_retry_count != 0)
30430                         SD_CONDSET(xb, xb, xb_retry_count, "xb_retry_count");
30431                 SD_CONDSET(xb, xb, xb_victim_retry_count,
30432                     "xb_victim_retry_count");
30433                 SD_CONDSET(xb, xb, xb_sense_status, "xb_sense_status");
30434                 SD_CONDSET(xb, xb, xb_sense_state, "xb_sense_state");
30435                 SD_CONDSET(xb, xb, xb_sense_resid, "xb_sense_resid");
30436 
30437                 /* copy in block data from sense */
30438                 /*
30439                  * if (fi_xb->xb_sense_data[0] != -1) {
30440                  *      bcopy(fi_xb->xb_sense_data, xb->xb_sense_data,
30441                  *      SENSE_LENGTH);
30442                  * }
30443                  */
30444                 bcopy(fi_xb->xb_sense_data, xb->xb_sense_data, SENSE_LENGTH);
30445 
30446                 /* copy in extended sense codes */
30447                 SD_CONDSET(((struct scsi_extended_sense *)xb->xb_sense_data),
30448                     xb, es_code, "es_code");
30449                 SD_CONDSET(((struct scsi_extended_sense *)xb->xb_sense_data),
30450                     xb, es_key, "es_key");
30451                 SD_CONDSET(((struct scsi_extended_sense *)xb->xb_sense_data),
30452                     xb, es_add_code, "es_add_code");
30453                 SD_CONDSET(((struct scsi_extended_sense *)xb->xb_sense_data),
30454                     xb, es_qual_code, "es_qual_code");
30455                 struct scsi_extended_sense *esp;
30456                 esp = (struct scsi_extended_sense *)xb->xb_sense_data;
30457                 esp->es_class = CLASS_EXTENDED_SENSE;
30458         }
30459 
30460         /* set un if it was on fifo */
30461         if (fi_un != NULL) {
30462                 SD_CONDSET(un->un_sd->sd_inq, un, inq_rmb, "inq_rmb");
30463                 SD_CONDSET(un, un, un_ctype, "un_ctype");
30464                 SD_CONDSET(un, un, un_reset_retry_count,
30465                     "un_reset_retry_count");
30466                 SD_CONDSET(un, un, un_reservation_type, "un_reservation_type");
30467                 SD_CONDSET(un, un, un_resvd_status, "un_resvd_status");
30468                 SD_CONDSET(un, un, un_f_arq_enabled, "un_f_arq_enabled");
30469                 SD_CONDSET(un, un, un_f_allow_bus_device_reset,
30470                     "un_f_allow_bus_device_reset");
30471                 SD_CONDSET(un, un, un_f_opt_queueing, "un_f_opt_queueing");
30472 
30473         }
30474 
30475         /* copy in auto request sense if it was on fifo */
30476         if (fi_arq != NULL) {
30477                 bcopy(fi_arq, pktp->pkt_scbp, sizeof (struct sd_fi_arq));
30478         }
30479 
30480         /* free structs */
30481         if (un->sd_fi_fifo_pkt[i] != NULL) {
30482                 kmem_free(un->sd_fi_fifo_pkt[i], sizeof (struct sd_fi_pkt));
30483         }
30484         if (un->sd_fi_fifo_xb[i] != NULL) {
30485                 kmem_free(un->sd_fi_fifo_xb[i], sizeof (struct sd_fi_xb));
30486         }
30487         if (un->sd_fi_fifo_un[i] != NULL) {
30488                 kmem_free(un->sd_fi_fifo_un[i], sizeof (struct sd_fi_un));
30489         }
30490         if (un->sd_fi_fifo_arq[i] != NULL) {
30491                 kmem_free(un->sd_fi_fifo_arq[i], sizeof (struct sd_fi_arq));
30492         }
30493 
30494         /*
30495          * kmem_free does not gurantee to set to NULL
30496          * since we uses these to determine if we set
30497          * values or not lets confirm they are always
30498          * NULL after free
30499          */
30500         un->sd_fi_fifo_pkt[i] = NULL;
30501         un->sd_fi_fifo_un[i] = NULL;
30502         un->sd_fi_fifo_xb[i] = NULL;
30503         un->sd_fi_fifo_arq[i] = NULL;
30504 
30505         un->sd_fi_fifo_start++;
30506 
30507         mutex_exit(SD_MUTEX(un));
30508 
30509         SD_INFO(SD_LOG_SDTEST, un, "sd_faultinjection: exit\n");
30510 }
30511 
30512 #endif /* SD_FAULT_INJECTION */
30513 
30514 /*
30515  * This routine is invoked in sd_unit_attach(). Before calling it, the
30516  * properties in conf file should be processed already, and "hotpluggable"
30517  * property was processed also.
30518  *
30519  * The sd driver distinguishes 3 different type of devices: removable media,
30520  * non-removable media, and hotpluggable. Below the differences are defined:
30521  *
30522  * 1. Device ID
30523  *
30524  *     The device ID of a device is used to identify this device. Refer to
30525  *     ddi_devid_register(9F).
30526  *
30527  *     For a non-removable media disk device which can provide 0x80 or 0x83
30528  *     VPD page (refer to INQUIRY command of SCSI SPC specification), a unique
30529  *     device ID is created to identify this device. For other non-removable
30530  *     media devices, a default device ID is created only if this device has
30531  *     at least 2 alter cylinders. Otherwise, this device has no devid.
30532  *
30533  *     -------------------------------------------------------
30534  *     removable media   hotpluggable  | Can Have Device ID
30535  *     -------------------------------------------------------
30536  *         false             false     |     Yes
30537  *         false             true      |     Yes
30538  *         true                x       |     No
30539  *     ------------------------------------------------------
30540  *
30541  *
30542  * 2. SCSI group 4 commands
30543  *
30544  *     In SCSI specs, only some commands in group 4 command set can use
30545  *     8-byte addresses that can be used to access >2TB storage spaces.
30546  *     Other commands have no such capability. Without supporting group4,
30547  *     it is impossible to make full use of storage spaces of a disk with
30548  *     capacity larger than 2TB.
30549  *
30550  *     -----------------------------------------------
30551  *     removable media   hotpluggable   LP64  |  Group
30552  *     -----------------------------------------------
30553  *           false          false       false |   1
30554  *           false          false       true  |   4
30555  *           false          true        false |   1
30556  *           false          true        true  |   4
30557  *           true             x           x   |   5
30558  *     -----------------------------------------------
30559  *
30560  *
30561  * 3. Check for VTOC Label
30562  *
30563  *     If a direct-access disk has no EFI label, sd will check if it has a
30564  *     valid VTOC label. Now, sd also does that check for removable media
30565  *     and hotpluggable devices.
30566  *
30567  *     --------------------------------------------------------------
30568  *     Direct-Access   removable media    hotpluggable |  Check Label
30569  *     -------------------------------------------------------------
30570  *         false          false           false        |   No
30571  *         false          false           true         |   No
30572  *         false          true            false        |   Yes
30573  *         false          true            true         |   Yes
30574  *         true            x                x          |   Yes
30575  *     --------------------------------------------------------------
30576  *
30577  *
30578  * 4. Building default VTOC label
30579  *
30580  *     As section 3 says, sd checks if some kinds of devices have VTOC label.
30581  *     If those devices have no valid VTOC label, sd(7d) will attempt to
30582  *     create default VTOC for them. Currently sd creates default VTOC label
30583  *     for all devices on x86 platform (VTOC_16), but only for removable
30584  *     media devices on SPARC (VTOC_8).
30585  *
30586  *     -----------------------------------------------------------
30587  *       removable media hotpluggable platform   |   Default Label
30588  *     -----------------------------------------------------------
30589  *             false          false    sparc     |     No
30590  *             false          true      x86      |     Yes
30591  *             false          true     sparc     |     Yes
30592  *             true             x        x       |     Yes
30593  *     ----------------------------------------------------------
30594  *
30595  *
30596  * 5. Supported blocksizes of target devices
30597  *
30598  *     Sd supports non-512-byte blocksize for removable media devices only.
30599  *     For other devices, only 512-byte blocksize is supported. This may be
30600  *     changed in near future because some RAID devices require non-512-byte
30601  *     blocksize
30602  *
30603  *     -----------------------------------------------------------
30604  *     removable media    hotpluggable    | non-512-byte blocksize
30605  *     -----------------------------------------------------------
30606  *           false          false         |   No
30607  *           false          true          |   No
30608  *           true             x           |   Yes
30609  *     -----------------------------------------------------------
30610  *
30611  *
30612  * 6. Automatic mount & unmount
30613  *
30614  *     Sd(7d) driver provides DKIOCREMOVABLE ioctl. This ioctl is used to query
30615  *     if a device is removable media device. It return 1 for removable media
30616  *     devices, and 0 for others.
30617  *
30618  *     The automatic mounting subsystem should distinguish between the types
30619  *     of devices and apply automounting policies to each.
30620  *
30621  *
30622  * 7. fdisk partition management
30623  *
30624  *     Fdisk is traditional partition method on x86 platform. Sd(7d) driver
30625  *     just supports fdisk partitions on x86 platform. On sparc platform, sd
30626  *     doesn't support fdisk partitions at all. Note: pcfs(7fs) can recognize
30627  *     fdisk partitions on both x86 and SPARC platform.
30628  *
30629  *     -----------------------------------------------------------
30630  *       platform   removable media  USB/1394  |  fdisk supported
30631  *     -----------------------------------------------------------
30632  *        x86         X               X        |       true
30633  *     ------------------------------------------------------------
30634  *        sparc       X               X        |       false
30635  *     ------------------------------------------------------------
30636  *
30637  *
30638  * 8. MBOOT/MBR
30639  *
30640  *     Although sd(7d) doesn't support fdisk on SPARC platform, it does support
30641  *     read/write mboot for removable media devices on sparc platform.
30642  *
30643  *     -----------------------------------------------------------
30644  *       platform   removable media  USB/1394  |  mboot supported
30645  *     -----------------------------------------------------------
30646  *        x86         X               X        |       true
30647  *     ------------------------------------------------------------
30648  *        sparc      false           false     |       false
30649  *        sparc      false           true      |       true
30650  *        sparc      true            false     |       true
30651  *        sparc      true            true      |       true
30652  *     ------------------------------------------------------------
30653  *
30654  *
30655  * 9.  error handling during opening device
30656  *
30657  *     If failed to open a disk device, an errno is returned. For some kinds
30658  *     of errors, different errno is returned depending on if this device is
30659  *     a removable media device. This brings USB/1394 hard disks in line with
30660  *     expected hard disk behavior. It is not expected that this breaks any
30661  *     application.
30662  *
30663  *     ------------------------------------------------------
30664  *       removable media    hotpluggable   |  errno
30665  *     ------------------------------------------------------
30666  *             false          false        |   EIO
30667  *             false          true         |   EIO
30668  *             true             x          |   ENXIO
30669  *     ------------------------------------------------------
30670  *
30671  *
30672  * 11. ioctls: DKIOCEJECT, CDROMEJECT
30673  *
30674  *     These IOCTLs are applicable only to removable media devices.
30675  *
30676  *     -----------------------------------------------------------
30677  *       removable media    hotpluggable   |DKIOCEJECT, CDROMEJECT
30678  *     -----------------------------------------------------------
30679  *             false          false        |     No
30680  *             false          true         |     No
30681  *             true            x           |     Yes
30682  *     -----------------------------------------------------------
30683  *
30684  *
30685  * 12. Kstats for partitions
30686  *
30687  *     sd creates partition kstat for non-removable media devices. USB and
30688  *     Firewire hard disks now have partition kstats
30689  *
30690  *      ------------------------------------------------------
30691  *       removable media    hotpluggable   |   kstat
30692  *      ------------------------------------------------------
30693  *             false          false        |    Yes
30694  *             false          true         |    Yes
30695  *             true             x          |    No
30696  *       ------------------------------------------------------
30697  *
30698  *
30699  * 13. Removable media & hotpluggable properties
30700  *
30701  *     Sd driver creates a "removable-media" property for removable media
30702  *     devices. Parent nexus drivers create a "hotpluggable" property if
30703  *     it supports hotplugging.
30704  *
30705  *     ---------------------------------------------------------------------
30706  *     removable media   hotpluggable |  "removable-media"   " hotpluggable"
30707  *     ---------------------------------------------------------------------
30708  *       false            false       |    No                   No
30709  *       false            true        |    No                   Yes
30710  *       true             false       |    Yes                  No
30711  *       true             true        |    Yes                  Yes
30712  *     ---------------------------------------------------------------------
30713  *
30714  *
30715  * 14. Power Management
30716  *
30717  *     sd only power manages removable media devices or devices that support
30718  *     LOG_SENSE or have a "pm-capable" property  (PSARC/2002/250)
30719  *
30720  *     A parent nexus that supports hotplugging can also set "pm-capable"
30721  *     if the disk can be power managed.
30722  *
30723  *     ------------------------------------------------------------
30724  *       removable media hotpluggable pm-capable  |   power manage
30725  *     ------------------------------------------------------------
30726  *             false          false     false     |     No
30727  *             false          false     true      |     Yes
30728  *             false          true      false     |     No
30729  *             false          true      true      |     Yes
30730  *             true             x        x        |     Yes
30731  *     ------------------------------------------------------------
30732  *
30733  *      USB and firewire hard disks can now be power managed independently
30734  *      of the framebuffer
30735  *
30736  *
30737  * 15. Support for USB disks with capacity larger than 1TB
30738  *
30739  *     Currently, sd doesn't permit a fixed disk device with capacity
30740  *     larger than 1TB to be used in a 32-bit operating system environment.
30741  *     However, sd doesn't do that for removable media devices. Instead, it
30742  *     assumes that removable media devices cannot have a capacity larger
30743  *     than 1TB. Therefore, using those devices on 32-bit system is partially
30744  *     supported, which can cause some unexpected results.
30745  *
30746  *     ---------------------------------------------------------------------
30747  *       removable media    USB/1394 | Capacity > 1TB |   Used in 32-bit env
30748  *     ---------------------------------------------------------------------
30749  *             false          false  |   true         |     no
30750  *             false          true   |   true         |     no
30751  *             true           false  |   true         |     Yes
30752  *             true           true   |   true         |     Yes
30753  *     ---------------------------------------------------------------------
30754  *
30755  *
30756  * 16. Check write-protection at open time
30757  *
30758  *     When a removable media device is being opened for writing without NDELAY
30759  *     flag, sd will check if this device is writable. If attempting to open
30760  *     without NDELAY flag a write-protected device, this operation will abort.
30761  *
30762  *     ------------------------------------------------------------
30763  *       removable media    USB/1394   |   WP Check
30764  *     ------------------------------------------------------------
30765  *             false          false    |     No
30766  *             false          true     |     No
30767  *             true           false    |     Yes
30768  *             true           true     |     Yes
30769  *     ------------------------------------------------------------
30770  *
30771  *
30772  * 17. syslog when corrupted VTOC is encountered
30773  *
30774  *      Currently, if an invalid VTOC is encountered, sd only print syslog
30775  *      for fixed SCSI disks.
30776  *     ------------------------------------------------------------
30777  *       removable media    USB/1394   |   print syslog
30778  *     ------------------------------------------------------------
30779  *             false          false    |     Yes
30780  *             false          true     |     No
30781  *             true           false    |     No
30782  *             true           true     |     No
30783  *     ------------------------------------------------------------
30784  */
30785 static void
30786 sd_set_unit_attributes(struct sd_lun *un, dev_info_t *devi)
30787 {
30788         int     pm_cap;
30789 
30790         ASSERT(un->un_sd);
30791         ASSERT(un->un_sd->sd_inq);
30792 
30793         /*
30794          * Enable SYNC CACHE support for all devices.
30795          */
30796         un->un_f_sync_cache_supported = TRUE;
30797 
30798         /*
30799          * Set the sync cache required flag to false.
30800          * This would ensure that there is no SYNC CACHE
30801          * sent when there are no writes
30802          */
30803         un->un_f_sync_cache_required = FALSE;
30804 
30805         if (un->un_sd->sd_inq->inq_rmb) {
30806                 /*
30807                  * The media of this device is removable. And for this kind
30808                  * of devices, it is possible to change medium after opening
30809                  * devices. Thus we should support this operation.
30810                  */
30811                 un->un_f_has_removable_media = TRUE;
30812 
30813                 /*
30814                  * support non-512-byte blocksize of removable media devices
30815                  */
30816                 un->un_f_non_devbsize_supported = TRUE;
30817 
30818                 /*
30819                  * Assume that all removable media devices support DOOR_LOCK
30820                  */
30821                 un->un_f_doorlock_supported = TRUE;
30822 
30823                 /*
30824                  * For a removable media device, it is possible to be opened
30825                  * with NDELAY flag when there is no media in drive, in this
30826                  * case we don't care if device is writable. But if without
30827                  * NDELAY flag, we need to check if media is write-protected.
30828                  */
30829                 un->un_f_chk_wp_open = TRUE;
30830 
30831                 /*
30832                  * need to start a SCSI watch thread to monitor media state,
30833                  * when media is being inserted or ejected, notify syseventd.
30834                  */
30835                 un->un_f_monitor_media_state = TRUE;
30836 
30837                 /*
30838                  * Some devices don't support START_STOP_UNIT command.
30839                  * Therefore, we'd better check if a device supports it
30840                  * before sending it.
30841                  */
30842                 un->un_f_check_start_stop = TRUE;
30843 
30844                 /*
30845                  * support eject media ioctl:
30846                  *              FDEJECT, DKIOCEJECT, CDROMEJECT
30847                  */
30848                 un->un_f_eject_media_supported = TRUE;
30849 
30850                 /*
30851                  * Because many removable-media devices don't support
30852                  * LOG_SENSE, we couldn't use this command to check if
30853                  * a removable media device support power-management.
30854                  * We assume that they support power-management via
30855                  * START_STOP_UNIT command and can be spun up and down
30856                  * without limitations.
30857                  */
30858                 un->un_f_pm_supported = TRUE;
30859 
30860                 /*
30861                  * Need to create a zero length (Boolean) property
30862                  * removable-media for the removable media devices.
30863                  * Note that the return value of the property is not being
30864                  * checked, since if unable to create the property
30865                  * then do not want the attach to fail altogether. Consistent
30866                  * with other property creation in attach.
30867                  */
30868                 (void) ddi_prop_create(DDI_DEV_T_NONE, devi,
30869                     DDI_PROP_CANSLEEP, "removable-media", NULL, 0);
30870 
30871         } else {
30872                 /*
30873                  * create device ID for device
30874                  */
30875                 un->un_f_devid_supported = TRUE;
30876 
30877                 /*
30878                  * Spin up non-removable-media devices once it is attached
30879                  */
30880                 un->un_f_attach_spinup = TRUE;
30881 
30882                 /*
30883                  * According to SCSI specification, Sense data has two kinds of
30884                  * format: fixed format, and descriptor format. At present, we
30885                  * don't support descriptor format sense data for removable
30886                  * media.
30887                  */
30888                 if (SD_INQUIRY(un)->inq_dtype == DTYPE_DIRECT) {
30889                         un->un_f_descr_format_supported = TRUE;
30890                 }
30891 
30892                 /*
30893                  * kstats are created only for non-removable media devices.
30894                  *
30895                  * Set this in sd.conf to 0 in order to disable kstats.  The
30896                  * default is 1, so they are enabled by default.
30897                  */
30898                 un->un_f_pkstats_enabled = (ddi_prop_get_int(DDI_DEV_T_ANY,
30899                     SD_DEVINFO(un), DDI_PROP_DONTPASS,
30900                     "enable-partition-kstats", 1));
30901 
30902                 /*
30903                  * Check if HBA has set the "pm-capable" property.
30904                  * If "pm-capable" exists and is non-zero then we can
30905                  * power manage the device without checking the start/stop
30906                  * cycle count log sense page.
30907                  *
30908                  * If "pm-capable" exists and is set to be false (0),
30909                  * then we should not power manage the device.
30910                  *
30911                  * If "pm-capable" doesn't exist then pm_cap will
30912                  * be set to SD_PM_CAPABLE_UNDEFINED (-1).  In this case,
30913                  * sd will check the start/stop cycle count log sense page
30914                  * and power manage the device if the cycle count limit has
30915                  * not been exceeded.
30916                  */
30917                 pm_cap = ddi_prop_get_int(DDI_DEV_T_ANY, devi,
30918                     DDI_PROP_DONTPASS, "pm-capable", SD_PM_CAPABLE_UNDEFINED);
30919                 if (SD_PM_CAPABLE_IS_UNDEFINED(pm_cap)) {
30920                         un->un_f_log_sense_supported = TRUE;
30921                         if (!un->un_f_power_condition_disabled &&
30922                             SD_INQUIRY(un)->inq_ansi == 6) {
30923                                 un->un_f_power_condition_supported = TRUE;
30924                         }
30925                 } else {
30926                         /*
30927                          * pm-capable property exists.
30928                          *
30929                          * Convert "TRUE" values for pm_cap to
30930                          * SD_PM_CAPABLE_IS_TRUE to make it easier to check
30931                          * later. "TRUE" values are any values defined in
30932                          * inquiry.h.
30933                          */
30934                         if (SD_PM_CAPABLE_IS_FALSE(pm_cap)) {
30935                                 un->un_f_log_sense_supported = FALSE;
30936                         } else {
30937                                 /* SD_PM_CAPABLE_IS_TRUE case */
30938                                 un->un_f_pm_supported = TRUE;
30939                                 if (!un->un_f_power_condition_disabled &&
30940                                     SD_PM_CAPABLE_IS_SPC_4(pm_cap)) {
30941                                         un->un_f_power_condition_supported =
30942                                             TRUE;
30943                                 }
30944                                 if (SD_PM_CAP_LOG_SUPPORTED(pm_cap)) {
30945                                         un->un_f_log_sense_supported = TRUE;
30946                                         un->un_f_pm_log_sense_smart =
30947                                             SD_PM_CAP_SMART_LOG(pm_cap);
30948                                 }
30949                         }
30950 
30951                         SD_INFO(SD_LOG_ATTACH_DETACH, un,
30952                             "sd_unit_attach: un:0x%p pm-capable "
30953                             "property set to %d.\n", un, un->un_f_pm_supported);
30954                 }
30955         }
30956 
30957         if (un->un_f_is_hotpluggable) {
30958 
30959                 /*
30960                  * Have to watch hotpluggable devices as well, since
30961                  * that's the only way for userland applications to
30962                  * detect hot removal while device is busy/mounted.
30963                  */
30964                 un->un_f_monitor_media_state = TRUE;
30965 
30966                 un->un_f_check_start_stop = TRUE;
30967 
30968         }
30969 }
30970 
30971 /*
30972  * sd_tg_rdwr:
30973  * Provides rdwr access for cmlb via sd_tgops. The start_block is
30974  * in sys block size, req_length in bytes.
30975  *
30976  */
30977 static int
30978 sd_tg_rdwr(dev_info_t *devi, uchar_t cmd, void *bufaddr,
30979     diskaddr_t start_block, size_t reqlength, void *tg_cookie)
30980 {
30981         struct sd_lun *un;
30982         int path_flag = (int)(uintptr_t)tg_cookie;
30983         char *dkl = NULL;
30984         diskaddr_t real_addr = start_block;
30985         diskaddr_t first_byte, end_block;
30986 
30987         size_t  buffer_size = reqlength;
30988         int rval = 0;
30989         diskaddr_t      cap;
30990         uint32_t        lbasize;
30991         sd_ssc_t        *ssc;
30992 
30993         un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
30994         if (un == NULL)
30995                 return (ENXIO);
30996 
30997         if (cmd != TG_READ && cmd != TG_WRITE)
30998                 return (EINVAL);
30999 
31000         ssc = sd_ssc_init(un);
31001         mutex_enter(SD_MUTEX(un));
31002         if (un->un_f_tgt_blocksize_is_valid == FALSE) {
31003                 mutex_exit(SD_MUTEX(un));
31004                 rval = sd_send_scsi_READ_CAPACITY(ssc, (uint64_t *)&cap,
31005                     &lbasize, path_flag);
31006                 if (rval != 0)
31007                         goto done1;
31008                 mutex_enter(SD_MUTEX(un));
31009                 sd_update_block_info(un, lbasize, cap);
31010                 if ((un->un_f_tgt_blocksize_is_valid == FALSE)) {
31011                         mutex_exit(SD_MUTEX(un));
31012                         rval = EIO;
31013                         goto done;
31014                 }
31015         }
31016 
31017         if (NOT_DEVBSIZE(un)) {
31018                 /*
31019                  * sys_blocksize != tgt_blocksize, need to re-adjust
31020                  * blkno and save the index to beginning of dk_label
31021                  */
31022                 first_byte  = SD_SYSBLOCKS2BYTES(start_block);
31023                 real_addr = first_byte / un->un_tgt_blocksize;
31024 
31025                 end_block = (first_byte + reqlength +
31026                     un->un_tgt_blocksize - 1) / un->un_tgt_blocksize;
31027 
31028                 /* round up buffer size to multiple of target block size */
31029                 buffer_size = (end_block - real_addr) * un->un_tgt_blocksize;
31030 
31031                 SD_TRACE(SD_LOG_IO_PARTITION, un, "sd_tg_rdwr",
31032                     "label_addr: 0x%x allocation size: 0x%x\n",
31033                     real_addr, buffer_size);
31034 
31035                 if (((first_byte % un->un_tgt_blocksize) != 0) ||
31036                     (reqlength % un->un_tgt_blocksize) != 0)
31037                         /* the request is not aligned */
31038                         dkl = kmem_zalloc(buffer_size, KM_SLEEP);
31039         }
31040 
31041         /*
31042          * The MMC standard allows READ CAPACITY to be
31043          * inaccurate by a bounded amount (in the interest of
31044          * response latency).  As a result, failed READs are
31045          * commonplace (due to the reading of metadata and not
31046          * data). Depending on the per-Vendor/drive Sense data,
31047          * the failed READ can cause many (unnecessary) retries.
31048          */
31049 
31050         if (ISCD(un) && (cmd == TG_READ) &&
31051             (un->un_f_blockcount_is_valid == TRUE) &&
31052             ((start_block == (un->un_blockcount - 1))||
31053             (start_block == (un->un_blockcount - 2)))) {
31054                         path_flag = SD_PATH_DIRECT_PRIORITY;
31055         }
31056 
31057         mutex_exit(SD_MUTEX(un));
31058         if (cmd == TG_READ) {
31059                 rval = sd_send_scsi_READ(ssc, (dkl != NULL)? dkl: bufaddr,
31060                     buffer_size, real_addr, path_flag);
31061                 if (dkl != NULL)
31062                         bcopy(dkl + SD_TGTBYTEOFFSET(un, start_block,
31063                             real_addr), bufaddr, reqlength);
31064         } else {
31065                 if (dkl) {
31066                         rval = sd_send_scsi_READ(ssc, dkl, buffer_size,
31067                             real_addr, path_flag);
31068                         if (rval) {
31069                                 goto done1;
31070                         }
31071                         bcopy(bufaddr, dkl + SD_TGTBYTEOFFSET(un, start_block,
31072                             real_addr), reqlength);
31073                 }
31074                 rval = sd_send_scsi_WRITE(ssc, (dkl != NULL)? dkl: bufaddr,
31075                     buffer_size, real_addr, path_flag);
31076         }
31077 
31078 done1:
31079         if (dkl != NULL)
31080                 kmem_free(dkl, buffer_size);
31081 
31082         if (rval != 0) {
31083                 if (rval == EIO)
31084                         sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK);
31085                 else
31086                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
31087         }
31088 done:
31089         sd_ssc_fini(ssc);
31090         return (rval);
31091 }
31092 
31093 
31094 static int
31095 sd_tg_getinfo(dev_info_t *devi, int cmd, void *arg, void *tg_cookie)
31096 {
31097 
31098         struct sd_lun *un;
31099         diskaddr_t      cap;
31100         uint32_t        lbasize;
31101         int             path_flag = (int)(uintptr_t)tg_cookie;
31102         int             ret = 0;
31103 
31104         un = ddi_get_soft_state(sd_state, ddi_get_instance(devi));
31105         if (un == NULL)
31106                 return (ENXIO);
31107 
31108         switch (cmd) {
31109         case TG_GETPHYGEOM:
31110         case TG_GETVIRTGEOM:
31111         case TG_GETCAPACITY:
31112         case TG_GETBLOCKSIZE:
31113                 mutex_enter(SD_MUTEX(un));
31114 
31115                 if ((un->un_f_blockcount_is_valid == TRUE) &&
31116                     (un->un_f_tgt_blocksize_is_valid == TRUE)) {
31117                         cap = un->un_blockcount;
31118                         lbasize = un->un_tgt_blocksize;
31119                         mutex_exit(SD_MUTEX(un));
31120                 } else {
31121                         sd_ssc_t        *ssc;
31122                         mutex_exit(SD_MUTEX(un));
31123                         ssc = sd_ssc_init(un);
31124                         ret = sd_send_scsi_READ_CAPACITY(ssc, (uint64_t *)&cap,
31125                             &lbasize, path_flag);
31126                         if (ret != 0) {
31127                                 if (ret == EIO)
31128                                         sd_ssc_assessment(ssc,
31129                                             SD_FMT_STATUS_CHECK);
31130                                 else
31131                                         sd_ssc_assessment(ssc,
31132                                             SD_FMT_IGNORE);
31133                                 sd_ssc_fini(ssc);
31134                                 return (ret);
31135                         }
31136                         sd_ssc_fini(ssc);
31137                         mutex_enter(SD_MUTEX(un));
31138                         sd_update_block_info(un, lbasize, cap);
31139                         if ((un->un_f_blockcount_is_valid == FALSE) ||
31140                             (un->un_f_tgt_blocksize_is_valid == FALSE)) {
31141                                 mutex_exit(SD_MUTEX(un));
31142                                 return (EIO);
31143                         }
31144                         mutex_exit(SD_MUTEX(un));
31145                 }
31146 
31147                 if (cmd == TG_GETCAPACITY) {
31148                         *(diskaddr_t *)arg = cap;
31149                         return (0);
31150                 }
31151 
31152                 if (cmd == TG_GETBLOCKSIZE) {
31153                         *(uint32_t *)arg = lbasize;
31154                         return (0);
31155                 }
31156 
31157                 if (cmd == TG_GETPHYGEOM)
31158                         ret = sd_get_physical_geometry(un, (cmlb_geom_t *)arg,
31159                             cap, lbasize, path_flag);
31160                 else
31161                         /* TG_GETVIRTGEOM */
31162                         ret = sd_get_virtual_geometry(un,
31163                             (cmlb_geom_t *)arg, cap, lbasize);
31164 
31165                 return (ret);
31166 
31167         case TG_GETATTR:
31168                 mutex_enter(SD_MUTEX(un));
31169                 ((tg_attribute_t *)arg)->media_is_writable =
31170                     un->un_f_mmc_writable_media;
31171                 ((tg_attribute_t *)arg)->media_is_solid_state =
31172                     un->un_f_is_solid_state;
31173                 mutex_exit(SD_MUTEX(un));
31174                 return (0);
31175         default:
31176                 return (ENOTTY);
31177 
31178         }
31179 }
31180 
31181 /*
31182  *    Function: sd_ssc_ereport_post
31183  *
31184  * Description: Will be called when SD driver need to post an ereport.
31185  *
31186  *    Context: Kernel thread or interrupt context.
31187  */
31188 
31189 #define DEVID_IF_KNOWN(d) "devid", DATA_TYPE_STRING, (d) ? (d) : "unknown"
31190 
31191 static void
31192 sd_ssc_ereport_post(sd_ssc_t *ssc, enum sd_driver_assessment drv_assess)
31193 {
31194         int uscsi_path_instance = 0;
31195         uchar_t uscsi_pkt_reason;
31196         uint32_t uscsi_pkt_state;
31197         uint32_t uscsi_pkt_statistics;
31198         uint64_t uscsi_ena;
31199         uchar_t op_code;
31200         uint8_t *sensep;
31201         union scsi_cdb *cdbp;
31202         uint_t cdblen = 0;
31203         uint_t senlen = 0;
31204         struct sd_lun *un;
31205         dev_info_t *dip;
31206         char *devid;
31207         int ssc_invalid_flags = SSC_FLAGS_INVALID_PKT_REASON |
31208             SSC_FLAGS_INVALID_STATUS |
31209             SSC_FLAGS_INVALID_SENSE |
31210             SSC_FLAGS_INVALID_DATA;
31211         char assessment[16];
31212 
31213         ASSERT(ssc != NULL);
31214         ASSERT(ssc->ssc_uscsi_cmd != NULL);
31215         ASSERT(ssc->ssc_uscsi_info != NULL);
31216 
31217         un = ssc->ssc_un;
31218         ASSERT(un != NULL);
31219 
31220         dip = un->un_sd->sd_dev;
31221 
31222         /*
31223          * Get the devid:
31224          *      devid will only be passed to non-transport error reports.
31225          */
31226         devid = DEVI(dip)->devi_devid_str;
31227 
31228         /*
31229          * If we are syncing or dumping, the command will not be executed
31230          * so we bypass this situation.
31231          */
31232         if (ddi_in_panic() || (un->un_state == SD_STATE_SUSPENDED) ||
31233             (un->un_state == SD_STATE_DUMPING))
31234                 return;
31235 
31236         uscsi_pkt_reason = ssc->ssc_uscsi_info->ui_pkt_reason;
31237         uscsi_path_instance = ssc->ssc_uscsi_cmd->uscsi_path_instance;
31238         uscsi_pkt_state = ssc->ssc_uscsi_info->ui_pkt_state;
31239         uscsi_pkt_statistics = ssc->ssc_uscsi_info->ui_pkt_statistics;
31240         uscsi_ena = ssc->ssc_uscsi_info->ui_ena;
31241 
31242         sensep = (uint8_t *)ssc->ssc_uscsi_cmd->uscsi_rqbuf;
31243         cdbp = (union scsi_cdb *)ssc->ssc_uscsi_cmd->uscsi_cdb;
31244 
31245         /* In rare cases, EG:DOORLOCK, the cdb could be NULL */
31246         if (cdbp == NULL) {
31247                 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN,
31248                     "sd_ssc_ereport_post meet empty cdb\n");
31249                 return;
31250         }
31251 
31252         op_code = cdbp->scc_cmd;
31253 
31254         cdblen = (int)ssc->ssc_uscsi_cmd->uscsi_cdblen;
31255         senlen = (int)(ssc->ssc_uscsi_cmd->uscsi_rqlen -
31256             ssc->ssc_uscsi_cmd->uscsi_rqresid);
31257 
31258         if (senlen > 0)
31259                 ASSERT(sensep != NULL);
31260 
31261         /*
31262          * Initialize drv_assess to corresponding values.
31263          * SD_FM_DRV_FATAL will be mapped to "fail" or "fatal" depending
31264          * on the sense-key returned back.
31265          */
31266         switch (drv_assess) {
31267                 case SD_FM_DRV_RECOVERY:
31268                         (void) sprintf(assessment, "%s", "recovered");
31269                         break;
31270                 case SD_FM_DRV_RETRY:
31271                         (void) sprintf(assessment, "%s", "retry");
31272                         break;
31273                 case SD_FM_DRV_NOTICE:
31274                         (void) sprintf(assessment, "%s", "info");
31275                         break;
31276                 case SD_FM_DRV_FATAL:
31277                 default:
31278                         (void) sprintf(assessment, "%s", "unknown");
31279         }
31280         /*
31281          * If drv_assess == SD_FM_DRV_RECOVERY, this should be a recovered
31282          * command, we will post ereport.io.scsi.cmd.disk.recovered.
31283          * driver-assessment will always be "recovered" here.
31284          */
31285         if (drv_assess == SD_FM_DRV_RECOVERY) {
31286                 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance, NULL,
31287                     "cmd.disk.recovered", uscsi_ena, devid, NULL,
31288                     DDI_NOSLEEP, NULL,
31289                     FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31290                     DEVID_IF_KNOWN(devid),
31291                     "driver-assessment", DATA_TYPE_STRING, assessment,
31292                     "op-code", DATA_TYPE_UINT8, op_code,
31293                     "cdb", DATA_TYPE_UINT8_ARRAY,
31294                     cdblen, ssc->ssc_uscsi_cmd->uscsi_cdb,
31295                     "pkt-reason", DATA_TYPE_UINT8, uscsi_pkt_reason,
31296                     "pkt-state", DATA_TYPE_UINT32, uscsi_pkt_state,
31297                     "pkt-stats", DATA_TYPE_UINT32, uscsi_pkt_statistics,
31298                     NULL);
31299                 return;
31300         }
31301 
31302         /*
31303          * If there is un-expected/un-decodable data, we should post
31304          * ereport.io.scsi.cmd.disk.dev.uderr.
31305          * driver-assessment will be set based on parameter drv_assess.
31306          * SSC_FLAGS_INVALID_SENSE - invalid sense data sent back.
31307          * SSC_FLAGS_INVALID_PKT_REASON - invalid pkt-reason encountered.
31308          * SSC_FLAGS_INVALID_STATUS - invalid stat-code encountered.
31309          * SSC_FLAGS_INVALID_DATA - invalid data sent back.
31310          */
31311         if (ssc->ssc_flags & ssc_invalid_flags) {
31312                 if (ssc->ssc_flags & SSC_FLAGS_INVALID_SENSE) {
31313                         scsi_fm_ereport_post(un->un_sd, uscsi_path_instance,
31314                             NULL, "cmd.disk.dev.uderr", uscsi_ena, devid,
31315                             NULL, DDI_NOSLEEP, NULL,
31316                             FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31317                             DEVID_IF_KNOWN(devid),
31318                             "driver-assessment", DATA_TYPE_STRING,
31319                             drv_assess == SD_FM_DRV_FATAL ?
31320                             "fail" : assessment,
31321                             "op-code", DATA_TYPE_UINT8, op_code,
31322                             "cdb", DATA_TYPE_UINT8_ARRAY,
31323                             cdblen, ssc->ssc_uscsi_cmd->uscsi_cdb,
31324                             "pkt-reason", DATA_TYPE_UINT8, uscsi_pkt_reason,
31325                             "pkt-state", DATA_TYPE_UINT32, uscsi_pkt_state,
31326                             "pkt-stats", DATA_TYPE_UINT32,
31327                             uscsi_pkt_statistics,
31328                             "stat-code", DATA_TYPE_UINT8,
31329                             ssc->ssc_uscsi_cmd->uscsi_status,
31330                             "un-decode-info", DATA_TYPE_STRING,
31331                             ssc->ssc_info,
31332                             "un-decode-value", DATA_TYPE_UINT8_ARRAY,
31333                             senlen, sensep,
31334                             NULL);
31335                 } else {
31336                         /*
31337                          * For other type of invalid data, the
31338                          * un-decode-value field would be empty because the
31339                          * un-decodable content could be seen from upper
31340                          * level payload or inside un-decode-info.
31341                          */
31342                         scsi_fm_ereport_post(un->un_sd, uscsi_path_instance,
31343                             NULL,
31344                             "cmd.disk.dev.uderr", uscsi_ena, devid,
31345                             NULL, DDI_NOSLEEP, NULL,
31346                             FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31347                             DEVID_IF_KNOWN(devid),
31348                             "driver-assessment", DATA_TYPE_STRING,
31349                             drv_assess == SD_FM_DRV_FATAL ?
31350                             "fail" : assessment,
31351                             "op-code", DATA_TYPE_UINT8, op_code,
31352                             "cdb", DATA_TYPE_UINT8_ARRAY,
31353                             cdblen, ssc->ssc_uscsi_cmd->uscsi_cdb,
31354                             "pkt-reason", DATA_TYPE_UINT8, uscsi_pkt_reason,
31355                             "pkt-state", DATA_TYPE_UINT32, uscsi_pkt_state,
31356                             "pkt-stats", DATA_TYPE_UINT32,
31357                             uscsi_pkt_statistics,
31358                             "stat-code", DATA_TYPE_UINT8,
31359                             ssc->ssc_uscsi_cmd->uscsi_status,
31360                             "un-decode-info", DATA_TYPE_STRING,
31361                             ssc->ssc_info,
31362                             "un-decode-value", DATA_TYPE_UINT8_ARRAY,
31363                             0, NULL,
31364                             NULL);
31365                 }
31366                 ssc->ssc_flags &= ~ssc_invalid_flags;
31367                 return;
31368         }
31369 
31370         if (uscsi_pkt_reason != CMD_CMPLT ||
31371             (ssc->ssc_flags & SSC_FLAGS_TRAN_ABORT)) {
31372                 /*
31373                  * pkt-reason != CMD_CMPLT or SSC_FLAGS_TRAN_ABORT was
31374                  * set inside sd_start_cmds due to errors(bad packet or
31375                  * fatal transport error), we should take it as a
31376                  * transport error, so we post ereport.io.scsi.cmd.disk.tran.
31377                  * driver-assessment will be set based on drv_assess.
31378                  * We will set devid to NULL because it is a transport
31379                  * error.
31380                  */
31381                 if (ssc->ssc_flags & SSC_FLAGS_TRAN_ABORT)
31382                         ssc->ssc_flags &= ~SSC_FLAGS_TRAN_ABORT;
31383 
31384                 scsi_fm_ereport_post(un->un_sd, uscsi_path_instance, NULL,
31385                     "cmd.disk.tran", uscsi_ena, NULL, NULL, DDI_NOSLEEP, NULL,
31386                     FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31387                     DEVID_IF_KNOWN(devid),
31388                     "driver-assessment", DATA_TYPE_STRING,
31389                     drv_assess == SD_FM_DRV_FATAL ? "fail" : assessment,
31390                     "op-code", DATA_TYPE_UINT8, op_code,
31391                     "cdb", DATA_TYPE_UINT8_ARRAY,
31392                     cdblen, ssc->ssc_uscsi_cmd->uscsi_cdb,
31393                     "pkt-reason", DATA_TYPE_UINT8, uscsi_pkt_reason,
31394                     "pkt-state", DATA_TYPE_UINT8, uscsi_pkt_state,
31395                     "pkt-stats", DATA_TYPE_UINT32, uscsi_pkt_statistics,
31396                     NULL);
31397         } else {
31398                 /*
31399                  * If we got here, we have a completed command, and we need
31400                  * to further investigate the sense data to see what kind
31401                  * of ereport we should post.
31402                  * Post ereport.io.scsi.cmd.disk.dev.rqs.merr
31403                  * if sense-key == 0x3.
31404                  * Post ereport.io.scsi.cmd.disk.dev.rqs.derr otherwise.
31405                  * driver-assessment will be set based on the parameter
31406                  * drv_assess.
31407                  */
31408                 if (senlen > 0) {
31409                         /*
31410                          * Here we have sense data available.
31411                          */
31412                         uint8_t sense_key;
31413                         sense_key = scsi_sense_key(sensep);
31414                         if (sense_key == 0x3) {
31415                                 /*
31416                                  * sense-key == 0x3(medium error),
31417                                  * driver-assessment should be "fatal" if
31418                                  * drv_assess is SD_FM_DRV_FATAL.
31419                                  */
31420                                 scsi_fm_ereport_post(un->un_sd,
31421                                     uscsi_path_instance, NULL,
31422                                     "cmd.disk.dev.rqs.merr",
31423                                     uscsi_ena, devid, NULL, DDI_NOSLEEP, NULL,
31424                                     FM_VERSION, DATA_TYPE_UINT8,
31425                                     FM_EREPORT_VERS0,
31426                                     DEVID_IF_KNOWN(devid),
31427                                     "driver-assessment",
31428                                     DATA_TYPE_STRING,
31429                                     drv_assess == SD_FM_DRV_FATAL ?
31430                                     "fatal" : assessment,
31431                                     "op-code",
31432                                     DATA_TYPE_UINT8, op_code,
31433                                     "cdb",
31434                                     DATA_TYPE_UINT8_ARRAY, cdblen,
31435                                     ssc->ssc_uscsi_cmd->uscsi_cdb,
31436                                     "pkt-reason",
31437                                     DATA_TYPE_UINT8, uscsi_pkt_reason,
31438                                     "pkt-state",
31439                                     DATA_TYPE_UINT8, uscsi_pkt_state,
31440                                     "pkt-stats",
31441                                     DATA_TYPE_UINT32,
31442                                     uscsi_pkt_statistics,
31443                                     "stat-code",
31444                                     DATA_TYPE_UINT8,
31445                                     ssc->ssc_uscsi_cmd->uscsi_status,
31446                                     "key",
31447                                     DATA_TYPE_UINT8,
31448                                     scsi_sense_key(sensep),
31449                                     "asc",
31450                                     DATA_TYPE_UINT8,
31451                                     scsi_sense_asc(sensep),
31452                                     "ascq",
31453                                     DATA_TYPE_UINT8,
31454                                     scsi_sense_ascq(sensep),
31455                                     "sense-data",
31456                                     DATA_TYPE_UINT8_ARRAY,
31457                                     senlen, sensep,
31458                                     "lba",
31459                                     DATA_TYPE_UINT64,
31460                                     ssc->ssc_uscsi_info->ui_lba,
31461                                     NULL);
31462                                 } else {
31463                                         /*
31464                                          * if sense-key == 0x4(hardware
31465                                          * error), driver-assessment should
31466                                          * be "fatal" if drv_assess is
31467                                          * SD_FM_DRV_FATAL.
31468                                          */
31469                                         scsi_fm_ereport_post(un->un_sd,
31470                                             uscsi_path_instance, NULL,
31471                                             "cmd.disk.dev.rqs.derr",
31472                                             uscsi_ena, devid,
31473                                             NULL, DDI_NOSLEEP, NULL,
31474                                             FM_VERSION,
31475                                             DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31476                                             DEVID_IF_KNOWN(devid),
31477                                             "driver-assessment",
31478                                             DATA_TYPE_STRING,
31479                                             drv_assess == SD_FM_DRV_FATAL ?
31480                                             (sense_key == 0x4 ?
31481                                             "fatal" : "fail") : assessment,
31482                                             "op-code",
31483                                             DATA_TYPE_UINT8, op_code,
31484                                             "cdb",
31485                                             DATA_TYPE_UINT8_ARRAY, cdblen,
31486                                             ssc->ssc_uscsi_cmd->uscsi_cdb,
31487                                             "pkt-reason",
31488                                             DATA_TYPE_UINT8, uscsi_pkt_reason,
31489                                             "pkt-state",
31490                                             DATA_TYPE_UINT8, uscsi_pkt_state,
31491                                             "pkt-stats",
31492                                             DATA_TYPE_UINT32,
31493                                             uscsi_pkt_statistics,
31494                                             "stat-code",
31495                                             DATA_TYPE_UINT8,
31496                                             ssc->ssc_uscsi_cmd->uscsi_status,
31497                                             "key",
31498                                             DATA_TYPE_UINT8,
31499                                             scsi_sense_key(sensep),
31500                                             "asc",
31501                                             DATA_TYPE_UINT8,
31502                                             scsi_sense_asc(sensep),
31503                                             "ascq",
31504                                             DATA_TYPE_UINT8,
31505                                             scsi_sense_ascq(sensep),
31506                                             "sense-data",
31507                                             DATA_TYPE_UINT8_ARRAY,
31508                                             senlen, sensep,
31509                                             NULL);
31510                                 }
31511                 } else {
31512                         /*
31513                          * For stat_code == STATUS_GOOD, this is not a
31514                          * hardware error.
31515                          */
31516                         if (ssc->ssc_uscsi_cmd->uscsi_status == STATUS_GOOD)
31517                                 return;
31518 
31519                         /*
31520                          * Post ereport.io.scsi.cmd.disk.dev.serr if we got the
31521                          * stat-code but with sense data unavailable.
31522                          * driver-assessment will be set based on parameter
31523                          * drv_assess.
31524                          */
31525                         scsi_fm_ereport_post(un->un_sd, uscsi_path_instance,
31526                             NULL,
31527                             "cmd.disk.dev.serr", uscsi_ena,
31528                             devid, NULL, DDI_NOSLEEP, NULL,
31529                             FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0,
31530                             DEVID_IF_KNOWN(devid),
31531                             "driver-assessment", DATA_TYPE_STRING,
31532                             drv_assess == SD_FM_DRV_FATAL ? "fail" : assessment,
31533                             "op-code", DATA_TYPE_UINT8, op_code,
31534                             "cdb",
31535                             DATA_TYPE_UINT8_ARRAY,
31536                             cdblen, ssc->ssc_uscsi_cmd->uscsi_cdb,
31537                             "pkt-reason",
31538                             DATA_TYPE_UINT8, uscsi_pkt_reason,
31539                             "pkt-state",
31540                             DATA_TYPE_UINT8, uscsi_pkt_state,
31541                             "pkt-stats",
31542                             DATA_TYPE_UINT32, uscsi_pkt_statistics,
31543                             "stat-code",
31544                             DATA_TYPE_UINT8,
31545                             ssc->ssc_uscsi_cmd->uscsi_status,
31546                             NULL);
31547                 }
31548         }
31549 }
31550 
31551 /*
31552  *     Function: sd_ssc_extract_info
31553  *
31554  * Description: Extract information available to help generate ereport.
31555  *
31556  *     Context: Kernel thread or interrupt context.
31557  */
31558 static void
31559 sd_ssc_extract_info(sd_ssc_t *ssc, struct sd_lun *un, struct scsi_pkt *pktp,
31560     struct buf *bp, struct sd_xbuf *xp)
31561 {
31562         size_t senlen = 0;
31563         union scsi_cdb *cdbp;
31564         int path_instance;
31565         /*
31566          * Need scsi_cdb_size array to determine the cdb length.
31567          */
31568         extern uchar_t  scsi_cdb_size[];
31569 
31570         ASSERT(un != NULL);
31571         ASSERT(pktp != NULL);
31572         ASSERT(bp != NULL);
31573         ASSERT(xp != NULL);
31574         ASSERT(ssc != NULL);
31575         ASSERT(mutex_owned(SD_MUTEX(un)));
31576 
31577         /*
31578          * Transfer the cdb buffer pointer here.
31579          */
31580         cdbp = (union scsi_cdb *)pktp->pkt_cdbp;
31581 
31582         ssc->ssc_uscsi_cmd->uscsi_cdblen = scsi_cdb_size[GETGROUP(cdbp)];
31583         ssc->ssc_uscsi_cmd->uscsi_cdb = (caddr_t)cdbp;
31584 
31585         /*
31586          * Transfer the sense data buffer pointer if sense data is available,
31587          * calculate the sense data length first.
31588          */
31589         if ((xp->xb_sense_state & STATE_XARQ_DONE) ||
31590             (xp->xb_sense_state & STATE_ARQ_DONE)) {
31591                 /*
31592                  * For arq case, we will enter here.
31593                  */
31594                 if (xp->xb_sense_state & STATE_XARQ_DONE) {
31595                         senlen = MAX_SENSE_LENGTH - xp->xb_sense_resid;
31596                 } else {
31597                         senlen = SENSE_LENGTH;
31598                 }
31599         } else {
31600                 /*
31601                  * For non-arq case, we will enter this branch.
31602                  */
31603                 if (SD_GET_PKT_STATUS(pktp) == STATUS_CHECK &&
31604                     (xp->xb_sense_state & STATE_XFERRED_DATA)) {
31605                         senlen = SENSE_LENGTH - xp->xb_sense_resid;
31606                 }
31607 
31608         }
31609 
31610         ssc->ssc_uscsi_cmd->uscsi_rqlen = (senlen & 0xff);
31611         ssc->ssc_uscsi_cmd->uscsi_rqresid = 0;
31612         ssc->ssc_uscsi_cmd->uscsi_rqbuf = (caddr_t)xp->xb_sense_data;
31613 
31614         ssc->ssc_uscsi_cmd->uscsi_status = ((*(pktp)->pkt_scbp) & STATUS_MASK);
31615 
31616         /*
31617          * Only transfer path_instance when scsi_pkt was properly allocated.
31618          */
31619         path_instance = pktp->pkt_path_instance;
31620         if (scsi_pkt_allocated_correctly(pktp) && path_instance)
31621                 ssc->ssc_uscsi_cmd->uscsi_path_instance = path_instance;
31622         else
31623                 ssc->ssc_uscsi_cmd->uscsi_path_instance = 0;
31624 
31625         /*
31626          * Copy in the other fields we may need when posting ereport.
31627          */
31628         ssc->ssc_uscsi_info->ui_pkt_reason = pktp->pkt_reason;
31629         ssc->ssc_uscsi_info->ui_pkt_state = pktp->pkt_state;
31630         ssc->ssc_uscsi_info->ui_pkt_statistics = pktp->pkt_statistics;
31631         ssc->ssc_uscsi_info->ui_lba = (uint64_t)SD_GET_BLKNO(bp);
31632 
31633         /*
31634          * For partially read/write command, we will not create ena
31635          * in case of a successful command be reconized as recovered.
31636          */
31637         if ((pktp->pkt_reason == CMD_CMPLT) &&
31638             (ssc->ssc_uscsi_cmd->uscsi_status == STATUS_GOOD) &&
31639             (senlen == 0)) {
31640                 return;
31641         }
31642 
31643         /*
31644          * To associate ereports of a single command execution flow, we
31645          * need a shared ena for a specific command.
31646          */
31647         if (xp->xb_ena == 0)
31648                 xp->xb_ena = fm_ena_generate(0, FM_ENA_FMT1);
31649         ssc->ssc_uscsi_info->ui_ena = xp->xb_ena;
31650 }
31651 
31652 
31653 /*
31654  *     Function: sd_check_solid_state
31655  *
31656  * Description: Query the optional INQUIRY VPD page 0xb1. If the device
31657  *              supports VPD page 0xb1, sd examines the MEDIUM ROTATION
31658  *              RATE. If the MEDIUM ROTATION RATE is 1, sd assumes the
31659  *              device is a solid state drive.
31660  *
31661  *     Context: Kernel thread or interrupt context.
31662  */
31663 
31664 static void
31665 sd_check_solid_state(sd_ssc_t *ssc)
31666 {
31667         int             rval            = 0;
31668         uchar_t         *inqb1          = NULL;
31669         size_t          inqb1_len       = MAX_INQUIRY_SIZE;
31670         size_t          inqb1_resid     = 0;
31671         struct sd_lun   *un;
31672 
31673         ASSERT(ssc != NULL);
31674         un = ssc->ssc_un;
31675         ASSERT(un != NULL);
31676         ASSERT(!mutex_owned(SD_MUTEX(un)));
31677 
31678         mutex_enter(SD_MUTEX(un));
31679         un->un_f_is_solid_state = FALSE;
31680 
31681         if (ISCD(un)) {
31682                 mutex_exit(SD_MUTEX(un));
31683                 return;
31684         }
31685 
31686         if (sd_check_vpd_page_support(ssc) == 0 &&
31687             un->un_vpd_page_mask & SD_VPD_DEV_CHARACTER_PG) {
31688                 mutex_exit(SD_MUTEX(un));
31689                 /* collect page b1 data */
31690                 inqb1 = kmem_zalloc(inqb1_len, KM_SLEEP);
31691 
31692                 rval = sd_send_scsi_INQUIRY(ssc, inqb1, inqb1_len,
31693                     0x01, 0xB1, &inqb1_resid);
31694 
31695                 if (rval == 0 && (inqb1_len - inqb1_resid > 5)) {
31696                         SD_TRACE(SD_LOG_COMMON, un,
31697                             "sd_check_solid_state: \
31698                             successfully get VPD page: %x \
31699                             PAGE LENGTH: %x BYTE 4: %x \
31700                             BYTE 5: %x", inqb1[1], inqb1[3], inqb1[4],
31701                             inqb1[5]);
31702 
31703                         mutex_enter(SD_MUTEX(un));
31704                         /*
31705                          * Check the MEDIUM ROTATION RATE. If it is set
31706                          * to 1, the device is a solid state drive.
31707                          */
31708                         if (inqb1[4] == 0 && inqb1[5] == 1) {
31709                                 un->un_f_is_solid_state = TRUE;
31710                                 /* solid state drives don't need disksort */
31711                                 un->un_f_disksort_disabled = TRUE;
31712                         }
31713                         mutex_exit(SD_MUTEX(un));
31714                 } else if (rval != 0) {
31715                         sd_ssc_assessment(ssc, SD_FMT_IGNORE);
31716                 }
31717 
31718                 kmem_free(inqb1, inqb1_len);
31719         } else {
31720                 mutex_exit(SD_MUTEX(un));
31721         }
31722 }
31723 
31724 /*
31725  *      Function: sd_check_emulation_mode
31726  *
31727  *   Description: Check whether the SSD is at emulation mode
31728  *                by issuing READ_CAPACITY_16 to see whether
31729  *                we can get physical block size of the drive.
31730  *
31731  *       Context: Kernel thread or interrupt context.
31732  */
31733 
31734 static void
31735 sd_check_emulation_mode(sd_ssc_t *ssc)
31736 {
31737         int             rval = 0;
31738         uint64_t        capacity;
31739         uint_t          lbasize;
31740         uint_t          pbsize;
31741         int             i;
31742         int             devid_len;
31743         struct sd_lun   *un;
31744 
31745         ASSERT(ssc != NULL);
31746         un = ssc->ssc_un;
31747         ASSERT(un != NULL);
31748         ASSERT(!mutex_owned(SD_MUTEX(un)));
31749 
31750         mutex_enter(SD_MUTEX(un));
31751         if (ISCD(un)) {
31752                 mutex_exit(SD_MUTEX(un));
31753                 return;
31754         }
31755 
31756         if (un->un_f_descr_format_supported) {
31757                 mutex_exit(SD_MUTEX(un));
31758                 rval = sd_send_scsi_READ_CAPACITY_16(ssc, &capacity, &lbasize,
31759                     &pbsize, SD_PATH_DIRECT);
31760                 mutex_enter(SD_MUTEX(un));
31761 
31762                 if (rval != 0) {
31763                         un->un_phy_blocksize = DEV_BSIZE;
31764                 } else {
31765                         if (!ISP2(pbsize % DEV_BSIZE) || pbsize == 0) {
31766                                 un->un_phy_blocksize = DEV_BSIZE;
31767                         } else if (pbsize > un->un_phy_blocksize) {
31768                                 /*
31769                                  * Don't reset the physical blocksize
31770                                  * unless we've detected a larger value.
31771                                  */
31772                                 un->un_phy_blocksize = pbsize;
31773                         }
31774                 }
31775         }
31776 
31777         for (i = 0; i < sd_flash_dev_table_size; i++) {
31778                 devid_len = (int)strlen(sd_flash_dev_table[i]);
31779                 if (sd_sdconf_id_match(un, sd_flash_dev_table[i], devid_len)
31780                     == SD_SUCCESS) {
31781                         un->un_phy_blocksize = SSD_SECSIZE;
31782                         if (un->un_f_is_solid_state &&
31783                             un->un_phy_blocksize != un->un_tgt_blocksize)
31784                                 un->un_f_enable_rmw = TRUE;
31785                 }
31786         }
31787 
31788         mutex_exit(SD_MUTEX(un));
31789 }