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 (c) 2011 Bayard G. Bell. All rights reserved. 27 * Copyright (c) 2012 by Delphix. All rights reserved. 28 * Copyright 2014 Nexenta Systems, Inc. All rights reserved. 29 * Copyright 2012 DEY Storage Systems, Inc. All rights reserved. 30 */ 31 /* 32 * Copyright 2011 cyril.galibern@opensvc.com 33 */ 34 35 /* 36 * SCSI disk target driver. 37 */ 38 #include <sys/scsi/scsi.h> 39 #include <sys/dkbad.h> 40 #include <sys/dklabel.h> 41 #include <sys/dkio.h> 42 #include <sys/fdio.h> 43 #include <sys/cdio.h> 44 #include <sys/mhd.h> 45 #include <sys/vtoc.h> 46 #include <sys/dktp/fdisk.h> 47 #include <sys/kstat.h> 48 #include <sys/vtrace.h> 49 #include <sys/note.h> 50 #include <sys/thread.h> 51 #include <sys/proc.h> 52 #include <sys/efi_partition.h> 53 #include <sys/var.h> 54 #include <sys/aio_req.h> 55 56 #ifdef __lock_lint 57 #define _LP64 58 #define __amd64 59 #endif 60 61 #if (defined(__fibre)) 62 /* Note: is there a leadville version of the following? */ 63 #include <sys/fc4/fcal_linkapp.h> 64 #endif 65 #include <sys/taskq.h> 66 #include <sys/uuid.h> 67 #include <sys/byteorder.h> 68 #include <sys/sdt.h> 69 70 #include "sd_xbuf.h" 71 72 #include <sys/scsi/targets/sddef.h> 73 #include <sys/cmlb.h> 74 #include <sys/sysevent/eventdefs.h> 75 #include <sys/sysevent/dev.h> 76 77 #include <sys/fm/protocol.h> 78 79 /* 80 * Loadable module info. 81 */ 82 #if (defined(__fibre)) 83 #define SD_MODULE_NAME "SCSI SSA/FCAL Disk Driver" 84 #else /* !__fibre */ 85 #define SD_MODULE_NAME "SCSI Disk Driver" 86 #endif /* !__fibre */ 87 88 /* 89 * Define the interconnect type, to allow the driver to distinguish 90 * between parallel SCSI (sd) and fibre channel (ssd) behaviors. 91 * 92 * This is really for backward compatibility. In the future, the driver 93 * should actually check the "interconnect-type" property as reported by 94 * the HBA; however at present this property is not defined by all HBAs, 95 * so we will use this #define (1) to permit the driver to run in 96 * backward-compatibility mode; and (2) to print a notification message 97 * if an FC HBA does not support the "interconnect-type" property. The 98 * behavior of the driver will be to assume parallel SCSI behaviors unless 99 * the "interconnect-type" property is defined by the HBA **AND** has a 100 * value of either INTERCONNECT_FIBRE, INTERCONNECT_SSA, or 101 * INTERCONNECT_FABRIC, in which case the driver will assume Fibre 102 * Channel behaviors (as per the old ssd). (Note that the 103 * INTERCONNECT_1394 and INTERCONNECT_USB types are not supported and 104 * will result in the driver assuming parallel SCSI behaviors.) 105 * 106 * (see common/sys/scsi/impl/services.h) 107 * 108 * Note: For ssd semantics, don't use INTERCONNECT_FABRIC as the default 109 * since some FC HBAs may already support that, and there is some code in 110 * the driver that already looks for it. Using INTERCONNECT_FABRIC as the 111 * default would confuse that code, and besides things should work fine 112 * anyways if the FC HBA already reports INTERCONNECT_FABRIC for the 113 * "interconnect_type" property. 114 * 115 */ 116 #if (defined(__fibre)) 117 #define SD_DEFAULT_INTERCONNECT_TYPE SD_INTERCONNECT_FIBRE 118 #else 119 #define SD_DEFAULT_INTERCONNECT_TYPE SD_INTERCONNECT_PARALLEL 120 #endif 121 122 /* 123 * The name of the driver, established from the module name in _init. 124 */ 125 static char *sd_label = NULL; 126 127 /* 128 * Driver name is unfortunately prefixed on some driver.conf properties. 129 */ 130 #if (defined(__fibre)) 131 #define sd_max_xfer_size ssd_max_xfer_size 132 #define sd_config_list ssd_config_list 133 static char *sd_max_xfer_size = "ssd_max_xfer_size"; 134 static char *sd_config_list = "ssd-config-list"; 135 #else 136 static char *sd_max_xfer_size = "sd_max_xfer_size"; 137 static char *sd_config_list = "sd-config-list"; 138 #endif 139 140 /* 141 * Driver global variables 142 */ 143 144 #if (defined(__fibre)) 145 /* 146 * These #defines are to avoid namespace collisions that occur because this 147 * code is currently used to compile two separate driver modules: sd and ssd. 148 * All global variables need to be treated this way (even if declared static) 149 * in order to allow the debugger to resolve the names properly. 150 * It is anticipated that in the near future the ssd module will be obsoleted, 151 * at which time this namespace issue should go away. 152 */ 153 #define sd_state ssd_state 154 #define sd_io_time ssd_io_time 155 #define sd_failfast_enable ssd_failfast_enable 156 #define sd_ua_retry_count ssd_ua_retry_count 157 #define sd_report_pfa ssd_report_pfa 158 #define sd_max_throttle ssd_max_throttle 159 #define sd_min_throttle ssd_min_throttle 160 #define sd_rot_delay ssd_rot_delay 161 162 #define sd_retry_on_reservation_conflict \ 163 ssd_retry_on_reservation_conflict 164 #define sd_reinstate_resv_delay ssd_reinstate_resv_delay 165 #define sd_resv_conflict_name ssd_resv_conflict_name 166 167 #define sd_component_mask ssd_component_mask 168 #define sd_level_mask ssd_level_mask 169 #define sd_debug_un ssd_debug_un 170 #define sd_error_level ssd_error_level 171 172 #define sd_xbuf_active_limit ssd_xbuf_active_limit 173 #define sd_xbuf_reserve_limit ssd_xbuf_reserve_limit 174 175 #define sd_tr ssd_tr 176 #define sd_reset_throttle_timeout ssd_reset_throttle_timeout 177 #define sd_qfull_throttle_timeout ssd_qfull_throttle_timeout 178 #define sd_qfull_throttle_enable ssd_qfull_throttle_enable 179 #define sd_check_media_time ssd_check_media_time 180 #define sd_wait_cmds_complete ssd_wait_cmds_complete 181 #define sd_label_mutex ssd_label_mutex 182 #define sd_detach_mutex ssd_detach_mutex 183 #define sd_log_buf ssd_log_buf 184 #define sd_log_mutex ssd_log_mutex 185 186 #define sd_disk_table ssd_disk_table 187 #define sd_disk_table_size ssd_disk_table_size 188 #define sd_sense_mutex ssd_sense_mutex 189 #define sd_cdbtab ssd_cdbtab 190 191 #define sd_cb_ops ssd_cb_ops 192 #define sd_ops ssd_ops 193 #define sd_additional_codes ssd_additional_codes 194 #define sd_tgops ssd_tgops 195 196 #define sd_minor_data ssd_minor_data 197 #define sd_minor_data_efi ssd_minor_data_efi 198 199 #define sd_tq ssd_tq 200 #define sd_wmr_tq ssd_wmr_tq 201 #define sd_taskq_name ssd_taskq_name 202 #define sd_wmr_taskq_name ssd_wmr_taskq_name 203 #define sd_taskq_minalloc ssd_taskq_minalloc 204 #define sd_taskq_maxalloc ssd_taskq_maxalloc 205 206 #define sd_dump_format_string ssd_dump_format_string 207 208 #define sd_iostart_chain ssd_iostart_chain 209 #define sd_iodone_chain ssd_iodone_chain 210 211 #define sd_pm_idletime ssd_pm_idletime 212 213 #define sd_force_pm_supported ssd_force_pm_supported 214 215 #define sd_dtype_optical_bind ssd_dtype_optical_bind 216 217 #define sd_ssc_init ssd_ssc_init 218 #define sd_ssc_send ssd_ssc_send 219 #define sd_ssc_fini ssd_ssc_fini 220 #define sd_ssc_assessment ssd_ssc_assessment 221 #define sd_ssc_post ssd_ssc_post 222 #define sd_ssc_print ssd_ssc_print 223 #define sd_ssc_ereport_post ssd_ssc_ereport_post 224 #define sd_ssc_set_info ssd_ssc_set_info 225 #define sd_ssc_extract_info ssd_ssc_extract_info 226 227 #endif 228 229 #ifdef SDDEBUG 230 int sd_force_pm_supported = 0; 231 #endif /* SDDEBUG */ 232 233 void *sd_state = NULL; 234 int sd_io_time = SD_IO_TIME; 235 int sd_failfast_enable = 1; 236 int sd_ua_retry_count = SD_UA_RETRY_COUNT; 237 int sd_report_pfa = 1; 238 int sd_max_throttle = SD_MAX_THROTTLE; 239 int sd_min_throttle = SD_MIN_THROTTLE; 240 int sd_rot_delay = 4; /* Default 4ms Rotation delay */ 241 int sd_qfull_throttle_enable = TRUE; 242 243 int sd_retry_on_reservation_conflict = 1; 244 int sd_reinstate_resv_delay = SD_REINSTATE_RESV_DELAY; 245 _NOTE(SCHEME_PROTECTS_DATA("safe sharing", sd_reinstate_resv_delay)) 246 247 static int sd_dtype_optical_bind = -1; 248 249 /* Note: the following is not a bug, it really is "sd_" and not "ssd_" */ 250 static char *sd_resv_conflict_name = "sd_retry_on_reservation_conflict"; 251 252 /* 253 * Global data for debug logging. To enable debug printing, sd_component_mask 254 * and sd_level_mask should be set to the desired bit patterns as outlined in 255 * sddef.h. 256 */ 257 uint_t sd_component_mask = 0x0; 258 uint_t sd_level_mask = 0x0; 259 struct sd_lun *sd_debug_un = NULL; 260 uint_t sd_error_level = SCSI_ERR_RETRYABLE; 261 262 /* Note: these may go away in the future... */ 263 static uint32_t sd_xbuf_active_limit = 512; 264 static uint32_t sd_xbuf_reserve_limit = 16; 265 266 static struct sd_resv_reclaim_request sd_tr = { NULL, NULL, NULL, 0, 0, 0 }; 267 268 /* 269 * Timer value used to reset the throttle after it has been reduced 270 * (typically in response to TRAN_BUSY or STATUS_QFULL) 271 */ 272 static int sd_reset_throttle_timeout = SD_RESET_THROTTLE_TIMEOUT; 273 static int sd_qfull_throttle_timeout = SD_QFULL_THROTTLE_TIMEOUT; 274 275 /* 276 * Interval value associated with the media change scsi watch. 277 */ 278 static int sd_check_media_time = 3000000; 279 280 /* 281 * Wait value used for in progress operations during a DDI_SUSPEND 282 */ 283 static int sd_wait_cmds_complete = SD_WAIT_CMDS_COMPLETE; 284 285 /* 286 * sd_label_mutex protects a static buffer used in the disk label 287 * component of the driver 288 */ 289 static kmutex_t sd_label_mutex; 290 291 /* 292 * sd_detach_mutex protects un_layer_count, un_detach_count, and 293 * un_opens_in_progress in the sd_lun structure. 294 */ 295 static kmutex_t sd_detach_mutex; 296 297 _NOTE(MUTEX_PROTECTS_DATA(sd_detach_mutex, 298 sd_lun::{un_layer_count un_detach_count un_opens_in_progress})) 299 300 /* 301 * Global buffer and mutex for debug logging 302 */ 303 static char sd_log_buf[1024]; 304 static kmutex_t sd_log_mutex; 305 306 /* 307 * Structs and globals for recording attached lun information. 308 * This maintains a chain. Each node in the chain represents a SCSI controller. 309 * The structure records the number of luns attached to each target connected 310 * with the controller. 311 * For parallel scsi device only. 312 */ 313 struct sd_scsi_hba_tgt_lun { 314 struct sd_scsi_hba_tgt_lun *next; 315 dev_info_t *pdip; 316 int nlun[NTARGETS_WIDE]; 317 }; 318 319 /* 320 * Flag to indicate the lun is attached or detached 321 */ 322 #define SD_SCSI_LUN_ATTACH 0 323 #define SD_SCSI_LUN_DETACH 1 324 325 static kmutex_t sd_scsi_target_lun_mutex; 326 static struct sd_scsi_hba_tgt_lun *sd_scsi_target_lun_head = NULL; 327 328 _NOTE(MUTEX_PROTECTS_DATA(sd_scsi_target_lun_mutex, 329 sd_scsi_hba_tgt_lun::next sd_scsi_hba_tgt_lun::pdip)) 330 331 _NOTE(MUTEX_PROTECTS_DATA(sd_scsi_target_lun_mutex, 332 sd_scsi_target_lun_head)) 333 334 /* 335 * "Smart" Probe Caching structs, globals, #defines, etc. 336 * For parallel scsi and non-self-identify device only. 337 */ 338 339 /* 340 * The following resources and routines are implemented to support 341 * "smart" probing, which caches the scsi_probe() results in an array, 342 * in order to help avoid long probe times. 343 */ 344 struct sd_scsi_probe_cache { 345 struct sd_scsi_probe_cache *next; 346 dev_info_t *pdip; 347 int cache[NTARGETS_WIDE]; 348 }; 349 350 static kmutex_t sd_scsi_probe_cache_mutex; 351 static struct sd_scsi_probe_cache *sd_scsi_probe_cache_head = NULL; 352 353 /* 354 * Really we only need protection on the head of the linked list, but 355 * better safe than sorry. 356 */ 357 _NOTE(MUTEX_PROTECTS_DATA(sd_scsi_probe_cache_mutex, 358 sd_scsi_probe_cache::next sd_scsi_probe_cache::pdip)) 359 360 _NOTE(MUTEX_PROTECTS_DATA(sd_scsi_probe_cache_mutex, 361 sd_scsi_probe_cache_head)) 362 363 /* 364 * Power attribute table 365 */ 366 static sd_power_attr_ss sd_pwr_ss = { 367 { "NAME=spindle-motor", "0=off", "1=on", NULL }, 368 {0, 100}, 369 {30, 0}, 370 {20000, 0} 371 }; 372 373 static sd_power_attr_pc sd_pwr_pc = { 374 { "NAME=spindle-motor", "0=stopped", "1=standby", "2=idle", 375 "3=active", NULL }, 376 {0, 0, 0, 100}, 377 {90, 90, 20, 0}, 378 {15000, 15000, 1000, 0} 379 }; 380 381 /* 382 * Power level to power condition 383 */ 384 static int sd_pl2pc[] = { 385 SD_TARGET_START_VALID, 386 SD_TARGET_STANDBY, 387 SD_TARGET_IDLE, 388 SD_TARGET_ACTIVE 389 }; 390 391 /* 392 * Vendor specific data name property declarations 393 */ 394 395 #if defined(__fibre) || defined(__i386) ||defined(__amd64) 396 397 static sd_tunables seagate_properties = { 398 SEAGATE_THROTTLE_VALUE, 399 0, 400 0, 401 0, 402 0, 403 0, 404 0, 405 0, 406 0 407 }; 408 409 410 static sd_tunables fujitsu_properties = { 411 FUJITSU_THROTTLE_VALUE, 412 0, 413 0, 414 0, 415 0, 416 0, 417 0, 418 0, 419 0 420 }; 421 422 static sd_tunables ibm_properties = { 423 IBM_THROTTLE_VALUE, 424 0, 425 0, 426 0, 427 0, 428 0, 429 0, 430 0, 431 0 432 }; 433 434 static sd_tunables purple_properties = { 435 PURPLE_THROTTLE_VALUE, 436 0, 437 0, 438 PURPLE_BUSY_RETRIES, 439 PURPLE_RESET_RETRY_COUNT, 440 PURPLE_RESERVE_RELEASE_TIME, 441 0, 442 0, 443 0 444 }; 445 446 static sd_tunables sve_properties = { 447 SVE_THROTTLE_VALUE, 448 0, 449 0, 450 SVE_BUSY_RETRIES, 451 SVE_RESET_RETRY_COUNT, 452 SVE_RESERVE_RELEASE_TIME, 453 SVE_MIN_THROTTLE_VALUE, 454 SVE_DISKSORT_DISABLED_FLAG, 455 0 456 }; 457 458 static sd_tunables maserati_properties = { 459 0, 460 0, 461 0, 462 0, 463 0, 464 0, 465 0, 466 MASERATI_DISKSORT_DISABLED_FLAG, 467 MASERATI_LUN_RESET_ENABLED_FLAG 468 }; 469 470 static sd_tunables pirus_properties = { 471 PIRUS_THROTTLE_VALUE, 472 0, 473 PIRUS_NRR_COUNT, 474 PIRUS_BUSY_RETRIES, 475 PIRUS_RESET_RETRY_COUNT, 476 0, 477 PIRUS_MIN_THROTTLE_VALUE, 478 PIRUS_DISKSORT_DISABLED_FLAG, 479 PIRUS_LUN_RESET_ENABLED_FLAG 480 }; 481 482 #endif 483 484 #if (defined(__sparc) && !defined(__fibre)) || \ 485 (defined(__i386) || defined(__amd64)) 486 487 488 static sd_tunables elite_properties = { 489 ELITE_THROTTLE_VALUE, 490 0, 491 0, 492 0, 493 0, 494 0, 495 0, 496 0, 497 0 498 }; 499 500 static sd_tunables st31200n_properties = { 501 ST31200N_THROTTLE_VALUE, 502 0, 503 0, 504 0, 505 0, 506 0, 507 0, 508 0, 509 0 510 }; 511 512 #endif /* Fibre or not */ 513 514 static sd_tunables lsi_properties_scsi = { 515 LSI_THROTTLE_VALUE, 516 0, 517 LSI_NOTREADY_RETRIES, 518 0, 519 0, 520 0, 521 0, 522 0, 523 0 524 }; 525 526 static sd_tunables symbios_properties = { 527 SYMBIOS_THROTTLE_VALUE, 528 0, 529 SYMBIOS_NOTREADY_RETRIES, 530 0, 531 0, 532 0, 533 0, 534 0, 535 0 536 }; 537 538 static sd_tunables lsi_properties = { 539 0, 540 0, 541 LSI_NOTREADY_RETRIES, 542 0, 543 0, 544 0, 545 0, 546 0, 547 0 548 }; 549 550 static sd_tunables lsi_oem_properties = { 551 0, 552 0, 553 LSI_OEM_NOTREADY_RETRIES, 554 0, 555 0, 556 0, 557 0, 558 0, 559 0, 560 1 561 }; 562 563 564 565 #if (defined(SD_PROP_TST)) 566 567 #define SD_TST_CTYPE_VAL CTYPE_CDROM 568 #define SD_TST_THROTTLE_VAL 16 569 #define SD_TST_NOTREADY_VAL 12 570 #define SD_TST_BUSY_VAL 60 571 #define SD_TST_RST_RETRY_VAL 36 572 #define SD_TST_RSV_REL_TIME 60 573 574 static sd_tunables tst_properties = { 575 SD_TST_THROTTLE_VAL, 576 SD_TST_CTYPE_VAL, 577 SD_TST_NOTREADY_VAL, 578 SD_TST_BUSY_VAL, 579 SD_TST_RST_RETRY_VAL, 580 SD_TST_RSV_REL_TIME, 581 0, 582 0, 583 0 584 }; 585 #endif 586 587 /* This is similar to the ANSI toupper implementation */ 588 #define SD_TOUPPER(C) (((C) >= 'a' && (C) <= 'z') ? (C) - 'a' + 'A' : (C)) 589 590 /* 591 * Static Driver Configuration Table 592 * 593 * This is the table of disks which need throttle adjustment (or, perhaps 594 * something else as defined by the flags at a future time.) device_id 595 * is a string consisting of concatenated vid (vendor), pid (product/model) 596 * and revision strings as defined in the scsi_inquiry structure. Offsets of 597 * the parts of the string are as defined by the sizes in the scsi_inquiry 598 * structure. Device type is searched as far as the device_id string is 599 * defined. Flags defines which values are to be set in the driver from the 600 * properties list. 601 * 602 * Entries below which begin and end with a "*" are a special case. 603 * These do not have a specific vendor, and the string which follows 604 * can appear anywhere in the 16 byte PID portion of the inquiry data. 605 * 606 * Entries below which begin and end with a " " (blank) are a special 607 * case. The comparison function will treat multiple consecutive blanks 608 * as equivalent to a single blank. For example, this causes a 609 * sd_disk_table entry of " NEC CDROM " to match a device's id string 610 * of "NEC CDROM". 611 * 612 * Note: The MD21 controller type has been obsoleted. 613 * ST318202F is a Legacy device 614 * MAM3182FC, MAM3364FC, MAM3738FC do not appear to have ever been 615 * made with an FC connection. The entries here are a legacy. 616 */ 617 static sd_disk_config_t sd_disk_table[] = { 618 #if defined(__fibre) || defined(__i386) || defined(__amd64) 619 { "SEAGATE ST34371FC", SD_CONF_BSET_THROTTLE, &seagate_properties }, 620 { "SEAGATE ST19171FC", SD_CONF_BSET_THROTTLE, &seagate_properties }, 621 { "SEAGATE ST39102FC", SD_CONF_BSET_THROTTLE, &seagate_properties }, 622 { "SEAGATE ST39103FC", SD_CONF_BSET_THROTTLE, &seagate_properties }, 623 { "SEAGATE ST118273F", SD_CONF_BSET_THROTTLE, &seagate_properties }, 624 { "SEAGATE ST318202F", SD_CONF_BSET_THROTTLE, &seagate_properties }, 625 { "SEAGATE ST318203F", SD_CONF_BSET_THROTTLE, &seagate_properties }, 626 { "SEAGATE ST136403F", SD_CONF_BSET_THROTTLE, &seagate_properties }, 627 { "SEAGATE ST318304F", SD_CONF_BSET_THROTTLE, &seagate_properties }, 628 { "SEAGATE ST336704F", SD_CONF_BSET_THROTTLE, &seagate_properties }, 629 { "SEAGATE ST373405F", SD_CONF_BSET_THROTTLE, &seagate_properties }, 630 { "SEAGATE ST336605F", SD_CONF_BSET_THROTTLE, &seagate_properties }, 631 { "SEAGATE ST336752F", SD_CONF_BSET_THROTTLE, &seagate_properties }, 632 { "SEAGATE ST318452F", SD_CONF_BSET_THROTTLE, &seagate_properties }, 633 { "FUJITSU MAG3091F", SD_CONF_BSET_THROTTLE, &fujitsu_properties }, 634 { "FUJITSU MAG3182F", SD_CONF_BSET_THROTTLE, &fujitsu_properties }, 635 { "FUJITSU MAA3182F", SD_CONF_BSET_THROTTLE, &fujitsu_properties }, 636 { "FUJITSU MAF3364F", SD_CONF_BSET_THROTTLE, &fujitsu_properties }, 637 { "FUJITSU MAL3364F", SD_CONF_BSET_THROTTLE, &fujitsu_properties }, 638 { "FUJITSU MAL3738F", SD_CONF_BSET_THROTTLE, &fujitsu_properties }, 639 { "FUJITSU MAM3182FC", SD_CONF_BSET_THROTTLE, &fujitsu_properties }, 640 { "FUJITSU MAM3364FC", SD_CONF_BSET_THROTTLE, &fujitsu_properties }, 641 { "FUJITSU MAM3738FC", SD_CONF_BSET_THROTTLE, &fujitsu_properties }, 642 { "IBM DDYFT1835", SD_CONF_BSET_THROTTLE, &ibm_properties }, 643 { "IBM DDYFT3695", SD_CONF_BSET_THROTTLE, &ibm_properties }, 644 { "IBM IC35LF2D2", SD_CONF_BSET_THROTTLE, &ibm_properties }, 645 { "IBM IC35LF2PR", SD_CONF_BSET_THROTTLE, &ibm_properties }, 646 { "IBM 1724-100", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 647 { "IBM 1726-2xx", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 648 { "IBM 1726-22x", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 649 { "IBM 1726-4xx", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 650 { "IBM 1726-42x", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 651 { "IBM 1726-3xx", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 652 { "IBM 3526", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 653 { "IBM 3542", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 654 { "IBM 3552", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 655 { "IBM 1722", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 656 { "IBM 1742", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 657 { "IBM 1815", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 658 { "IBM FAStT", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 659 { "IBM 1814", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 660 { "IBM 1814-200", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 661 { "IBM 1818", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 662 { "DELL MD3000", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 663 { "DELL MD3000i", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 664 { "LSI INF", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 665 { "ENGENIO INF", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 666 { "SGI TP", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 667 { "SGI IS", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 668 { "*CSM100_*", SD_CONF_BSET_NRR_COUNT | 669 SD_CONF_BSET_CACHE_IS_NV, &lsi_oem_properties }, 670 { "*CSM200_*", SD_CONF_BSET_NRR_COUNT | 671 SD_CONF_BSET_CACHE_IS_NV, &lsi_oem_properties }, 672 { "Fujitsu SX300", SD_CONF_BSET_THROTTLE, &lsi_oem_properties }, 673 { "LSI", SD_CONF_BSET_NRR_COUNT, &lsi_properties }, 674 { "SUN T3", SD_CONF_BSET_THROTTLE | 675 SD_CONF_BSET_BSY_RETRY_COUNT| 676 SD_CONF_BSET_RST_RETRIES| 677 SD_CONF_BSET_RSV_REL_TIME, 678 &purple_properties }, 679 { "SUN SESS01", SD_CONF_BSET_THROTTLE | 680 SD_CONF_BSET_BSY_RETRY_COUNT| 681 SD_CONF_BSET_RST_RETRIES| 682 SD_CONF_BSET_RSV_REL_TIME| 683 SD_CONF_BSET_MIN_THROTTLE| 684 SD_CONF_BSET_DISKSORT_DISABLED, 685 &sve_properties }, 686 { "SUN T4", SD_CONF_BSET_THROTTLE | 687 SD_CONF_BSET_BSY_RETRY_COUNT| 688 SD_CONF_BSET_RST_RETRIES| 689 SD_CONF_BSET_RSV_REL_TIME, 690 &purple_properties }, 691 { "SUN SVE01", SD_CONF_BSET_DISKSORT_DISABLED | 692 SD_CONF_BSET_LUN_RESET_ENABLED, 693 &maserati_properties }, 694 { "SUN SE6920", SD_CONF_BSET_THROTTLE | 695 SD_CONF_BSET_NRR_COUNT| 696 SD_CONF_BSET_BSY_RETRY_COUNT| 697 SD_CONF_BSET_RST_RETRIES| 698 SD_CONF_BSET_MIN_THROTTLE| 699 SD_CONF_BSET_DISKSORT_DISABLED| 700 SD_CONF_BSET_LUN_RESET_ENABLED, 701 &pirus_properties }, 702 { "SUN SE6940", SD_CONF_BSET_THROTTLE | 703 SD_CONF_BSET_NRR_COUNT| 704 SD_CONF_BSET_BSY_RETRY_COUNT| 705 SD_CONF_BSET_RST_RETRIES| 706 SD_CONF_BSET_MIN_THROTTLE| 707 SD_CONF_BSET_DISKSORT_DISABLED| 708 SD_CONF_BSET_LUN_RESET_ENABLED, 709 &pirus_properties }, 710 { "SUN StorageTek 6920", SD_CONF_BSET_THROTTLE | 711 SD_CONF_BSET_NRR_COUNT| 712 SD_CONF_BSET_BSY_RETRY_COUNT| 713 SD_CONF_BSET_RST_RETRIES| 714 SD_CONF_BSET_MIN_THROTTLE| 715 SD_CONF_BSET_DISKSORT_DISABLED| 716 SD_CONF_BSET_LUN_RESET_ENABLED, 717 &pirus_properties }, 718 { "SUN StorageTek 6940", SD_CONF_BSET_THROTTLE | 719 SD_CONF_BSET_NRR_COUNT| 720 SD_CONF_BSET_BSY_RETRY_COUNT| 721 SD_CONF_BSET_RST_RETRIES| 722 SD_CONF_BSET_MIN_THROTTLE| 723 SD_CONF_BSET_DISKSORT_DISABLED| 724 SD_CONF_BSET_LUN_RESET_ENABLED, 725 &pirus_properties }, 726 { "SUN PSX1000", SD_CONF_BSET_THROTTLE | 727 SD_CONF_BSET_NRR_COUNT| 728 SD_CONF_BSET_BSY_RETRY_COUNT| 729 SD_CONF_BSET_RST_RETRIES| 730 SD_CONF_BSET_MIN_THROTTLE| 731 SD_CONF_BSET_DISKSORT_DISABLED| 732 SD_CONF_BSET_LUN_RESET_ENABLED, 733 &pirus_properties }, 734 { "SUN SE6330", SD_CONF_BSET_THROTTLE | 735 SD_CONF_BSET_NRR_COUNT| 736 SD_CONF_BSET_BSY_RETRY_COUNT| 737 SD_CONF_BSET_RST_RETRIES| 738 SD_CONF_BSET_MIN_THROTTLE| 739 SD_CONF_BSET_DISKSORT_DISABLED| 740 SD_CONF_BSET_LUN_RESET_ENABLED, 741 &pirus_properties }, 742 { "SUN STK6580_6780", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 743 { "SUN SUN_6180", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 744 { "STK OPENstorage", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 745 { "STK OpenStorage", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 746 { "STK BladeCtlr", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 747 { "STK FLEXLINE", SD_CONF_BSET_NRR_COUNT, &lsi_oem_properties }, 748 { "SYMBIOS", SD_CONF_BSET_NRR_COUNT, &symbios_properties }, 749 #endif /* fibre or NON-sparc platforms */ 750 #if ((defined(__sparc) && !defined(__fibre)) ||\ 751 (defined(__i386) || defined(__amd64))) 752 { "SEAGATE ST42400N", SD_CONF_BSET_THROTTLE, &elite_properties }, 753 { "SEAGATE ST31200N", SD_CONF_BSET_THROTTLE, &st31200n_properties }, 754 { "SEAGATE ST41600N", SD_CONF_BSET_TUR_CHECK, NULL }, 755 { "CONNER CP30540", SD_CONF_BSET_NOCACHE, NULL }, 756 { "*SUN0104*", SD_CONF_BSET_FAB_DEVID, NULL }, 757 { "*SUN0207*", SD_CONF_BSET_FAB_DEVID, NULL }, 758 { "*SUN0327*", SD_CONF_BSET_FAB_DEVID, NULL }, 759 { "*SUN0340*", SD_CONF_BSET_FAB_DEVID, NULL }, 760 { "*SUN0424*", SD_CONF_BSET_FAB_DEVID, NULL }, 761 { "*SUN0669*", SD_CONF_BSET_FAB_DEVID, NULL }, 762 { "*SUN1.0G*", SD_CONF_BSET_FAB_DEVID, NULL }, 763 { "SYMBIOS INF-01-00 ", SD_CONF_BSET_FAB_DEVID, NULL }, 764 { "SYMBIOS", SD_CONF_BSET_THROTTLE|SD_CONF_BSET_NRR_COUNT, 765 &symbios_properties }, 766 { "LSI", SD_CONF_BSET_THROTTLE | SD_CONF_BSET_NRR_COUNT, 767 &lsi_properties_scsi }, 768 #if defined(__i386) || defined(__amd64) 769 { " NEC CD-ROM DRIVE:260 ", (SD_CONF_BSET_PLAYMSF_BCD 770 | SD_CONF_BSET_READSUB_BCD 771 | SD_CONF_BSET_READ_TOC_ADDR_BCD 772 | SD_CONF_BSET_NO_READ_HEADER 773 | SD_CONF_BSET_READ_CD_XD4), NULL }, 774 775 { " NEC CD-ROM DRIVE:270 ", (SD_CONF_BSET_PLAYMSF_BCD 776 | SD_CONF_BSET_READSUB_BCD 777 | SD_CONF_BSET_READ_TOC_ADDR_BCD 778 | SD_CONF_BSET_NO_READ_HEADER 779 | SD_CONF_BSET_READ_CD_XD4), NULL }, 780 #endif /* __i386 || __amd64 */ 781 #endif /* sparc NON-fibre or NON-sparc platforms */ 782 783 #if (defined(SD_PROP_TST)) 784 { "VENDOR PRODUCT ", (SD_CONF_BSET_THROTTLE 785 | SD_CONF_BSET_CTYPE 786 | SD_CONF_BSET_NRR_COUNT 787 | SD_CONF_BSET_FAB_DEVID 788 | SD_CONF_BSET_NOCACHE 789 | SD_CONF_BSET_BSY_RETRY_COUNT 790 | SD_CONF_BSET_PLAYMSF_BCD 791 | SD_CONF_BSET_READSUB_BCD 792 | SD_CONF_BSET_READ_TOC_TRK_BCD 793 | SD_CONF_BSET_READ_TOC_ADDR_BCD 794 | SD_CONF_BSET_NO_READ_HEADER 795 | SD_CONF_BSET_READ_CD_XD4 796 | SD_CONF_BSET_RST_RETRIES 797 | SD_CONF_BSET_RSV_REL_TIME 798 | SD_CONF_BSET_TUR_CHECK), &tst_properties}, 799 #endif 800 }; 801 802 static const int sd_disk_table_size = 803 sizeof (sd_disk_table)/ sizeof (sd_disk_config_t); 804 805 /* 806 * Emulation mode disk drive VID/PID table 807 */ 808 static char sd_flash_dev_table[][25] = { 809 "ATA MARVELL SD88SA02", 810 "MARVELL SD88SA02", 811 "TOSHIBA THNSNV05", 812 }; 813 814 static const int sd_flash_dev_table_size = 815 sizeof (sd_flash_dev_table) / sizeof (sd_flash_dev_table[0]); 816 817 #define SD_INTERCONNECT_PARALLEL 0 818 #define SD_INTERCONNECT_FABRIC 1 819 #define SD_INTERCONNECT_FIBRE 2 820 #define SD_INTERCONNECT_SSA 3 821 #define SD_INTERCONNECT_SATA 4 822 #define SD_INTERCONNECT_SAS 5 823 824 #define SD_IS_PARALLEL_SCSI(un) \ 825 ((un)->un_interconnect_type == SD_INTERCONNECT_PARALLEL) 826 #define SD_IS_SERIAL(un) \ 827 (((un)->un_interconnect_type == SD_INTERCONNECT_SATA) ||\ 828 ((un)->un_interconnect_type == SD_INTERCONNECT_SAS)) 829 830 /* 831 * Definitions used by device id registration routines 832 */ 833 #define VPD_HEAD_OFFSET 3 /* size of head for vpd page */ 834 #define VPD_PAGE_LENGTH 3 /* offset for pge length data */ 835 #define VPD_MODE_PAGE 1 /* offset into vpd pg for "page code" */ 836 837 static kmutex_t sd_sense_mutex = {0}; 838 839 /* 840 * Macros for updates of the driver state 841 */ 842 #define New_state(un, s) \ 843 (un)->un_last_state = (un)->un_state, (un)->un_state = (s) 844 #define Restore_state(un) \ 845 { uchar_t tmp = (un)->un_last_state; New_state((un), tmp); } 846 847 static struct sd_cdbinfo sd_cdbtab[] = { 848 { CDB_GROUP0, 0x00, 0x1FFFFF, 0xFF, }, 849 { CDB_GROUP1, SCMD_GROUP1, 0xFFFFFFFF, 0xFFFF, }, 850 { CDB_GROUP5, SCMD_GROUP5, 0xFFFFFFFF, 0xFFFFFFFF, }, 851 { CDB_GROUP4, SCMD_GROUP4, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFF, }, 852 }; 853 854 /* 855 * Specifies the number of seconds that must have elapsed since the last 856 * cmd. has completed for a device to be declared idle to the PM framework. 857 */ 858 static int sd_pm_idletime = 1; 859 860 /* 861 * Internal function prototypes 862 */ 863 864 #if (defined(__fibre)) 865 /* 866 * These #defines are to avoid namespace collisions that occur because this 867 * code is currently used to compile two separate driver modules: sd and ssd. 868 * All function names need to be treated this way (even if declared static) 869 * in order to allow the debugger to resolve the names properly. 870 * It is anticipated that in the near future the ssd module will be obsoleted, 871 * at which time this ugliness should go away. 872 */ 873 #define sd_log_trace ssd_log_trace 874 #define sd_log_info ssd_log_info 875 #define sd_log_err ssd_log_err 876 #define sdprobe ssdprobe 877 #define sdinfo ssdinfo 878 #define sd_prop_op ssd_prop_op 879 #define sd_scsi_probe_cache_init ssd_scsi_probe_cache_init 880 #define sd_scsi_probe_cache_fini ssd_scsi_probe_cache_fini 881 #define sd_scsi_clear_probe_cache ssd_scsi_clear_probe_cache 882 #define sd_scsi_probe_with_cache ssd_scsi_probe_with_cache 883 #define sd_scsi_target_lun_init ssd_scsi_target_lun_init 884 #define sd_scsi_target_lun_fini ssd_scsi_target_lun_fini 885 #define sd_scsi_get_target_lun_count ssd_scsi_get_target_lun_count 886 #define sd_scsi_update_lun_on_target ssd_scsi_update_lun_on_target 887 #define sd_spin_up_unit ssd_spin_up_unit 888 #define sd_enable_descr_sense ssd_enable_descr_sense 889 #define sd_reenable_dsense_task ssd_reenable_dsense_task 890 #define sd_set_mmc_caps ssd_set_mmc_caps 891 #define sd_read_unit_properties ssd_read_unit_properties 892 #define sd_process_sdconf_file ssd_process_sdconf_file 893 #define sd_process_sdconf_table ssd_process_sdconf_table 894 #define sd_sdconf_id_match ssd_sdconf_id_match 895 #define sd_blank_cmp ssd_blank_cmp 896 #define sd_chk_vers1_data ssd_chk_vers1_data 897 #define sd_set_vers1_properties ssd_set_vers1_properties 898 #define sd_check_solid_state ssd_check_solid_state 899 #define sd_check_emulation_mode ssd_check_emulation_mode 900 901 #define sd_get_physical_geometry ssd_get_physical_geometry 902 #define sd_get_virtual_geometry ssd_get_virtual_geometry 903 #define sd_update_block_info ssd_update_block_info 904 #define sd_register_devid ssd_register_devid 905 #define sd_get_devid ssd_get_devid 906 #define sd_create_devid ssd_create_devid 907 #define sd_write_deviceid ssd_write_deviceid 908 #define sd_check_vpd_page_support ssd_check_vpd_page_support 909 #define sd_setup_pm ssd_setup_pm 910 #define sd_create_pm_components ssd_create_pm_components 911 #define sd_ddi_suspend ssd_ddi_suspend 912 #define sd_ddi_resume ssd_ddi_resume 913 #define sd_pm_state_change ssd_pm_state_change 914 #define sdpower ssdpower 915 #define sdattach ssdattach 916 #define sddetach ssddetach 917 #define sd_unit_attach ssd_unit_attach 918 #define sd_unit_detach ssd_unit_detach 919 #define sd_set_unit_attributes ssd_set_unit_attributes 920 #define sd_create_errstats ssd_create_errstats 921 #define sd_set_errstats ssd_set_errstats 922 #define sd_set_pstats ssd_set_pstats 923 #define sddump ssddump 924 #define sd_scsi_poll ssd_scsi_poll 925 #define sd_send_polled_RQS ssd_send_polled_RQS 926 #define sd_ddi_scsi_poll ssd_ddi_scsi_poll 927 #define sd_init_event_callbacks ssd_init_event_callbacks 928 #define sd_event_callback ssd_event_callback 929 #define sd_cache_control ssd_cache_control 930 #define sd_get_write_cache_enabled ssd_get_write_cache_enabled 931 #define sd_get_nv_sup ssd_get_nv_sup 932 #define sd_make_device ssd_make_device 933 #define sdopen ssdopen 934 #define sdclose ssdclose 935 #define sd_ready_and_valid ssd_ready_and_valid 936 #define sdmin ssdmin 937 #define sdread ssdread 938 #define sdwrite ssdwrite 939 #define sdaread ssdaread 940 #define sdawrite ssdawrite 941 #define sdstrategy ssdstrategy 942 #define sdioctl ssdioctl 943 #define sd_mapblockaddr_iostart ssd_mapblockaddr_iostart 944 #define sd_mapblocksize_iostart ssd_mapblocksize_iostart 945 #define sd_checksum_iostart ssd_checksum_iostart 946 #define sd_checksum_uscsi_iostart ssd_checksum_uscsi_iostart 947 #define sd_pm_iostart ssd_pm_iostart 948 #define sd_core_iostart ssd_core_iostart 949 #define sd_mapblockaddr_iodone ssd_mapblockaddr_iodone 950 #define sd_mapblocksize_iodone ssd_mapblocksize_iodone 951 #define sd_checksum_iodone ssd_checksum_iodone 952 #define sd_checksum_uscsi_iodone ssd_checksum_uscsi_iodone 953 #define sd_pm_iodone ssd_pm_iodone 954 #define sd_initpkt_for_buf ssd_initpkt_for_buf 955 #define sd_destroypkt_for_buf ssd_destroypkt_for_buf 956 #define sd_setup_rw_pkt ssd_setup_rw_pkt 957 #define sd_setup_next_rw_pkt ssd_setup_next_rw_pkt 958 #define sd_buf_iodone ssd_buf_iodone 959 #define sd_uscsi_strategy ssd_uscsi_strategy 960 #define sd_initpkt_for_uscsi ssd_initpkt_for_uscsi 961 #define sd_destroypkt_for_uscsi ssd_destroypkt_for_uscsi 962 #define sd_uscsi_iodone ssd_uscsi_iodone 963 #define sd_xbuf_strategy ssd_xbuf_strategy 964 #define sd_xbuf_init ssd_xbuf_init 965 #define sd_pm_entry ssd_pm_entry 966 #define sd_pm_exit ssd_pm_exit 967 968 #define sd_pm_idletimeout_handler ssd_pm_idletimeout_handler 969 #define sd_pm_timeout_handler ssd_pm_timeout_handler 970 971 #define sd_add_buf_to_waitq ssd_add_buf_to_waitq 972 #define sdintr ssdintr 973 #define sd_start_cmds ssd_start_cmds 974 #define sd_send_scsi_cmd ssd_send_scsi_cmd 975 #define sd_bioclone_alloc ssd_bioclone_alloc 976 #define sd_bioclone_free ssd_bioclone_free 977 #define sd_shadow_buf_alloc ssd_shadow_buf_alloc 978 #define sd_shadow_buf_free ssd_shadow_buf_free 979 #define sd_print_transport_rejected_message \ 980 ssd_print_transport_rejected_message 981 #define sd_retry_command ssd_retry_command 982 #define sd_set_retry_bp ssd_set_retry_bp 983 #define sd_send_request_sense_command ssd_send_request_sense_command 984 #define sd_start_retry_command ssd_start_retry_command 985 #define sd_start_direct_priority_command \ 986 ssd_start_direct_priority_command 987 #define sd_return_failed_command ssd_return_failed_command 988 #define sd_return_failed_command_no_restart \ 989 ssd_return_failed_command_no_restart 990 #define sd_return_command ssd_return_command 991 #define sd_sync_with_callback ssd_sync_with_callback 992 #define sdrunout ssdrunout 993 #define sd_mark_rqs_busy ssd_mark_rqs_busy 994 #define sd_mark_rqs_idle ssd_mark_rqs_idle 995 #define sd_reduce_throttle ssd_reduce_throttle 996 #define sd_restore_throttle ssd_restore_throttle 997 #define sd_print_incomplete_msg ssd_print_incomplete_msg 998 #define sd_init_cdb_limits ssd_init_cdb_limits 999 #define sd_pkt_status_good ssd_pkt_status_good 1000 #define sd_pkt_status_check_condition ssd_pkt_status_check_condition 1001 #define sd_pkt_status_busy ssd_pkt_status_busy 1002 #define sd_pkt_status_reservation_conflict \ 1003 ssd_pkt_status_reservation_conflict 1004 #define sd_pkt_status_qfull ssd_pkt_status_qfull 1005 #define sd_handle_request_sense ssd_handle_request_sense 1006 #define sd_handle_auto_request_sense ssd_handle_auto_request_sense 1007 #define sd_print_sense_failed_msg ssd_print_sense_failed_msg 1008 #define sd_validate_sense_data ssd_validate_sense_data 1009 #define sd_decode_sense ssd_decode_sense 1010 #define sd_print_sense_msg ssd_print_sense_msg 1011 #define sd_sense_key_no_sense ssd_sense_key_no_sense 1012 #define sd_sense_key_recoverable_error ssd_sense_key_recoverable_error 1013 #define sd_sense_key_not_ready ssd_sense_key_not_ready 1014 #define sd_sense_key_medium_or_hardware_error \ 1015 ssd_sense_key_medium_or_hardware_error 1016 #define sd_sense_key_illegal_request ssd_sense_key_illegal_request 1017 #define sd_sense_key_unit_attention ssd_sense_key_unit_attention 1018 #define sd_sense_key_fail_command ssd_sense_key_fail_command 1019 #define sd_sense_key_blank_check ssd_sense_key_blank_check 1020 #define sd_sense_key_aborted_command ssd_sense_key_aborted_command 1021 #define sd_sense_key_default ssd_sense_key_default 1022 #define sd_print_retry_msg ssd_print_retry_msg 1023 #define sd_print_cmd_incomplete_msg ssd_print_cmd_incomplete_msg 1024 #define sd_pkt_reason_cmd_incomplete ssd_pkt_reason_cmd_incomplete 1025 #define sd_pkt_reason_cmd_tran_err ssd_pkt_reason_cmd_tran_err 1026 #define sd_pkt_reason_cmd_reset ssd_pkt_reason_cmd_reset 1027 #define sd_pkt_reason_cmd_aborted ssd_pkt_reason_cmd_aborted 1028 #define sd_pkt_reason_cmd_timeout ssd_pkt_reason_cmd_timeout 1029 #define sd_pkt_reason_cmd_unx_bus_free ssd_pkt_reason_cmd_unx_bus_free 1030 #define sd_pkt_reason_cmd_tag_reject ssd_pkt_reason_cmd_tag_reject 1031 #define sd_pkt_reason_default ssd_pkt_reason_default 1032 #define sd_reset_target ssd_reset_target 1033 #define sd_start_stop_unit_callback ssd_start_stop_unit_callback 1034 #define sd_start_stop_unit_task ssd_start_stop_unit_task 1035 #define sd_taskq_create ssd_taskq_create 1036 #define sd_taskq_delete ssd_taskq_delete 1037 #define sd_target_change_task ssd_target_change_task 1038 #define sd_log_dev_status_event ssd_log_dev_status_event 1039 #define sd_log_lun_expansion_event ssd_log_lun_expansion_event 1040 #define sd_log_eject_request_event ssd_log_eject_request_event 1041 #define sd_media_change_task ssd_media_change_task 1042 #define sd_handle_mchange ssd_handle_mchange 1043 #define sd_send_scsi_DOORLOCK ssd_send_scsi_DOORLOCK 1044 #define sd_send_scsi_READ_CAPACITY ssd_send_scsi_READ_CAPACITY 1045 #define sd_send_scsi_READ_CAPACITY_16 ssd_send_scsi_READ_CAPACITY_16 1046 #define sd_send_scsi_GET_CONFIGURATION ssd_send_scsi_GET_CONFIGURATION 1047 #define sd_send_scsi_feature_GET_CONFIGURATION \ 1048 sd_send_scsi_feature_GET_CONFIGURATION 1049 #define sd_send_scsi_START_STOP_UNIT ssd_send_scsi_START_STOP_UNIT 1050 #define sd_send_scsi_INQUIRY ssd_send_scsi_INQUIRY 1051 #define sd_send_scsi_TEST_UNIT_READY ssd_send_scsi_TEST_UNIT_READY 1052 #define sd_send_scsi_PERSISTENT_RESERVE_IN \ 1053 ssd_send_scsi_PERSISTENT_RESERVE_IN 1054 #define sd_send_scsi_PERSISTENT_RESERVE_OUT \ 1055 ssd_send_scsi_PERSISTENT_RESERVE_OUT 1056 #define sd_send_scsi_SYNCHRONIZE_CACHE ssd_send_scsi_SYNCHRONIZE_CACHE 1057 #define sd_send_scsi_SYNCHRONIZE_CACHE_biodone \ 1058 ssd_send_scsi_SYNCHRONIZE_CACHE_biodone 1059 #define sd_send_scsi_MODE_SENSE ssd_send_scsi_MODE_SENSE 1060 #define sd_send_scsi_MODE_SELECT ssd_send_scsi_MODE_SELECT 1061 #define sd_send_scsi_RDWR ssd_send_scsi_RDWR 1062 #define sd_send_scsi_LOG_SENSE ssd_send_scsi_LOG_SENSE 1063 #define sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION \ 1064 ssd_send_scsi_GET_EVENT_STATUS_NOTIFICATION 1065 #define sd_gesn_media_data_valid ssd_gesn_media_data_valid 1066 #define sd_alloc_rqs ssd_alloc_rqs 1067 #define sd_free_rqs ssd_free_rqs 1068 #define sd_dump_memory ssd_dump_memory 1069 #define sd_get_media_info_com ssd_get_media_info_com 1070 #define sd_get_media_info ssd_get_media_info 1071 #define sd_get_media_info_ext ssd_get_media_info_ext 1072 #define sd_dkio_ctrl_info ssd_dkio_ctrl_info 1073 #define sd_nvpair_str_decode ssd_nvpair_str_decode 1074 #define sd_strtok_r ssd_strtok_r 1075 #define sd_set_properties ssd_set_properties 1076 #define sd_get_tunables_from_conf ssd_get_tunables_from_conf 1077 #define sd_setup_next_xfer ssd_setup_next_xfer 1078 #define sd_dkio_get_temp ssd_dkio_get_temp 1079 #define sd_check_mhd ssd_check_mhd 1080 #define sd_mhd_watch_cb ssd_mhd_watch_cb 1081 #define sd_mhd_watch_incomplete ssd_mhd_watch_incomplete 1082 #define sd_sname ssd_sname 1083 #define sd_mhd_resvd_recover ssd_mhd_resvd_recover 1084 #define sd_resv_reclaim_thread ssd_resv_reclaim_thread 1085 #define sd_take_ownership ssd_take_ownership 1086 #define sd_reserve_release ssd_reserve_release 1087 #define sd_rmv_resv_reclaim_req ssd_rmv_resv_reclaim_req 1088 #define sd_mhd_reset_notify_cb ssd_mhd_reset_notify_cb 1089 #define sd_persistent_reservation_in_read_keys \ 1090 ssd_persistent_reservation_in_read_keys 1091 #define sd_persistent_reservation_in_read_resv \ 1092 ssd_persistent_reservation_in_read_resv 1093 #define sd_mhdioc_takeown ssd_mhdioc_takeown 1094 #define sd_mhdioc_failfast ssd_mhdioc_failfast 1095 #define sd_mhdioc_release ssd_mhdioc_release 1096 #define sd_mhdioc_register_devid ssd_mhdioc_register_devid 1097 #define sd_mhdioc_inkeys ssd_mhdioc_inkeys 1098 #define sd_mhdioc_inresv ssd_mhdioc_inresv 1099 #define sr_change_blkmode ssr_change_blkmode 1100 #define sr_change_speed ssr_change_speed 1101 #define sr_atapi_change_speed ssr_atapi_change_speed 1102 #define sr_pause_resume ssr_pause_resume 1103 #define sr_play_msf ssr_play_msf 1104 #define sr_play_trkind ssr_play_trkind 1105 #define sr_read_all_subcodes ssr_read_all_subcodes 1106 #define sr_read_subchannel ssr_read_subchannel 1107 #define sr_read_tocentry ssr_read_tocentry 1108 #define sr_read_tochdr ssr_read_tochdr 1109 #define sr_read_cdda ssr_read_cdda 1110 #define sr_read_cdxa ssr_read_cdxa 1111 #define sr_read_mode1 ssr_read_mode1 1112 #define sr_read_mode2 ssr_read_mode2 1113 #define sr_read_cd_mode2 ssr_read_cd_mode2 1114 #define sr_sector_mode ssr_sector_mode 1115 #define sr_eject ssr_eject 1116 #define sr_ejected ssr_ejected 1117 #define sr_check_wp ssr_check_wp 1118 #define sd_watch_request_submit ssd_watch_request_submit 1119 #define sd_check_media ssd_check_media 1120 #define sd_media_watch_cb ssd_media_watch_cb 1121 #define sd_delayed_cv_broadcast ssd_delayed_cv_broadcast 1122 #define sr_volume_ctrl ssr_volume_ctrl 1123 #define sr_read_sony_session_offset ssr_read_sony_session_offset 1124 #define sd_log_page_supported ssd_log_page_supported 1125 #define sd_check_for_writable_cd ssd_check_for_writable_cd 1126 #define sd_wm_cache_constructor ssd_wm_cache_constructor 1127 #define sd_wm_cache_destructor ssd_wm_cache_destructor 1128 #define sd_range_lock ssd_range_lock 1129 #define sd_get_range ssd_get_range 1130 #define sd_free_inlist_wmap ssd_free_inlist_wmap 1131 #define sd_range_unlock ssd_range_unlock 1132 #define sd_read_modify_write_task ssd_read_modify_write_task 1133 #define sddump_do_read_of_rmw ssddump_do_read_of_rmw 1134 1135 #define sd_iostart_chain ssd_iostart_chain 1136 #define sd_iodone_chain ssd_iodone_chain 1137 #define sd_initpkt_map ssd_initpkt_map 1138 #define sd_destroypkt_map ssd_destroypkt_map 1139 #define sd_chain_type_map ssd_chain_type_map 1140 #define sd_chain_index_map ssd_chain_index_map 1141 1142 #define sd_failfast_flushctl ssd_failfast_flushctl 1143 #define sd_failfast_flushq ssd_failfast_flushq 1144 #define sd_failfast_flushq_callback ssd_failfast_flushq_callback 1145 1146 #define sd_is_lsi ssd_is_lsi 1147 #define sd_tg_rdwr ssd_tg_rdwr 1148 #define sd_tg_getinfo ssd_tg_getinfo 1149 #define sd_rmw_msg_print_handler ssd_rmw_msg_print_handler 1150 1151 #endif /* #if (defined(__fibre)) */ 1152 1153 1154 int _init(void); 1155 int _fini(void); 1156 int _info(struct modinfo *modinfop); 1157 1158 /*PRINTFLIKE3*/ 1159 static void sd_log_trace(uint_t comp, struct sd_lun *un, const char *fmt, ...); 1160 /*PRINTFLIKE3*/ 1161 static void sd_log_info(uint_t comp, struct sd_lun *un, const char *fmt, ...); 1162 /*PRINTFLIKE3*/ 1163 static void sd_log_err(uint_t comp, struct sd_lun *un, const char *fmt, ...); 1164 1165 static int sdprobe(dev_info_t *devi); 1166 static int sdinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 1167 void **result); 1168 static int sd_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, 1169 int mod_flags, char *name, caddr_t valuep, int *lengthp); 1170 1171 /* 1172 * Smart probe for parallel scsi 1173 */ 1174 static void sd_scsi_probe_cache_init(void); 1175 static void sd_scsi_probe_cache_fini(void); 1176 static void sd_scsi_clear_probe_cache(void); 1177 static int sd_scsi_probe_with_cache(struct scsi_device *devp, int (*fn)()); 1178 1179 /* 1180 * Attached luns on target for parallel scsi 1181 */ 1182 static void sd_scsi_target_lun_init(void); 1183 static void sd_scsi_target_lun_fini(void); 1184 static int sd_scsi_get_target_lun_count(dev_info_t *dip, int target); 1185 static void sd_scsi_update_lun_on_target(dev_info_t *dip, int target, int flag); 1186 1187 static int sd_spin_up_unit(sd_ssc_t *ssc); 1188 1189 /* 1190 * Using sd_ssc_init to establish sd_ssc_t struct 1191 * Using sd_ssc_send to send uscsi internal command 1192 * Using sd_ssc_fini to free sd_ssc_t struct 1193 */ 1194 static sd_ssc_t *sd_ssc_init(struct sd_lun *un); 1195 static int sd_ssc_send(sd_ssc_t *ssc, struct uscsi_cmd *incmd, 1196 int flag, enum uio_seg dataspace, int path_flag); 1197 static void sd_ssc_fini(sd_ssc_t *ssc); 1198 1199 /* 1200 * Using sd_ssc_assessment to set correct type-of-assessment 1201 * Using sd_ssc_post to post ereport & system log 1202 * sd_ssc_post will call sd_ssc_print to print system log 1203 * sd_ssc_post will call sd_ssd_ereport_post to post ereport 1204 */ 1205 static void sd_ssc_assessment(sd_ssc_t *ssc, 1206 enum sd_type_assessment tp_assess); 1207 1208 static void sd_ssc_post(sd_ssc_t *ssc, enum sd_driver_assessment sd_assess); 1209 static void sd_ssc_print(sd_ssc_t *ssc, int sd_severity); 1210 static void sd_ssc_ereport_post(sd_ssc_t *ssc, 1211 enum sd_driver_assessment drv_assess); 1212 1213 /* 1214 * Using sd_ssc_set_info to mark an un-decodable-data error. 1215 * Using sd_ssc_extract_info to transfer information from internal 1216 * data structures to sd_ssc_t. 1217 */ 1218 static void sd_ssc_set_info(sd_ssc_t *ssc, int ssc_flags, uint_t comp, 1219 const char *fmt, ...); 1220 static void sd_ssc_extract_info(sd_ssc_t *ssc, struct sd_lun *un, 1221 struct scsi_pkt *pktp, struct buf *bp, struct sd_xbuf *xp); 1222 1223 static int sd_send_scsi_cmd(dev_t dev, struct uscsi_cmd *incmd, int flag, 1224 enum uio_seg dataspace, int path_flag); 1225 1226 #ifdef _LP64 1227 static void sd_enable_descr_sense(sd_ssc_t *ssc); 1228 static void sd_reenable_dsense_task(void *arg); 1229 #endif /* _LP64 */ 1230 1231 static void sd_set_mmc_caps(sd_ssc_t *ssc); 1232 1233 static void sd_read_unit_properties(struct sd_lun *un); 1234 static int sd_process_sdconf_file(struct sd_lun *un); 1235 static void sd_nvpair_str_decode(struct sd_lun *un, char *nvpair_str); 1236 static char *sd_strtok_r(char *string, const char *sepset, char **lasts); 1237 static void sd_set_properties(struct sd_lun *un, char *name, char *value); 1238 static void sd_get_tunables_from_conf(struct sd_lun *un, int flags, 1239 int *data_list, sd_tunables *values); 1240 static void sd_process_sdconf_table(struct sd_lun *un); 1241 static int sd_sdconf_id_match(struct sd_lun *un, char *id, int idlen); 1242 static int sd_blank_cmp(struct sd_lun *un, char *id, int idlen); 1243 static int sd_chk_vers1_data(struct sd_lun *un, int flags, int *prop_list, 1244 int list_len, char *dataname_ptr); 1245 static void sd_set_vers1_properties(struct sd_lun *un, int flags, 1246 sd_tunables *prop_list); 1247 1248 static void sd_register_devid(sd_ssc_t *ssc, dev_info_t *devi, 1249 int reservation_flag); 1250 static int sd_get_devid(sd_ssc_t *ssc); 1251 static ddi_devid_t sd_create_devid(sd_ssc_t *ssc); 1252 static int sd_write_deviceid(sd_ssc_t *ssc); 1253 static int sd_get_devid_page(struct sd_lun *un, uchar_t *wwn, int *len); 1254 static int sd_check_vpd_page_support(sd_ssc_t *ssc); 1255 1256 static void sd_setup_pm(sd_ssc_t *ssc, dev_info_t *devi); 1257 static void sd_create_pm_components(dev_info_t *devi, struct sd_lun *un); 1258 1259 static int sd_ddi_suspend(dev_info_t *devi); 1260 static int sd_ddi_resume(dev_info_t *devi); 1261 static int sd_pm_state_change(struct sd_lun *un, int level, int flag); 1262 static int sdpower(dev_info_t *devi, int component, int level); 1263 1264 static int sdattach(dev_info_t *devi, ddi_attach_cmd_t cmd); 1265 static int sddetach(dev_info_t *devi, ddi_detach_cmd_t cmd); 1266 static int sd_unit_attach(dev_info_t *devi); 1267 static int sd_unit_detach(dev_info_t *devi); 1268 1269 static void sd_set_unit_attributes(struct sd_lun *un, dev_info_t *devi); 1270 static void sd_create_errstats(struct sd_lun *un, int instance); 1271 static void sd_set_errstats(struct sd_lun *un); 1272 static void sd_set_pstats(struct sd_lun *un); 1273 1274 static int sddump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk); 1275 static int sd_scsi_poll(struct sd_lun *un, struct scsi_pkt *pkt); 1276 static int sd_send_polled_RQS(struct sd_lun *un); 1277 static int sd_ddi_scsi_poll(struct scsi_pkt *pkt); 1278 1279 #if (defined(__fibre)) 1280 /* 1281 * Event callbacks (photon) 1282 */ 1283 static void sd_init_event_callbacks(struct sd_lun *un); 1284 static void sd_event_callback(dev_info_t *, ddi_eventcookie_t, void *, void *); 1285 #endif 1286 1287 /* 1288 * Defines for sd_cache_control 1289 */ 1290 1291 #define SD_CACHE_ENABLE 1 1292 #define SD_CACHE_DISABLE 0 1293 #define SD_CACHE_NOCHANGE -1 1294 1295 static int sd_cache_control(sd_ssc_t *ssc, int rcd_flag, int wce_flag); 1296 static int sd_get_write_cache_enabled(sd_ssc_t *ssc, int *is_enabled); 1297 static void sd_get_nv_sup(sd_ssc_t *ssc); 1298 static dev_t sd_make_device(dev_info_t *devi); 1299 static void sd_check_solid_state(sd_ssc_t *ssc); 1300 static void sd_check_emulation_mode(sd_ssc_t *ssc); 1301 static void sd_update_block_info(struct sd_lun *un, uint32_t lbasize, 1302 uint64_t capacity); 1303 1304 /* 1305 * Driver entry point functions. 1306 */ 1307 static int sdopen(dev_t *dev_p, int flag, int otyp, cred_t *cred_p); 1308 static int sdclose(dev_t dev, int flag, int otyp, cred_t *cred_p); 1309 static int sd_ready_and_valid(sd_ssc_t *ssc, int part); 1310 1311 static void sdmin(struct buf *bp); 1312 static int sdread(dev_t dev, struct uio *uio, cred_t *cred_p); 1313 static int sdwrite(dev_t dev, struct uio *uio, cred_t *cred_p); 1314 static int sdaread(dev_t dev, struct aio_req *aio, cred_t *cred_p); 1315 static int sdawrite(dev_t dev, struct aio_req *aio, cred_t *cred_p); 1316 1317 static int sdstrategy(struct buf *bp); 1318 static int sdioctl(dev_t, int, intptr_t, int, cred_t *, int *); 1319 1320 /* 1321 * Function prototypes for layering functions in the iostart chain. 1322 */ 1323 static void sd_mapblockaddr_iostart(int index, struct sd_lun *un, 1324 struct buf *bp); 1325 static void sd_mapblocksize_iostart(int index, struct sd_lun *un, 1326 struct buf *bp); 1327 static void sd_checksum_iostart(int index, struct sd_lun *un, struct buf *bp); 1328 static void sd_checksum_uscsi_iostart(int index, struct sd_lun *un, 1329 struct buf *bp); 1330 static void sd_pm_iostart(int index, struct sd_lun *un, struct buf *bp); 1331 static void sd_core_iostart(int index, struct sd_lun *un, struct buf *bp); 1332 1333 /* 1334 * Function prototypes for layering functions in the iodone chain. 1335 */ 1336 static void sd_buf_iodone(int index, struct sd_lun *un, struct buf *bp); 1337 static void sd_uscsi_iodone(int index, struct sd_lun *un, struct buf *bp); 1338 static void sd_mapblockaddr_iodone(int index, struct sd_lun *un, 1339 struct buf *bp); 1340 static void sd_mapblocksize_iodone(int index, struct sd_lun *un, 1341 struct buf *bp); 1342 static void sd_checksum_iodone(int index, struct sd_lun *un, struct buf *bp); 1343 static void sd_checksum_uscsi_iodone(int index, struct sd_lun *un, 1344 struct buf *bp); 1345 static void sd_pm_iodone(int index, struct sd_lun *un, struct buf *bp); 1346 1347 /* 1348 * Prototypes for functions to support buf(9S) based IO. 1349 */ 1350 static void sd_xbuf_strategy(struct buf *bp, ddi_xbuf_t xp, void *arg); 1351 static int sd_initpkt_for_buf(struct buf *, struct scsi_pkt **); 1352 static void sd_destroypkt_for_buf(struct buf *); 1353 static int sd_setup_rw_pkt(struct sd_lun *un, struct scsi_pkt **pktpp, 1354 struct buf *bp, int flags, 1355 int (*callback)(caddr_t), caddr_t callback_arg, 1356 diskaddr_t lba, uint32_t blockcount); 1357 static int sd_setup_next_rw_pkt(struct sd_lun *un, struct scsi_pkt *pktp, 1358 struct buf *bp, diskaddr_t lba, uint32_t blockcount); 1359 1360 /* 1361 * Prototypes for functions to support USCSI IO. 1362 */ 1363 static int sd_uscsi_strategy(struct buf *bp); 1364 static int sd_initpkt_for_uscsi(struct buf *, struct scsi_pkt **); 1365 static void sd_destroypkt_for_uscsi(struct buf *); 1366 1367 static void sd_xbuf_init(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp, 1368 uchar_t chain_type, void *pktinfop); 1369 1370 static int sd_pm_entry(struct sd_lun *un); 1371 static void sd_pm_exit(struct sd_lun *un); 1372 1373 static void sd_pm_idletimeout_handler(void *arg); 1374 1375 /* 1376 * sd_core internal functions (used at the sd_core_io layer). 1377 */ 1378 static void sd_add_buf_to_waitq(struct sd_lun *un, struct buf *bp); 1379 static void sdintr(struct scsi_pkt *pktp); 1380 static void sd_start_cmds(struct sd_lun *un, struct buf *immed_bp); 1381 1382 static int sd_send_scsi_cmd(dev_t dev, struct uscsi_cmd *incmd, int flag, 1383 enum uio_seg dataspace, int path_flag); 1384 1385 static struct buf *sd_bioclone_alloc(struct buf *bp, size_t datalen, 1386 daddr_t blkno, int (*func)(struct buf *)); 1387 static struct buf *sd_shadow_buf_alloc(struct buf *bp, size_t datalen, 1388 uint_t bflags, daddr_t blkno, int (*func)(struct buf *)); 1389 static void sd_bioclone_free(struct buf *bp); 1390 static void sd_shadow_buf_free(struct buf *bp); 1391 1392 static void sd_print_transport_rejected_message(struct sd_lun *un, 1393 struct sd_xbuf *xp, int code); 1394 static void sd_print_incomplete_msg(struct sd_lun *un, struct buf *bp, 1395 void *arg, int code); 1396 static void sd_print_sense_failed_msg(struct sd_lun *un, struct buf *bp, 1397 void *arg, int code); 1398 static void sd_print_cmd_incomplete_msg(struct sd_lun *un, struct buf *bp, 1399 void *arg, int code); 1400 1401 static void sd_retry_command(struct sd_lun *un, struct buf *bp, 1402 int retry_check_flag, 1403 void (*user_funcp)(struct sd_lun *un, struct buf *bp, void *argp, 1404 int c), 1405 void *user_arg, int failure_code, clock_t retry_delay, 1406 void (*statp)(kstat_io_t *)); 1407 1408 static void sd_set_retry_bp(struct sd_lun *un, struct buf *bp, 1409 clock_t retry_delay, void (*statp)(kstat_io_t *)); 1410 1411 static void sd_send_request_sense_command(struct sd_lun *un, struct buf *bp, 1412 struct scsi_pkt *pktp); 1413 static void sd_start_retry_command(void *arg); 1414 static void sd_start_direct_priority_command(void *arg); 1415 static void sd_return_failed_command(struct sd_lun *un, struct buf *bp, 1416 int errcode); 1417 static void sd_return_failed_command_no_restart(struct sd_lun *un, 1418 struct buf *bp, int errcode); 1419 static void sd_return_command(struct sd_lun *un, struct buf *bp); 1420 static void sd_sync_with_callback(struct sd_lun *un); 1421 static int sdrunout(caddr_t arg); 1422 1423 static void sd_mark_rqs_busy(struct sd_lun *un, struct buf *bp); 1424 static struct buf *sd_mark_rqs_idle(struct sd_lun *un, struct sd_xbuf *xp); 1425 1426 static void sd_reduce_throttle(struct sd_lun *un, int throttle_type); 1427 static void sd_restore_throttle(void *arg); 1428 1429 static void sd_init_cdb_limits(struct sd_lun *un); 1430 1431 static void sd_pkt_status_good(struct sd_lun *un, struct buf *bp, 1432 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1433 1434 /* 1435 * Error handling functions 1436 */ 1437 static void sd_pkt_status_check_condition(struct sd_lun *un, struct buf *bp, 1438 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1439 static void sd_pkt_status_busy(struct sd_lun *un, struct buf *bp, 1440 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1441 static void sd_pkt_status_reservation_conflict(struct sd_lun *un, 1442 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp); 1443 static void sd_pkt_status_qfull(struct sd_lun *un, struct buf *bp, 1444 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1445 1446 static void sd_handle_request_sense(struct sd_lun *un, struct buf *bp, 1447 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1448 static void sd_handle_auto_request_sense(struct sd_lun *un, struct buf *bp, 1449 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1450 static int sd_validate_sense_data(struct sd_lun *un, struct buf *bp, 1451 struct sd_xbuf *xp, size_t actual_len); 1452 static void sd_decode_sense(struct sd_lun *un, struct buf *bp, 1453 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1454 1455 static void sd_print_sense_msg(struct sd_lun *un, struct buf *bp, 1456 void *arg, int code); 1457 1458 static void sd_sense_key_no_sense(struct sd_lun *un, struct buf *bp, 1459 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1460 static void sd_sense_key_recoverable_error(struct sd_lun *un, 1461 uint8_t *sense_datap, 1462 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp); 1463 static void sd_sense_key_not_ready(struct sd_lun *un, 1464 uint8_t *sense_datap, 1465 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp); 1466 static void sd_sense_key_medium_or_hardware_error(struct sd_lun *un, 1467 uint8_t *sense_datap, 1468 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp); 1469 static void sd_sense_key_illegal_request(struct sd_lun *un, struct buf *bp, 1470 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1471 static void sd_sense_key_unit_attention(struct sd_lun *un, 1472 uint8_t *sense_datap, 1473 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp); 1474 static void sd_sense_key_fail_command(struct sd_lun *un, struct buf *bp, 1475 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1476 static void sd_sense_key_blank_check(struct sd_lun *un, struct buf *bp, 1477 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1478 static void sd_sense_key_aborted_command(struct sd_lun *un, struct buf *bp, 1479 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1480 static void sd_sense_key_default(struct sd_lun *un, 1481 uint8_t *sense_datap, 1482 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp); 1483 1484 static void sd_print_retry_msg(struct sd_lun *un, struct buf *bp, 1485 void *arg, int flag); 1486 1487 static void sd_pkt_reason_cmd_incomplete(struct sd_lun *un, struct buf *bp, 1488 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1489 static void sd_pkt_reason_cmd_tran_err(struct sd_lun *un, struct buf *bp, 1490 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1491 static void sd_pkt_reason_cmd_reset(struct sd_lun *un, struct buf *bp, 1492 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1493 static void sd_pkt_reason_cmd_aborted(struct sd_lun *un, struct buf *bp, 1494 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1495 static void sd_pkt_reason_cmd_timeout(struct sd_lun *un, struct buf *bp, 1496 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1497 static void sd_pkt_reason_cmd_unx_bus_free(struct sd_lun *un, struct buf *bp, 1498 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1499 static void sd_pkt_reason_cmd_tag_reject(struct sd_lun *un, struct buf *bp, 1500 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1501 static void sd_pkt_reason_default(struct sd_lun *un, struct buf *bp, 1502 struct sd_xbuf *xp, struct scsi_pkt *pktp); 1503 1504 static void sd_reset_target(struct sd_lun *un, struct scsi_pkt *pktp); 1505 1506 static void sd_start_stop_unit_callback(void *arg); 1507 static void sd_start_stop_unit_task(void *arg); 1508 1509 static void sd_taskq_create(void); 1510 static void sd_taskq_delete(void); 1511 static void sd_target_change_task(void *arg); 1512 static void sd_log_dev_status_event(struct sd_lun *un, char *esc, int km_flag); 1513 static void sd_log_lun_expansion_event(struct sd_lun *un, int km_flag); 1514 static void sd_log_eject_request_event(struct sd_lun *un, int km_flag); 1515 static void sd_media_change_task(void *arg); 1516 1517 static int sd_handle_mchange(struct sd_lun *un); 1518 static int sd_send_scsi_DOORLOCK(sd_ssc_t *ssc, int flag, int path_flag); 1519 static int sd_send_scsi_READ_CAPACITY(sd_ssc_t *ssc, uint64_t *capp, 1520 uint32_t *lbap, int path_flag); 1521 static int sd_send_scsi_READ_CAPACITY_16(sd_ssc_t *ssc, uint64_t *capp, 1522 uint32_t *lbap, uint32_t *psp, int path_flag); 1523 static int sd_send_scsi_START_STOP_UNIT(sd_ssc_t *ssc, int pc_flag, 1524 int flag, int path_flag); 1525 static int sd_send_scsi_INQUIRY(sd_ssc_t *ssc, uchar_t *bufaddr, 1526 size_t buflen, uchar_t evpd, uchar_t page_code, size_t *residp); 1527 static int sd_send_scsi_TEST_UNIT_READY(sd_ssc_t *ssc, int flag); 1528 static int sd_send_scsi_PERSISTENT_RESERVE_IN(sd_ssc_t *ssc, 1529 uchar_t usr_cmd, uint16_t data_len, uchar_t *data_bufp); 1530 static int sd_send_scsi_PERSISTENT_RESERVE_OUT(sd_ssc_t *ssc, 1531 uchar_t usr_cmd, uchar_t *usr_bufp); 1532 static int sd_send_scsi_SYNCHRONIZE_CACHE(struct sd_lun *un, 1533 struct dk_callback *dkc); 1534 static int sd_send_scsi_SYNCHRONIZE_CACHE_biodone(struct buf *bp); 1535 static int sd_send_scsi_GET_CONFIGURATION(sd_ssc_t *ssc, 1536 struct uscsi_cmd *ucmdbuf, uchar_t *rqbuf, uint_t rqbuflen, 1537 uchar_t *bufaddr, uint_t buflen, int path_flag); 1538 static int sd_send_scsi_feature_GET_CONFIGURATION(sd_ssc_t *ssc, 1539 struct uscsi_cmd *ucmdbuf, uchar_t *rqbuf, uint_t rqbuflen, 1540 uchar_t *bufaddr, uint_t buflen, char feature, int path_flag); 1541 static int sd_send_scsi_MODE_SENSE(sd_ssc_t *ssc, int cdbsize, 1542 uchar_t *bufaddr, size_t buflen, uchar_t page_code, int path_flag); 1543 static int sd_send_scsi_MODE_SELECT(sd_ssc_t *ssc, int cdbsize, 1544 uchar_t *bufaddr, size_t buflen, uchar_t save_page, int path_flag); 1545 static int sd_send_scsi_RDWR(sd_ssc_t *ssc, uchar_t cmd, void *bufaddr, 1546 size_t buflen, daddr_t start_block, int path_flag); 1547 #define sd_send_scsi_READ(ssc, bufaddr, buflen, start_block, path_flag) \ 1548 sd_send_scsi_RDWR(ssc, SCMD_READ, bufaddr, buflen, start_block, \ 1549 path_flag) 1550 #define sd_send_scsi_WRITE(ssc, bufaddr, buflen, start_block, path_flag)\ 1551 sd_send_scsi_RDWR(ssc, SCMD_WRITE, bufaddr, buflen, start_block,\ 1552 path_flag) 1553 1554 static int sd_send_scsi_LOG_SENSE(sd_ssc_t *ssc, uchar_t *bufaddr, 1555 uint16_t buflen, uchar_t page_code, uchar_t page_control, 1556 uint16_t param_ptr, int path_flag); 1557 static int sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION(sd_ssc_t *ssc, 1558 uchar_t *bufaddr, size_t buflen, uchar_t class_req); 1559 static boolean_t sd_gesn_media_data_valid(uchar_t *data); 1560 1561 static int sd_alloc_rqs(struct scsi_device *devp, struct sd_lun *un); 1562 static void sd_free_rqs(struct sd_lun *un); 1563 1564 static void sd_dump_memory(struct sd_lun *un, uint_t comp, char *title, 1565 uchar_t *data, int len, int fmt); 1566 static void sd_panic_for_res_conflict(struct sd_lun *un); 1567 1568 /* 1569 * Disk Ioctl Function Prototypes 1570 */ 1571 static int sd_get_media_info(dev_t dev, caddr_t arg, int flag); 1572 static int sd_get_media_info_ext(dev_t dev, caddr_t arg, int flag); 1573 static int sd_dkio_ctrl_info(dev_t dev, caddr_t arg, int flag); 1574 static int sd_dkio_get_temp(dev_t dev, caddr_t arg, int flag); 1575 1576 /* 1577 * Multi-host Ioctl Prototypes 1578 */ 1579 static int sd_check_mhd(dev_t dev, int interval); 1580 static int sd_mhd_watch_cb(caddr_t arg, struct scsi_watch_result *resultp); 1581 static void sd_mhd_watch_incomplete(struct sd_lun *un, struct scsi_pkt *pkt); 1582 static char *sd_sname(uchar_t status); 1583 static void sd_mhd_resvd_recover(void *arg); 1584 static void sd_resv_reclaim_thread(); 1585 static int sd_take_ownership(dev_t dev, struct mhioctkown *p); 1586 static int sd_reserve_release(dev_t dev, int cmd); 1587 static void sd_rmv_resv_reclaim_req(dev_t dev); 1588 static void sd_mhd_reset_notify_cb(caddr_t arg); 1589 static int sd_persistent_reservation_in_read_keys(struct sd_lun *un, 1590 mhioc_inkeys_t *usrp, int flag); 1591 static int sd_persistent_reservation_in_read_resv(struct sd_lun *un, 1592 mhioc_inresvs_t *usrp, int flag); 1593 static int sd_mhdioc_takeown(dev_t dev, caddr_t arg, int flag); 1594 static int sd_mhdioc_failfast(dev_t dev, caddr_t arg, int flag); 1595 static int sd_mhdioc_release(dev_t dev); 1596 static int sd_mhdioc_register_devid(dev_t dev); 1597 static int sd_mhdioc_inkeys(dev_t dev, caddr_t arg, int flag); 1598 static int sd_mhdioc_inresv(dev_t dev, caddr_t arg, int flag); 1599 1600 /* 1601 * SCSI removable prototypes 1602 */ 1603 static int sr_change_blkmode(dev_t dev, int cmd, intptr_t data, int flag); 1604 static int sr_change_speed(dev_t dev, int cmd, intptr_t data, int flag); 1605 static int sr_atapi_change_speed(dev_t dev, int cmd, intptr_t data, int flag); 1606 static int sr_pause_resume(dev_t dev, int mode); 1607 static int sr_play_msf(dev_t dev, caddr_t data, int flag); 1608 static int sr_play_trkind(dev_t dev, caddr_t data, int flag); 1609 static int sr_read_all_subcodes(dev_t dev, caddr_t data, int flag); 1610 static int sr_read_subchannel(dev_t dev, caddr_t data, int flag); 1611 static int sr_read_tocentry(dev_t dev, caddr_t data, int flag); 1612 static int sr_read_tochdr(dev_t dev, caddr_t data, int flag); 1613 static int sr_read_cdda(dev_t dev, caddr_t data, int flag); 1614 static int sr_read_cdxa(dev_t dev, caddr_t data, int flag); 1615 static int sr_read_mode1(dev_t dev, caddr_t data, int flag); 1616 static int sr_read_mode2(dev_t dev, caddr_t data, int flag); 1617 static int sr_read_cd_mode2(dev_t dev, caddr_t data, int flag); 1618 static int sr_sector_mode(dev_t dev, uint32_t blksize); 1619 static int sr_eject(dev_t dev); 1620 static void sr_ejected(register struct sd_lun *un); 1621 static int sr_check_wp(dev_t dev); 1622 static opaque_t sd_watch_request_submit(struct sd_lun *un); 1623 static int sd_check_media(dev_t dev, enum dkio_state state); 1624 static int sd_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp); 1625 static void sd_delayed_cv_broadcast(void *arg); 1626 static int sr_volume_ctrl(dev_t dev, caddr_t data, int flag); 1627 static int sr_read_sony_session_offset(dev_t dev, caddr_t data, int flag); 1628 1629 static int sd_log_page_supported(sd_ssc_t *ssc, int log_page); 1630 1631 /* 1632 * Function Prototype for the non-512 support (DVDRAM, MO etc.) functions. 1633 */ 1634 static void sd_check_for_writable_cd(sd_ssc_t *ssc, int path_flag); 1635 static int sd_wm_cache_constructor(void *wm, void *un, int flags); 1636 static void sd_wm_cache_destructor(void *wm, void *un); 1637 static struct sd_w_map *sd_range_lock(struct sd_lun *un, daddr_t startb, 1638 daddr_t endb, ushort_t typ); 1639 static struct sd_w_map *sd_get_range(struct sd_lun *un, daddr_t startb, 1640 daddr_t endb); 1641 static void sd_free_inlist_wmap(struct sd_lun *un, struct sd_w_map *wmp); 1642 static void sd_range_unlock(struct sd_lun *un, struct sd_w_map *wm); 1643 static void sd_read_modify_write_task(void * arg); 1644 static int 1645 sddump_do_read_of_rmw(struct sd_lun *un, uint64_t blkno, uint64_t nblk, 1646 struct buf **bpp); 1647 1648 1649 /* 1650 * Function prototypes for failfast support. 1651 */ 1652 static void sd_failfast_flushq(struct sd_lun *un); 1653 static int sd_failfast_flushq_callback(struct buf *bp); 1654 1655 /* 1656 * Function prototypes to check for lsi devices 1657 */ 1658 static void sd_is_lsi(struct sd_lun *un); 1659 1660 /* 1661 * Function prototypes for partial DMA support 1662 */ 1663 static int sd_setup_next_xfer(struct sd_lun *un, struct buf *bp, 1664 struct scsi_pkt *pkt, struct sd_xbuf *xp); 1665 1666 1667 /* Function prototypes for cmlb */ 1668 static int sd_tg_rdwr(dev_info_t *devi, uchar_t cmd, void *bufaddr, 1669 diskaddr_t start_block, size_t reqlength, void *tg_cookie); 1670 1671 static int sd_tg_getinfo(dev_info_t *devi, int cmd, void *arg, void *tg_cookie); 1672 1673 /* 1674 * For printing RMW warning message timely 1675 */ 1676 static void sd_rmw_msg_print_handler(void *arg); 1677 1678 /* 1679 * Constants for failfast support: 1680 * 1681 * SD_FAILFAST_INACTIVE: Instance is currently in a normal state, with NO 1682 * failfast processing being performed. 1683 * 1684 * SD_FAILFAST_ACTIVE: Instance is in the failfast state and is performing 1685 * failfast processing on all bufs with B_FAILFAST set. 1686 */ 1687 1688 #define SD_FAILFAST_INACTIVE 0 1689 #define SD_FAILFAST_ACTIVE 1 1690 1691 /* 1692 * Bitmask to control behavior of buf(9S) flushes when a transition to 1693 * the failfast state occurs. Optional bits include: 1694 * 1695 * SD_FAILFAST_FLUSH_ALL_BUFS: When set, flush ALL bufs including those that 1696 * do NOT have B_FAILFAST set. When clear, only bufs with B_FAILFAST will 1697 * be flushed. 1698 * 1699 * SD_FAILFAST_FLUSH_ALL_QUEUES: When set, flush any/all other queues in the 1700 * driver, in addition to the regular wait queue. This includes the xbuf 1701 * queues. When clear, only the driver's wait queue will be flushed. 1702 */ 1703 #define SD_FAILFAST_FLUSH_ALL_BUFS 0x01 1704 #define SD_FAILFAST_FLUSH_ALL_QUEUES 0x02 1705 1706 /* 1707 * The default behavior is to only flush bufs that have B_FAILFAST set, but 1708 * to flush all queues within the driver. 1709 */ 1710 static int sd_failfast_flushctl = SD_FAILFAST_FLUSH_ALL_QUEUES; 1711 1712 1713 /* 1714 * SD Testing Fault Injection 1715 */ 1716 #ifdef SD_FAULT_INJECTION 1717 static void sd_faultinjection_ioctl(int cmd, intptr_t arg, struct sd_lun *un); 1718 static void sd_faultinjection(struct scsi_pkt *pktp); 1719 static void sd_injection_log(char *buf, struct sd_lun *un); 1720 #endif 1721 1722 /* 1723 * Device driver ops vector 1724 */ 1725 static struct cb_ops sd_cb_ops = { 1726 sdopen, /* open */ 1727 sdclose, /* close */ 1728 sdstrategy, /* strategy */ 1729 nodev, /* print */ 1730 sddump, /* dump */ 1731 sdread, /* read */ 1732 sdwrite, /* write */ 1733 sdioctl, /* ioctl */ 1734 nodev, /* devmap */ 1735 nodev, /* mmap */ 1736 nodev, /* segmap */ 1737 nochpoll, /* poll */ 1738 sd_prop_op, /* cb_prop_op */ 1739 0, /* streamtab */ 1740 D_64BIT | D_MP | D_NEW | D_HOTPLUG, /* Driver compatibility flags */ 1741 CB_REV, /* cb_rev */ 1742 sdaread, /* async I/O read entry point */ 1743 sdawrite /* async I/O write entry point */ 1744 }; 1745 1746 struct dev_ops sd_ops = { 1747 DEVO_REV, /* devo_rev, */ 1748 0, /* refcnt */ 1749 sdinfo, /* info */ 1750 nulldev, /* identify */ 1751 sdprobe, /* probe */ 1752 sdattach, /* attach */ 1753 sddetach, /* detach */ 1754 nodev, /* reset */ 1755 &sd_cb_ops, /* driver operations */ 1756 NULL, /* bus operations */ 1757 sdpower, /* power */ 1758 ddi_quiesce_not_needed, /* quiesce */ 1759 }; 1760 1761 /* 1762 * This is the loadable module wrapper. 1763 */ 1764 #include <sys/modctl.h> 1765 1766 #ifndef XPV_HVM_DRIVER 1767 static struct modldrv modldrv = { 1768 &mod_driverops, /* Type of module. This one is a driver */ 1769 SD_MODULE_NAME, /* Module name. */ 1770 &sd_ops /* driver ops */ 1771 }; 1772 1773 static struct modlinkage modlinkage = { 1774 MODREV_1, &modldrv, NULL 1775 }; 1776 1777 #else /* XPV_HVM_DRIVER */ 1778 static struct modlmisc modlmisc = { 1779 &mod_miscops, /* Type of module. This one is a misc */ 1780 "HVM " SD_MODULE_NAME, /* Module name. */ 1781 }; 1782 1783 static struct modlinkage modlinkage = { 1784 MODREV_1, &modlmisc, NULL 1785 }; 1786 1787 #endif /* XPV_HVM_DRIVER */ 1788 1789 static cmlb_tg_ops_t sd_tgops = { 1790 TG_DK_OPS_VERSION_1, 1791 sd_tg_rdwr, 1792 sd_tg_getinfo 1793 }; 1794 1795 static struct scsi_asq_key_strings sd_additional_codes[] = { 1796 0x81, 0, "Logical Unit is Reserved", 1797 0x85, 0, "Audio Address Not Valid", 1798 0xb6, 0, "Media Load Mechanism Failed", 1799 0xB9, 0, "Audio Play Operation Aborted", 1800 0xbf, 0, "Buffer Overflow for Read All Subcodes Command", 1801 0x53, 2, "Medium removal prevented", 1802 0x6f, 0, "Authentication failed during key exchange", 1803 0x6f, 1, "Key not present", 1804 0x6f, 2, "Key not established", 1805 0x6f, 3, "Read without proper authentication", 1806 0x6f, 4, "Mismatched region to this logical unit", 1807 0x6f, 5, "Region reset count error", 1808 0xffff, 0x0, NULL 1809 }; 1810 1811 1812 /* 1813 * Struct for passing printing information for sense data messages 1814 */ 1815 struct sd_sense_info { 1816 int ssi_severity; 1817 int ssi_pfa_flag; 1818 }; 1819 1820 /* 1821 * Table of function pointers for iostart-side routines. Separate "chains" 1822 * of layered function calls are formed by placing the function pointers 1823 * sequentially in the desired order. Functions are called according to an 1824 * incrementing table index ordering. The last function in each chain must 1825 * be sd_core_iostart(). The corresponding iodone-side routines are expected 1826 * in the sd_iodone_chain[] array. 1827 * 1828 * Note: It may seem more natural to organize both the iostart and iodone 1829 * functions together, into an array of structures (or some similar 1830 * organization) with a common index, rather than two separate arrays which 1831 * must be maintained in synchronization. The purpose of this division is 1832 * to achieve improved performance: individual arrays allows for more 1833 * effective cache line utilization on certain platforms. 1834 */ 1835 1836 typedef void (*sd_chain_t)(int index, struct sd_lun *un, struct buf *bp); 1837 1838 1839 static sd_chain_t sd_iostart_chain[] = { 1840 1841 /* Chain for buf IO for disk drive targets (PM enabled) */ 1842 sd_mapblockaddr_iostart, /* Index: 0 */ 1843 sd_pm_iostart, /* Index: 1 */ 1844 sd_core_iostart, /* Index: 2 */ 1845 1846 /* Chain for buf IO for disk drive targets (PM disabled) */ 1847 sd_mapblockaddr_iostart, /* Index: 3 */ 1848 sd_core_iostart, /* Index: 4 */ 1849 1850 /* 1851 * Chain for buf IO for removable-media or large sector size 1852 * disk drive targets with RMW needed (PM enabled) 1853 */ 1854 sd_mapblockaddr_iostart, /* Index: 5 */ 1855 sd_mapblocksize_iostart, /* Index: 6 */ 1856 sd_pm_iostart, /* Index: 7 */ 1857 sd_core_iostart, /* Index: 8 */ 1858 1859 /* 1860 * Chain for buf IO for removable-media or large sector size 1861 * disk drive targets with RMW needed (PM disabled) 1862 */ 1863 sd_mapblockaddr_iostart, /* Index: 9 */ 1864 sd_mapblocksize_iostart, /* Index: 10 */ 1865 sd_core_iostart, /* Index: 11 */ 1866 1867 /* Chain for buf IO for disk drives with checksumming (PM enabled) */ 1868 sd_mapblockaddr_iostart, /* Index: 12 */ 1869 sd_checksum_iostart, /* Index: 13 */ 1870 sd_pm_iostart, /* Index: 14 */ 1871 sd_core_iostart, /* Index: 15 */ 1872 1873 /* Chain for buf IO for disk drives with checksumming (PM disabled) */ 1874 sd_mapblockaddr_iostart, /* Index: 16 */ 1875 sd_checksum_iostart, /* Index: 17 */ 1876 sd_core_iostart, /* Index: 18 */ 1877 1878 /* Chain for USCSI commands (all targets) */ 1879 sd_pm_iostart, /* Index: 19 */ 1880 sd_core_iostart, /* Index: 20 */ 1881 1882 /* Chain for checksumming USCSI commands (all targets) */ 1883 sd_checksum_uscsi_iostart, /* Index: 21 */ 1884 sd_pm_iostart, /* Index: 22 */ 1885 sd_core_iostart, /* Index: 23 */ 1886 1887 /* Chain for "direct" USCSI commands (all targets) */ 1888 sd_core_iostart, /* Index: 24 */ 1889 1890 /* Chain for "direct priority" USCSI commands (all targets) */ 1891 sd_core_iostart, /* Index: 25 */ 1892 1893 /* 1894 * Chain for buf IO for large sector size disk drive targets 1895 * with RMW needed with checksumming (PM enabled) 1896 */ 1897 sd_mapblockaddr_iostart, /* Index: 26 */ 1898 sd_mapblocksize_iostart, /* Index: 27 */ 1899 sd_checksum_iostart, /* Index: 28 */ 1900 sd_pm_iostart, /* Index: 29 */ 1901 sd_core_iostart, /* Index: 30 */ 1902 1903 /* 1904 * Chain for buf IO for large sector size disk drive targets 1905 * with RMW needed with checksumming (PM disabled) 1906 */ 1907 sd_mapblockaddr_iostart, /* Index: 31 */ 1908 sd_mapblocksize_iostart, /* Index: 32 */ 1909 sd_checksum_iostart, /* Index: 33 */ 1910 sd_core_iostart, /* Index: 34 */ 1911 1912 }; 1913 1914 /* 1915 * Macros to locate the first function of each iostart chain in the 1916 * sd_iostart_chain[] array. These are located by the index in the array. 1917 */ 1918 #define SD_CHAIN_DISK_IOSTART 0 1919 #define SD_CHAIN_DISK_IOSTART_NO_PM 3 1920 #define SD_CHAIN_MSS_DISK_IOSTART 5 1921 #define SD_CHAIN_RMMEDIA_IOSTART 5 1922 #define SD_CHAIN_MSS_DISK_IOSTART_NO_PM 9 1923 #define SD_CHAIN_RMMEDIA_IOSTART_NO_PM 9 1924 #define SD_CHAIN_CHKSUM_IOSTART 12 1925 #define SD_CHAIN_CHKSUM_IOSTART_NO_PM 16 1926 #define SD_CHAIN_USCSI_CMD_IOSTART 19 1927 #define SD_CHAIN_USCSI_CHKSUM_IOSTART 21 1928 #define SD_CHAIN_DIRECT_CMD_IOSTART 24 1929 #define SD_CHAIN_PRIORITY_CMD_IOSTART 25 1930 #define SD_CHAIN_MSS_CHKSUM_IOSTART 26 1931 #define SD_CHAIN_MSS_CHKSUM_IOSTART_NO_PM 31 1932 1933 1934 /* 1935 * Table of function pointers for the iodone-side routines for the driver- 1936 * internal layering mechanism. The calling sequence for iodone routines 1937 * uses a decrementing table index, so the last routine called in a chain 1938 * must be at the lowest array index location for that chain. The last 1939 * routine for each chain must be either sd_buf_iodone() (for buf(9S) IOs) 1940 * or sd_uscsi_iodone() (for uscsi IOs). Other than this, the ordering 1941 * of the functions in an iodone side chain must correspond to the ordering 1942 * of the iostart routines for that chain. Note that there is no iodone 1943 * side routine that corresponds to sd_core_iostart(), so there is no 1944 * entry in the table for this. 1945 */ 1946 1947 static sd_chain_t sd_iodone_chain[] = { 1948 1949 /* Chain for buf IO for disk drive targets (PM enabled) */ 1950 sd_buf_iodone, /* Index: 0 */ 1951 sd_mapblockaddr_iodone, /* Index: 1 */ 1952 sd_pm_iodone, /* Index: 2 */ 1953 1954 /* Chain for buf IO for disk drive targets (PM disabled) */ 1955 sd_buf_iodone, /* Index: 3 */ 1956 sd_mapblockaddr_iodone, /* Index: 4 */ 1957 1958 /* 1959 * Chain for buf IO for removable-media or large sector size 1960 * disk drive targets with RMW needed (PM enabled) 1961 */ 1962 sd_buf_iodone, /* Index: 5 */ 1963 sd_mapblockaddr_iodone, /* Index: 6 */ 1964 sd_mapblocksize_iodone, /* Index: 7 */ 1965 sd_pm_iodone, /* Index: 8 */ 1966 1967 /* 1968 * Chain for buf IO for removable-media or large sector size 1969 * disk drive targets with RMW needed (PM disabled) 1970 */ 1971 sd_buf_iodone, /* Index: 9 */ 1972 sd_mapblockaddr_iodone, /* Index: 10 */ 1973 sd_mapblocksize_iodone, /* Index: 11 */ 1974 1975 /* Chain for buf IO for disk drives with checksumming (PM enabled) */ 1976 sd_buf_iodone, /* Index: 12 */ 1977 sd_mapblockaddr_iodone, /* Index: 13 */ 1978 sd_checksum_iodone, /* Index: 14 */ 1979 sd_pm_iodone, /* Index: 15 */ 1980 1981 /* Chain for buf IO for disk drives with checksumming (PM disabled) */ 1982 sd_buf_iodone, /* Index: 16 */ 1983 sd_mapblockaddr_iodone, /* Index: 17 */ 1984 sd_checksum_iodone, /* Index: 18 */ 1985 1986 /* Chain for USCSI commands (non-checksum targets) */ 1987 sd_uscsi_iodone, /* Index: 19 */ 1988 sd_pm_iodone, /* Index: 20 */ 1989 1990 /* Chain for USCSI commands (checksum targets) */ 1991 sd_uscsi_iodone, /* Index: 21 */ 1992 sd_checksum_uscsi_iodone, /* Index: 22 */ 1993 sd_pm_iodone, /* Index: 22 */ 1994 1995 /* Chain for "direct" USCSI commands (all targets) */ 1996 sd_uscsi_iodone, /* Index: 24 */ 1997 1998 /* Chain for "direct priority" USCSI commands (all targets) */ 1999 sd_uscsi_iodone, /* Index: 25 */ 2000 2001 /* 2002 * Chain for buf IO for large sector size disk drive targets 2003 * with checksumming (PM enabled) 2004 */ 2005 sd_buf_iodone, /* Index: 26 */ 2006 sd_mapblockaddr_iodone, /* Index: 27 */ 2007 sd_mapblocksize_iodone, /* Index: 28 */ 2008 sd_checksum_iodone, /* Index: 29 */ 2009 sd_pm_iodone, /* Index: 30 */ 2010 2011 /* 2012 * Chain for buf IO for large sector size disk drive targets 2013 * with checksumming (PM disabled) 2014 */ 2015 sd_buf_iodone, /* Index: 31 */ 2016 sd_mapblockaddr_iodone, /* Index: 32 */ 2017 sd_mapblocksize_iodone, /* Index: 33 */ 2018 sd_checksum_iodone, /* Index: 34 */ 2019 }; 2020 2021 2022 /* 2023 * Macros to locate the "first" function in the sd_iodone_chain[] array for 2024 * each iodone-side chain. These are located by the array index, but as the 2025 * iodone side functions are called in a decrementing-index order, the 2026 * highest index number in each chain must be specified (as these correspond 2027 * to the first function in the iodone chain that will be called by the core 2028 * at IO completion time). 2029 */ 2030 2031 #define SD_CHAIN_DISK_IODONE 2 2032 #define SD_CHAIN_DISK_IODONE_NO_PM 4 2033 #define SD_CHAIN_RMMEDIA_IODONE 8 2034 #define SD_CHAIN_MSS_DISK_IODONE 8 2035 #define SD_CHAIN_RMMEDIA_IODONE_NO_PM 11 2036 #define SD_CHAIN_MSS_DISK_IODONE_NO_PM 11 2037 #define SD_CHAIN_CHKSUM_IODONE 15 2038 #define SD_CHAIN_CHKSUM_IODONE_NO_PM 18 2039 #define SD_CHAIN_USCSI_CMD_IODONE 20 2040 #define SD_CHAIN_USCSI_CHKSUM_IODONE 22 2041 #define SD_CHAIN_DIRECT_CMD_IODONE 24 2042 #define SD_CHAIN_PRIORITY_CMD_IODONE 25 2043 #define SD_CHAIN_MSS_CHKSUM_IODONE 30 2044 #define SD_CHAIN_MSS_CHKSUM_IODONE_NO_PM 34 2045 2046 2047 2048 /* 2049 * Array to map a layering chain index to the appropriate initpkt routine. 2050 * The redundant entries are present so that the index used for accessing 2051 * the above sd_iostart_chain and sd_iodone_chain tables can be used directly 2052 * with this table as well. 2053 */ 2054 typedef int (*sd_initpkt_t)(struct buf *, struct scsi_pkt **); 2055 2056 static sd_initpkt_t sd_initpkt_map[] = { 2057 2058 /* Chain for buf IO for disk drive targets (PM enabled) */ 2059 sd_initpkt_for_buf, /* Index: 0 */ 2060 sd_initpkt_for_buf, /* Index: 1 */ 2061 sd_initpkt_for_buf, /* Index: 2 */ 2062 2063 /* Chain for buf IO for disk drive targets (PM disabled) */ 2064 sd_initpkt_for_buf, /* Index: 3 */ 2065 sd_initpkt_for_buf, /* Index: 4 */ 2066 2067 /* 2068 * Chain for buf IO for removable-media or large sector size 2069 * disk drive targets (PM enabled) 2070 */ 2071 sd_initpkt_for_buf, /* Index: 5 */ 2072 sd_initpkt_for_buf, /* Index: 6 */ 2073 sd_initpkt_for_buf, /* Index: 7 */ 2074 sd_initpkt_for_buf, /* Index: 8 */ 2075 2076 /* 2077 * Chain for buf IO for removable-media or large sector size 2078 * disk drive targets (PM disabled) 2079 */ 2080 sd_initpkt_for_buf, /* Index: 9 */ 2081 sd_initpkt_for_buf, /* Index: 10 */ 2082 sd_initpkt_for_buf, /* Index: 11 */ 2083 2084 /* Chain for buf IO for disk drives with checksumming (PM enabled) */ 2085 sd_initpkt_for_buf, /* Index: 12 */ 2086 sd_initpkt_for_buf, /* Index: 13 */ 2087 sd_initpkt_for_buf, /* Index: 14 */ 2088 sd_initpkt_for_buf, /* Index: 15 */ 2089 2090 /* Chain for buf IO for disk drives with checksumming (PM disabled) */ 2091 sd_initpkt_for_buf, /* Index: 16 */ 2092 sd_initpkt_for_buf, /* Index: 17 */ 2093 sd_initpkt_for_buf, /* Index: 18 */ 2094 2095 /* Chain for USCSI commands (non-checksum targets) */ 2096 sd_initpkt_for_uscsi, /* Index: 19 */ 2097 sd_initpkt_for_uscsi, /* Index: 20 */ 2098 2099 /* Chain for USCSI commands (checksum targets) */ 2100 sd_initpkt_for_uscsi, /* Index: 21 */ 2101 sd_initpkt_for_uscsi, /* Index: 22 */ 2102 sd_initpkt_for_uscsi, /* Index: 22 */ 2103 2104 /* Chain for "direct" USCSI commands (all targets) */ 2105 sd_initpkt_for_uscsi, /* Index: 24 */ 2106 2107 /* Chain for "direct priority" USCSI commands (all targets) */ 2108 sd_initpkt_for_uscsi, /* Index: 25 */ 2109 2110 /* 2111 * Chain for buf IO for large sector size disk drive targets 2112 * with checksumming (PM enabled) 2113 */ 2114 sd_initpkt_for_buf, /* Index: 26 */ 2115 sd_initpkt_for_buf, /* Index: 27 */ 2116 sd_initpkt_for_buf, /* Index: 28 */ 2117 sd_initpkt_for_buf, /* Index: 29 */ 2118 sd_initpkt_for_buf, /* Index: 30 */ 2119 2120 /* 2121 * Chain for buf IO for large sector size disk drive targets 2122 * with checksumming (PM disabled) 2123 */ 2124 sd_initpkt_for_buf, /* Index: 31 */ 2125 sd_initpkt_for_buf, /* Index: 32 */ 2126 sd_initpkt_for_buf, /* Index: 33 */ 2127 sd_initpkt_for_buf, /* Index: 34 */ 2128 }; 2129 2130 2131 /* 2132 * Array to map a layering chain index to the appropriate destroypktpkt routine. 2133 * The redundant entries are present so that the index used for accessing 2134 * the above sd_iostart_chain and sd_iodone_chain tables can be used directly 2135 * with this table as well. 2136 */ 2137 typedef void (*sd_destroypkt_t)(struct buf *); 2138 2139 static sd_destroypkt_t sd_destroypkt_map[] = { 2140 2141 /* Chain for buf IO for disk drive targets (PM enabled) */ 2142 sd_destroypkt_for_buf, /* Index: 0 */ 2143 sd_destroypkt_for_buf, /* Index: 1 */ 2144 sd_destroypkt_for_buf, /* Index: 2 */ 2145 2146 /* Chain for buf IO for disk drive targets (PM disabled) */ 2147 sd_destroypkt_for_buf, /* Index: 3 */ 2148 sd_destroypkt_for_buf, /* Index: 4 */ 2149 2150 /* 2151 * Chain for buf IO for removable-media or large sector size 2152 * disk drive targets (PM enabled) 2153 */ 2154 sd_destroypkt_for_buf, /* Index: 5 */ 2155 sd_destroypkt_for_buf, /* Index: 6 */ 2156 sd_destroypkt_for_buf, /* Index: 7 */ 2157 sd_destroypkt_for_buf, /* Index: 8 */ 2158 2159 /* 2160 * Chain for buf IO for removable-media or large sector size 2161 * disk drive targets (PM disabled) 2162 */ 2163 sd_destroypkt_for_buf, /* Index: 9 */ 2164 sd_destroypkt_for_buf, /* Index: 10 */ 2165 sd_destroypkt_for_buf, /* Index: 11 */ 2166 2167 /* Chain for buf IO for disk drives with checksumming (PM enabled) */ 2168 sd_destroypkt_for_buf, /* Index: 12 */ 2169 sd_destroypkt_for_buf, /* Index: 13 */ 2170 sd_destroypkt_for_buf, /* Index: 14 */ 2171 sd_destroypkt_for_buf, /* Index: 15 */ 2172 2173 /* Chain for buf IO for disk drives with checksumming (PM disabled) */ 2174 sd_destroypkt_for_buf, /* Index: 16 */ 2175 sd_destroypkt_for_buf, /* Index: 17 */ 2176 sd_destroypkt_for_buf, /* Index: 18 */ 2177 2178 /* Chain for USCSI commands (non-checksum targets) */ 2179 sd_destroypkt_for_uscsi, /* Index: 19 */ 2180 sd_destroypkt_for_uscsi, /* Index: 20 */ 2181 2182 /* Chain for USCSI commands (checksum targets) */ 2183 sd_destroypkt_for_uscsi, /* Index: 21 */ 2184 sd_destroypkt_for_uscsi, /* Index: 22 */ 2185 sd_destroypkt_for_uscsi, /* Index: 22 */ 2186 2187 /* Chain for "direct" USCSI commands (all targets) */ 2188 sd_destroypkt_for_uscsi, /* Index: 24 */ 2189 2190 /* Chain for "direct priority" USCSI commands (all targets) */ 2191 sd_destroypkt_for_uscsi, /* Index: 25 */ 2192 2193 /* 2194 * Chain for buf IO for large sector size disk drive targets 2195 * with checksumming (PM disabled) 2196 */ 2197 sd_destroypkt_for_buf, /* Index: 26 */ 2198 sd_destroypkt_for_buf, /* Index: 27 */ 2199 sd_destroypkt_for_buf, /* Index: 28 */ 2200 sd_destroypkt_for_buf, /* Index: 29 */ 2201 sd_destroypkt_for_buf, /* Index: 30 */ 2202 2203 /* 2204 * Chain for buf IO for large sector size disk drive targets 2205 * with checksumming (PM enabled) 2206 */ 2207 sd_destroypkt_for_buf, /* Index: 31 */ 2208 sd_destroypkt_for_buf, /* Index: 32 */ 2209 sd_destroypkt_for_buf, /* Index: 33 */ 2210 sd_destroypkt_for_buf, /* Index: 34 */ 2211 }; 2212 2213 2214 2215 /* 2216 * Array to map a layering chain index to the appropriate chain "type". 2217 * The chain type indicates a specific property/usage of the chain. 2218 * The redundant entries are present so that the index used for accessing 2219 * the above sd_iostart_chain and sd_iodone_chain tables can be used directly 2220 * with this table as well. 2221 */ 2222 2223 #define SD_CHAIN_NULL 0 /* for the special RQS cmd */ 2224 #define SD_CHAIN_BUFIO 1 /* regular buf IO */ 2225 #define SD_CHAIN_USCSI 2 /* regular USCSI commands */ 2226 #define SD_CHAIN_DIRECT 3 /* uscsi, w/ bypass power mgt */ 2227 #define SD_CHAIN_DIRECT_PRIORITY 4 /* uscsi, w/ bypass power mgt */ 2228 /* (for error recovery) */ 2229 2230 static int sd_chain_type_map[] = { 2231 2232 /* Chain for buf IO for disk drive targets (PM enabled) */ 2233 SD_CHAIN_BUFIO, /* Index: 0 */ 2234 SD_CHAIN_BUFIO, /* Index: 1 */ 2235 SD_CHAIN_BUFIO, /* Index: 2 */ 2236 2237 /* Chain for buf IO for disk drive targets (PM disabled) */ 2238 SD_CHAIN_BUFIO, /* Index: 3 */ 2239 SD_CHAIN_BUFIO, /* Index: 4 */ 2240 2241 /* 2242 * Chain for buf IO for removable-media or large sector size 2243 * disk drive targets (PM enabled) 2244 */ 2245 SD_CHAIN_BUFIO, /* Index: 5 */ 2246 SD_CHAIN_BUFIO, /* Index: 6 */ 2247 SD_CHAIN_BUFIO, /* Index: 7 */ 2248 SD_CHAIN_BUFIO, /* Index: 8 */ 2249 2250 /* 2251 * Chain for buf IO for removable-media or large sector size 2252 * disk drive targets (PM disabled) 2253 */ 2254 SD_CHAIN_BUFIO, /* Index: 9 */ 2255 SD_CHAIN_BUFIO, /* Index: 10 */ 2256 SD_CHAIN_BUFIO, /* Index: 11 */ 2257 2258 /* Chain for buf IO for disk drives with checksumming (PM enabled) */ 2259 SD_CHAIN_BUFIO, /* Index: 12 */ 2260 SD_CHAIN_BUFIO, /* Index: 13 */ 2261 SD_CHAIN_BUFIO, /* Index: 14 */ 2262 SD_CHAIN_BUFIO, /* Index: 15 */ 2263 2264 /* Chain for buf IO for disk drives with checksumming (PM disabled) */ 2265 SD_CHAIN_BUFIO, /* Index: 16 */ 2266 SD_CHAIN_BUFIO, /* Index: 17 */ 2267 SD_CHAIN_BUFIO, /* Index: 18 */ 2268 2269 /* Chain for USCSI commands (non-checksum targets) */ 2270 SD_CHAIN_USCSI, /* Index: 19 */ 2271 SD_CHAIN_USCSI, /* Index: 20 */ 2272 2273 /* Chain for USCSI commands (checksum targets) */ 2274 SD_CHAIN_USCSI, /* Index: 21 */ 2275 SD_CHAIN_USCSI, /* Index: 22 */ 2276 SD_CHAIN_USCSI, /* Index: 23 */ 2277 2278 /* Chain for "direct" USCSI commands (all targets) */ 2279 SD_CHAIN_DIRECT, /* Index: 24 */ 2280 2281 /* Chain for "direct priority" USCSI commands (all targets) */ 2282 SD_CHAIN_DIRECT_PRIORITY, /* Index: 25 */ 2283 2284 /* 2285 * Chain for buf IO for large sector size disk drive targets 2286 * with checksumming (PM enabled) 2287 */ 2288 SD_CHAIN_BUFIO, /* Index: 26 */ 2289 SD_CHAIN_BUFIO, /* Index: 27 */ 2290 SD_CHAIN_BUFIO, /* Index: 28 */ 2291 SD_CHAIN_BUFIO, /* Index: 29 */ 2292 SD_CHAIN_BUFIO, /* Index: 30 */ 2293 2294 /* 2295 * Chain for buf IO for large sector size disk drive targets 2296 * with checksumming (PM disabled) 2297 */ 2298 SD_CHAIN_BUFIO, /* Index: 31 */ 2299 SD_CHAIN_BUFIO, /* Index: 32 */ 2300 SD_CHAIN_BUFIO, /* Index: 33 */ 2301 SD_CHAIN_BUFIO, /* Index: 34 */ 2302 }; 2303 2304 2305 /* Macro to return TRUE if the IO has come from the sd_buf_iostart() chain. */ 2306 #define SD_IS_BUFIO(xp) \ 2307 (sd_chain_type_map[(xp)->xb_chain_iostart] == SD_CHAIN_BUFIO) 2308 2309 /* Macro to return TRUE if the IO has come from the "direct priority" chain. */ 2310 #define SD_IS_DIRECT_PRIORITY(xp) \ 2311 (sd_chain_type_map[(xp)->xb_chain_iostart] == SD_CHAIN_DIRECT_PRIORITY) 2312 2313 2314 2315 /* 2316 * Struct, array, and macros to map a specific chain to the appropriate 2317 * layering indexes in the sd_iostart_chain[] and sd_iodone_chain[] arrays. 2318 * 2319 * The sd_chain_index_map[] array is used at attach time to set the various 2320 * un_xxx_chain type members of the sd_lun softstate to the specific layering 2321 * chain to be used with the instance. This allows different instances to use 2322 * different chain for buf IO, uscsi IO, etc.. Also, since the xb_chain_iostart 2323 * and xb_chain_iodone index values in the sd_xbuf are initialized to these 2324 * values at sd_xbuf init time, this allows (1) layering chains may be changed 2325 * dynamically & without the use of locking; and (2) a layer may update the 2326 * xb_chain_io[start|done] member in a given xbuf with its current index value, 2327 * to allow for deferred processing of an IO within the same chain from a 2328 * different execution context. 2329 */ 2330 2331 struct sd_chain_index { 2332 int sci_iostart_index; 2333 int sci_iodone_index; 2334 }; 2335 2336 static struct sd_chain_index sd_chain_index_map[] = { 2337 { SD_CHAIN_DISK_IOSTART, SD_CHAIN_DISK_IODONE }, 2338 { SD_CHAIN_DISK_IOSTART_NO_PM, SD_CHAIN_DISK_IODONE_NO_PM }, 2339 { SD_CHAIN_RMMEDIA_IOSTART, SD_CHAIN_RMMEDIA_IODONE }, 2340 { SD_CHAIN_RMMEDIA_IOSTART_NO_PM, SD_CHAIN_RMMEDIA_IODONE_NO_PM }, 2341 { SD_CHAIN_CHKSUM_IOSTART, SD_CHAIN_CHKSUM_IODONE }, 2342 { SD_CHAIN_CHKSUM_IOSTART_NO_PM, SD_CHAIN_CHKSUM_IODONE_NO_PM }, 2343 { SD_CHAIN_USCSI_CMD_IOSTART, SD_CHAIN_USCSI_CMD_IODONE }, 2344 { SD_CHAIN_USCSI_CHKSUM_IOSTART, SD_CHAIN_USCSI_CHKSUM_IODONE }, 2345 { SD_CHAIN_DIRECT_CMD_IOSTART, SD_CHAIN_DIRECT_CMD_IODONE }, 2346 { SD_CHAIN_PRIORITY_CMD_IOSTART, SD_CHAIN_PRIORITY_CMD_IODONE }, 2347 { SD_CHAIN_MSS_CHKSUM_IOSTART, SD_CHAIN_MSS_CHKSUM_IODONE }, 2348 { SD_CHAIN_MSS_CHKSUM_IOSTART_NO_PM, SD_CHAIN_MSS_CHKSUM_IODONE_NO_PM }, 2349 2350 }; 2351 2352 2353 /* 2354 * The following are indexes into the sd_chain_index_map[] array. 2355 */ 2356 2357 /* un->un_buf_chain_type must be set to one of these */ 2358 #define SD_CHAIN_INFO_DISK 0 2359 #define SD_CHAIN_INFO_DISK_NO_PM 1 2360 #define SD_CHAIN_INFO_RMMEDIA 2 2361 #define SD_CHAIN_INFO_MSS_DISK 2 2362 #define SD_CHAIN_INFO_RMMEDIA_NO_PM 3 2363 #define SD_CHAIN_INFO_MSS_DSK_NO_PM 3 2364 #define SD_CHAIN_INFO_CHKSUM 4 2365 #define SD_CHAIN_INFO_CHKSUM_NO_PM 5 2366 #define SD_CHAIN_INFO_MSS_DISK_CHKSUM 10 2367 #define SD_CHAIN_INFO_MSS_DISK_CHKSUM_NO_PM 11 2368 2369 /* un->un_uscsi_chain_type must be set to one of these */ 2370 #define SD_CHAIN_INFO_USCSI_CMD 6 2371 /* USCSI with PM disabled is the same as DIRECT */ 2372 #define SD_CHAIN_INFO_USCSI_CMD_NO_PM 8 2373 #define SD_CHAIN_INFO_USCSI_CHKSUM 7 2374 2375 /* un->un_direct_chain_type must be set to one of these */ 2376 #define SD_CHAIN_INFO_DIRECT_CMD 8 2377 2378 /* un->un_priority_chain_type must be set to one of these */ 2379 #define SD_CHAIN_INFO_PRIORITY_CMD 9 2380 2381 /* size for devid inquiries */ 2382 #define MAX_INQUIRY_SIZE 0xF0 2383 2384 /* 2385 * Macros used by functions to pass a given buf(9S) struct along to the 2386 * next function in the layering chain for further processing. 2387 * 2388 * In the following macros, passing more than three arguments to the called 2389 * routines causes the optimizer for the SPARC compiler to stop doing tail 2390 * call elimination which results in significant performance degradation. 2391 */ 2392 #define SD_BEGIN_IOSTART(index, un, bp) \ 2393 ((*(sd_iostart_chain[index]))(index, un, bp)) 2394 2395 #define SD_BEGIN_IODONE(index, un, bp) \ 2396 ((*(sd_iodone_chain[index]))(index, un, bp)) 2397 2398 #define SD_NEXT_IOSTART(index, un, bp) \ 2399 ((*(sd_iostart_chain[(index) + 1]))((index) + 1, un, bp)) 2400 2401 #define SD_NEXT_IODONE(index, un, bp) \ 2402 ((*(sd_iodone_chain[(index) - 1]))((index) - 1, un, bp)) 2403 2404 /* 2405 * Function: _init 2406 * 2407 * Description: This is the driver _init(9E) entry point. 2408 * 2409 * Return Code: Returns the value from mod_install(9F) or 2410 * ddi_soft_state_init(9F) as appropriate. 2411 * 2412 * Context: Called when driver module loaded. 2413 */ 2414 2415 int 2416 _init(void) 2417 { 2418 int err; 2419 2420 /* establish driver name from module name */ 2421 sd_label = (char *)mod_modname(&modlinkage); 2422 2423 #ifndef XPV_HVM_DRIVER 2424 err = ddi_soft_state_init(&sd_state, sizeof (struct sd_lun), 2425 SD_MAXUNIT); 2426 if (err != 0) { 2427 return (err); 2428 } 2429 2430 #else /* XPV_HVM_DRIVER */ 2431 /* Remove the leading "hvm_" from the module name */ 2432 ASSERT(strncmp(sd_label, "hvm_", strlen("hvm_")) == 0); 2433 sd_label += strlen("hvm_"); 2434 2435 #endif /* XPV_HVM_DRIVER */ 2436 2437 mutex_init(&sd_detach_mutex, NULL, MUTEX_DRIVER, NULL); 2438 mutex_init(&sd_log_mutex, NULL, MUTEX_DRIVER, NULL); 2439 mutex_init(&sd_label_mutex, NULL, MUTEX_DRIVER, NULL); 2440 2441 mutex_init(&sd_tr.srq_resv_reclaim_mutex, NULL, MUTEX_DRIVER, NULL); 2442 cv_init(&sd_tr.srq_resv_reclaim_cv, NULL, CV_DRIVER, NULL); 2443 cv_init(&sd_tr.srq_inprocess_cv, NULL, CV_DRIVER, NULL); 2444 2445 /* 2446 * it's ok to init here even for fibre device 2447 */ 2448 sd_scsi_probe_cache_init(); 2449 2450 sd_scsi_target_lun_init(); 2451 2452 /* 2453 * Creating taskq before mod_install ensures that all callers (threads) 2454 * that enter the module after a successful mod_install encounter 2455 * a valid taskq. 2456 */ 2457 sd_taskq_create(); 2458 2459 err = mod_install(&modlinkage); 2460 if (err != 0) { 2461 /* delete taskq if install fails */ 2462 sd_taskq_delete(); 2463 2464 mutex_destroy(&sd_detach_mutex); 2465 mutex_destroy(&sd_log_mutex); 2466 mutex_destroy(&sd_label_mutex); 2467 2468 mutex_destroy(&sd_tr.srq_resv_reclaim_mutex); 2469 cv_destroy(&sd_tr.srq_resv_reclaim_cv); 2470 cv_destroy(&sd_tr.srq_inprocess_cv); 2471 2472 sd_scsi_probe_cache_fini(); 2473 2474 sd_scsi_target_lun_fini(); 2475 2476 #ifndef XPV_HVM_DRIVER 2477 ddi_soft_state_fini(&sd_state); 2478 #endif /* !XPV_HVM_DRIVER */ 2479 return (err); 2480 } 2481 2482 return (err); 2483 } 2484 2485 2486 /* 2487 * Function: _fini 2488 * 2489 * Description: This is the driver _fini(9E) entry point. 2490 * 2491 * Return Code: Returns the value from mod_remove(9F) 2492 * 2493 * Context: Called when driver module is unloaded. 2494 */ 2495 2496 int 2497 _fini(void) 2498 { 2499 int err; 2500 2501 if ((err = mod_remove(&modlinkage)) != 0) { 2502 return (err); 2503 } 2504 2505 sd_taskq_delete(); 2506 2507 mutex_destroy(&sd_detach_mutex); 2508 mutex_destroy(&sd_log_mutex); 2509 mutex_destroy(&sd_label_mutex); 2510 mutex_destroy(&sd_tr.srq_resv_reclaim_mutex); 2511 2512 sd_scsi_probe_cache_fini(); 2513 2514 sd_scsi_target_lun_fini(); 2515 2516 cv_destroy(&sd_tr.srq_resv_reclaim_cv); 2517 cv_destroy(&sd_tr.srq_inprocess_cv); 2518 2519 #ifndef XPV_HVM_DRIVER 2520 ddi_soft_state_fini(&sd_state); 2521 #endif /* !XPV_HVM_DRIVER */ 2522 2523 return (err); 2524 } 2525 2526 2527 /* 2528 * Function: _info 2529 * 2530 * Description: This is the driver _info(9E) entry point. 2531 * 2532 * Arguments: modinfop - pointer to the driver modinfo structure 2533 * 2534 * Return Code: Returns the value from mod_info(9F). 2535 * 2536 * Context: Kernel thread context 2537 */ 2538 2539 int 2540 _info(struct modinfo *modinfop) 2541 { 2542 return (mod_info(&modlinkage, modinfop)); 2543 } 2544 2545 2546 /* 2547 * The following routines implement the driver message logging facility. 2548 * They provide component- and level- based debug output filtering. 2549 * Output may also be restricted to messages for a single instance by 2550 * specifying a soft state pointer in sd_debug_un. If sd_debug_un is set 2551 * to NULL, then messages for all instances are printed. 2552 * 2553 * These routines have been cloned from each other due to the language 2554 * constraints of macros and variable argument list processing. 2555 */ 2556 2557 2558 /* 2559 * Function: sd_log_err 2560 * 2561 * Description: This routine is called by the SD_ERROR macro for debug 2562 * logging of error conditions. 2563 * 2564 * Arguments: comp - driver component being logged 2565 * dev - pointer to driver info structure 2566 * fmt - error string and format to be logged 2567 */ 2568 2569 static void 2570 sd_log_err(uint_t comp, struct sd_lun *un, const char *fmt, ...) 2571 { 2572 va_list ap; 2573 dev_info_t *dev; 2574 2575 ASSERT(un != NULL); 2576 dev = SD_DEVINFO(un); 2577 ASSERT(dev != NULL); 2578 2579 /* 2580 * Filter messages based on the global component and level masks. 2581 * Also print if un matches the value of sd_debug_un, or if 2582 * sd_debug_un is set to NULL. 2583 */ 2584 if ((sd_component_mask & comp) && (sd_level_mask & SD_LOGMASK_ERROR) && 2585 ((sd_debug_un == NULL) || (sd_debug_un == un))) { 2586 mutex_enter(&sd_log_mutex); 2587 va_start(ap, fmt); 2588 (void) vsprintf(sd_log_buf, fmt, ap); 2589 va_end(ap); 2590 scsi_log(dev, sd_label, CE_CONT, "%s", sd_log_buf); 2591 mutex_exit(&sd_log_mutex); 2592 } 2593 #ifdef SD_FAULT_INJECTION 2594 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::sd_injection_mask)); 2595 if (un->sd_injection_mask & comp) { 2596 mutex_enter(&sd_log_mutex); 2597 va_start(ap, fmt); 2598 (void) vsprintf(sd_log_buf, fmt, ap); 2599 va_end(ap); 2600 sd_injection_log(sd_log_buf, un); 2601 mutex_exit(&sd_log_mutex); 2602 } 2603 #endif 2604 } 2605 2606 2607 /* 2608 * Function: sd_log_info 2609 * 2610 * Description: This routine is called by the SD_INFO macro for debug 2611 * logging of general purpose informational conditions. 2612 * 2613 * Arguments: comp - driver component being logged 2614 * dev - pointer to driver info structure 2615 * fmt - info string and format to be logged 2616 */ 2617 2618 static void 2619 sd_log_info(uint_t component, struct sd_lun *un, const char *fmt, ...) 2620 { 2621 va_list ap; 2622 dev_info_t *dev; 2623 2624 ASSERT(un != NULL); 2625 dev = SD_DEVINFO(un); 2626 ASSERT(dev != NULL); 2627 2628 /* 2629 * Filter messages based on the global component and level masks. 2630 * Also print if un matches the value of sd_debug_un, or if 2631 * sd_debug_un is set to NULL. 2632 */ 2633 if ((sd_component_mask & component) && 2634 (sd_level_mask & SD_LOGMASK_INFO) && 2635 ((sd_debug_un == NULL) || (sd_debug_un == un))) { 2636 mutex_enter(&sd_log_mutex); 2637 va_start(ap, fmt); 2638 (void) vsprintf(sd_log_buf, fmt, ap); 2639 va_end(ap); 2640 scsi_log(dev, sd_label, CE_CONT, "%s", sd_log_buf); 2641 mutex_exit(&sd_log_mutex); 2642 } 2643 #ifdef SD_FAULT_INJECTION 2644 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::sd_injection_mask)); 2645 if (un->sd_injection_mask & component) { 2646 mutex_enter(&sd_log_mutex); 2647 va_start(ap, fmt); 2648 (void) vsprintf(sd_log_buf, fmt, ap); 2649 va_end(ap); 2650 sd_injection_log(sd_log_buf, un); 2651 mutex_exit(&sd_log_mutex); 2652 } 2653 #endif 2654 } 2655 2656 2657 /* 2658 * Function: sd_log_trace 2659 * 2660 * Description: This routine is called by the SD_TRACE macro for debug 2661 * logging of trace conditions (i.e. function entry/exit). 2662 * 2663 * Arguments: comp - driver component being logged 2664 * dev - pointer to driver info structure 2665 * fmt - trace string and format to be logged 2666 */ 2667 2668 static void 2669 sd_log_trace(uint_t component, struct sd_lun *un, const char *fmt, ...) 2670 { 2671 va_list ap; 2672 dev_info_t *dev; 2673 2674 ASSERT(un != NULL); 2675 dev = SD_DEVINFO(un); 2676 ASSERT(dev != NULL); 2677 2678 /* 2679 * Filter messages based on the global component and level masks. 2680 * Also print if un matches the value of sd_debug_un, or if 2681 * sd_debug_un is set to NULL. 2682 */ 2683 if ((sd_component_mask & component) && 2684 (sd_level_mask & SD_LOGMASK_TRACE) && 2685 ((sd_debug_un == NULL) || (sd_debug_un == un))) { 2686 mutex_enter(&sd_log_mutex); 2687 va_start(ap, fmt); 2688 (void) vsprintf(sd_log_buf, fmt, ap); 2689 va_end(ap); 2690 scsi_log(dev, sd_label, CE_CONT, "%s", sd_log_buf); 2691 mutex_exit(&sd_log_mutex); 2692 } 2693 #ifdef SD_FAULT_INJECTION 2694 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::sd_injection_mask)); 2695 if (un->sd_injection_mask & component) { 2696 mutex_enter(&sd_log_mutex); 2697 va_start(ap, fmt); 2698 (void) vsprintf(sd_log_buf, fmt, ap); 2699 va_end(ap); 2700 sd_injection_log(sd_log_buf, un); 2701 mutex_exit(&sd_log_mutex); 2702 } 2703 #endif 2704 } 2705 2706 2707 /* 2708 * Function: sdprobe 2709 * 2710 * Description: This is the driver probe(9e) entry point function. 2711 * 2712 * Arguments: devi - opaque device info handle 2713 * 2714 * Return Code: DDI_PROBE_SUCCESS: If the probe was successful. 2715 * DDI_PROBE_FAILURE: If the probe failed. 2716 * DDI_PROBE_PARTIAL: If the instance is not present now, 2717 * but may be present in the future. 2718 */ 2719 2720 static int 2721 sdprobe(dev_info_t *devi) 2722 { 2723 struct scsi_device *devp; 2724 int rval; 2725 #ifndef XPV_HVM_DRIVER 2726 int instance = ddi_get_instance(devi); 2727 #endif /* !XPV_HVM_DRIVER */ 2728 2729 /* 2730 * if it wasn't for pln, sdprobe could actually be nulldev 2731 * in the "__fibre" case. 2732 */ 2733 if (ddi_dev_is_sid(devi) == DDI_SUCCESS) { 2734 return (DDI_PROBE_DONTCARE); 2735 } 2736 2737 devp = ddi_get_driver_private(devi); 2738 2739 if (devp == NULL) { 2740 /* Ooops... nexus driver is mis-configured... */ 2741 return (DDI_PROBE_FAILURE); 2742 } 2743 2744 #ifndef XPV_HVM_DRIVER 2745 if (ddi_get_soft_state(sd_state, instance) != NULL) { 2746 return (DDI_PROBE_PARTIAL); 2747 } 2748 #endif /* !XPV_HVM_DRIVER */ 2749 2750 /* 2751 * Call the SCSA utility probe routine to see if we actually 2752 * have a target at this SCSI nexus. 2753 */ 2754 switch (sd_scsi_probe_with_cache(devp, NULL_FUNC)) { 2755 case SCSIPROBE_EXISTS: 2756 switch (devp->sd_inq->inq_dtype) { 2757 case DTYPE_DIRECT: 2758 rval = DDI_PROBE_SUCCESS; 2759 break; 2760 case DTYPE_RODIRECT: 2761 /* CDs etc. Can be removable media */ 2762 rval = DDI_PROBE_SUCCESS; 2763 break; 2764 case DTYPE_OPTICAL: 2765 /* 2766 * Rewritable optical driver HP115AA 2767 * Can also be removable media 2768 */ 2769 2770 /* 2771 * Do not attempt to bind to DTYPE_OPTICAL if 2772 * pre solaris 9 sparc sd behavior is required 2773 * 2774 * If first time through and sd_dtype_optical_bind 2775 * has not been set in /etc/system check properties 2776 */ 2777 2778 if (sd_dtype_optical_bind < 0) { 2779 sd_dtype_optical_bind = ddi_prop_get_int 2780 (DDI_DEV_T_ANY, devi, 0, 2781 "optical-device-bind", 1); 2782 } 2783 2784 if (sd_dtype_optical_bind == 0) { 2785 rval = DDI_PROBE_FAILURE; 2786 } else { 2787 rval = DDI_PROBE_SUCCESS; 2788 } 2789 break; 2790 2791 case DTYPE_NOTPRESENT: 2792 default: 2793 rval = DDI_PROBE_FAILURE; 2794 break; 2795 } 2796 break; 2797 default: 2798 rval = DDI_PROBE_PARTIAL; 2799 break; 2800 } 2801 2802 /* 2803 * This routine checks for resource allocation prior to freeing, 2804 * so it will take care of the "smart probing" case where a 2805 * scsi_probe() may or may not have been issued and will *not* 2806 * free previously-freed resources. 2807 */ 2808 scsi_unprobe(devp); 2809 return (rval); 2810 } 2811 2812 2813 /* 2814 * Function: sdinfo 2815 * 2816 * Description: This is the driver getinfo(9e) entry point function. 2817 * Given the device number, return the devinfo pointer from 2818 * the scsi_device structure or the instance number 2819 * associated with the dev_t. 2820 * 2821 * Arguments: dip - pointer to device info structure 2822 * infocmd - command argument (DDI_INFO_DEVT2DEVINFO, 2823 * DDI_INFO_DEVT2INSTANCE) 2824 * arg - driver dev_t 2825 * resultp - user buffer for request response 2826 * 2827 * Return Code: DDI_SUCCESS 2828 * DDI_FAILURE 2829 */ 2830 /* ARGSUSED */ 2831 static int 2832 sdinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 2833 { 2834 struct sd_lun *un; 2835 dev_t dev; 2836 int instance; 2837 int error; 2838 2839 switch (infocmd) { 2840 case DDI_INFO_DEVT2DEVINFO: 2841 dev = (dev_t)arg; 2842 instance = SDUNIT(dev); 2843 if ((un = ddi_get_soft_state(sd_state, instance)) == NULL) { 2844 return (DDI_FAILURE); 2845 } 2846 *result = (void *) SD_DEVINFO(un); 2847 error = DDI_SUCCESS; 2848 break; 2849 case DDI_INFO_DEVT2INSTANCE: 2850 dev = (dev_t)arg; 2851 instance = SDUNIT(dev); 2852 *result = (void *)(uintptr_t)instance; 2853 error = DDI_SUCCESS; 2854 break; 2855 default: 2856 error = DDI_FAILURE; 2857 } 2858 return (error); 2859 } 2860 2861 /* 2862 * Function: sd_prop_op 2863 * 2864 * Description: This is the driver prop_op(9e) entry point function. 2865 * Return the number of blocks for the partition in question 2866 * or forward the request to the property facilities. 2867 * 2868 * Arguments: dev - device number 2869 * dip - pointer to device info structure 2870 * prop_op - property operator 2871 * mod_flags - DDI_PROP_DONTPASS, don't pass to parent 2872 * name - pointer to property name 2873 * valuep - pointer or address of the user buffer 2874 * lengthp - property length 2875 * 2876 * Return Code: DDI_PROP_SUCCESS 2877 * DDI_PROP_NOT_FOUND 2878 * DDI_PROP_UNDEFINED 2879 * DDI_PROP_NO_MEMORY 2880 * DDI_PROP_BUF_TOO_SMALL 2881 */ 2882 2883 static int 2884 sd_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags, 2885 char *name, caddr_t valuep, int *lengthp) 2886 { 2887 struct sd_lun *un; 2888 2889 if ((un = ddi_get_soft_state(sd_state, ddi_get_instance(dip))) == NULL) 2890 return (ddi_prop_op(dev, dip, prop_op, mod_flags, 2891 name, valuep, lengthp)); 2892 2893 return (cmlb_prop_op(un->un_cmlbhandle, 2894 dev, dip, prop_op, mod_flags, name, valuep, lengthp, 2895 SDPART(dev), (void *)SD_PATH_DIRECT)); 2896 } 2897 2898 /* 2899 * The following functions are for smart probing: 2900 * sd_scsi_probe_cache_init() 2901 * sd_scsi_probe_cache_fini() 2902 * sd_scsi_clear_probe_cache() 2903 * sd_scsi_probe_with_cache() 2904 */ 2905 2906 /* 2907 * Function: sd_scsi_probe_cache_init 2908 * 2909 * Description: Initializes the probe response cache mutex and head pointer. 2910 * 2911 * Context: Kernel thread context 2912 */ 2913 2914 static void 2915 sd_scsi_probe_cache_init(void) 2916 { 2917 mutex_init(&sd_scsi_probe_cache_mutex, NULL, MUTEX_DRIVER, NULL); 2918 sd_scsi_probe_cache_head = NULL; 2919 } 2920 2921 2922 /* 2923 * Function: sd_scsi_probe_cache_fini 2924 * 2925 * Description: Frees all resources associated with the probe response cache. 2926 * 2927 * Context: Kernel thread context 2928 */ 2929 2930 static void 2931 sd_scsi_probe_cache_fini(void) 2932 { 2933 struct sd_scsi_probe_cache *cp; 2934 struct sd_scsi_probe_cache *ncp; 2935 2936 /* Clean up our smart probing linked list */ 2937 for (cp = sd_scsi_probe_cache_head; cp != NULL; cp = ncp) { 2938 ncp = cp->next; 2939 kmem_free(cp, sizeof (struct sd_scsi_probe_cache)); 2940 } 2941 sd_scsi_probe_cache_head = NULL; 2942 mutex_destroy(&sd_scsi_probe_cache_mutex); 2943 } 2944 2945 2946 /* 2947 * Function: sd_scsi_clear_probe_cache 2948 * 2949 * Description: This routine clears the probe response cache. This is 2950 * done when open() returns ENXIO so that when deferred 2951 * attach is attempted (possibly after a device has been 2952 * turned on) we will retry the probe. Since we don't know 2953 * which target we failed to open, we just clear the 2954 * entire cache. 2955 * 2956 * Context: Kernel thread context 2957 */ 2958 2959 static void 2960 sd_scsi_clear_probe_cache(void) 2961 { 2962 struct sd_scsi_probe_cache *cp; 2963 int i; 2964 2965 mutex_enter(&sd_scsi_probe_cache_mutex); 2966 for (cp = sd_scsi_probe_cache_head; cp != NULL; cp = cp->next) { 2967 /* 2968 * Reset all entries to SCSIPROBE_EXISTS. This will 2969 * force probing to be performed the next time 2970 * sd_scsi_probe_with_cache is called. 2971 */ 2972 for (i = 0; i < NTARGETS_WIDE; i++) { 2973 cp->cache[i] = SCSIPROBE_EXISTS; 2974 } 2975 } 2976 mutex_exit(&sd_scsi_probe_cache_mutex); 2977 } 2978 2979 2980 /* 2981 * Function: sd_scsi_probe_with_cache 2982 * 2983 * Description: This routine implements support for a scsi device probe 2984 * with cache. The driver maintains a cache of the target 2985 * responses to scsi probes. If we get no response from a 2986 * target during a probe inquiry, we remember that, and we 2987 * avoid additional calls to scsi_probe on non-zero LUNs 2988 * on the same target until the cache is cleared. By doing 2989 * so we avoid the 1/4 sec selection timeout for nonzero 2990 * LUNs. lun0 of a target is always probed. 2991 * 2992 * Arguments: devp - Pointer to a scsi_device(9S) structure 2993 * waitfunc - indicates what the allocator routines should 2994 * do when resources are not available. This value 2995 * is passed on to scsi_probe() when that routine 2996 * is called. 2997 * 2998 * Return Code: SCSIPROBE_NORESP if a NORESP in probe response cache; 2999 * otherwise the value returned by scsi_probe(9F). 3000 * 3001 * Context: Kernel thread context 3002 */ 3003 3004 static int 3005 sd_scsi_probe_with_cache(struct scsi_device *devp, int (*waitfn)()) 3006 { 3007 struct sd_scsi_probe_cache *cp; 3008 dev_info_t *pdip = ddi_get_parent(devp->sd_dev); 3009 int lun, tgt; 3010 3011 lun = ddi_prop_get_int(DDI_DEV_T_ANY, devp->sd_dev, DDI_PROP_DONTPASS, 3012 SCSI_ADDR_PROP_LUN, 0); 3013 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, devp->sd_dev, DDI_PROP_DONTPASS, 3014 SCSI_ADDR_PROP_TARGET, -1); 3015 3016 /* Make sure caching enabled and target in range */ 3017 if ((tgt < 0) || (tgt >= NTARGETS_WIDE)) { 3018 /* do it the old way (no cache) */ 3019 return (scsi_probe(devp, waitfn)); 3020 } 3021 3022 mutex_enter(&sd_scsi_probe_cache_mutex); 3023 3024 /* Find the cache for this scsi bus instance */ 3025 for (cp = sd_scsi_probe_cache_head; cp != NULL; cp = cp->next) { 3026 if (cp->pdip == pdip) { 3027 break; 3028 } 3029 } 3030 3031 /* If we can't find a cache for this pdip, create one */ 3032 if (cp == NULL) { 3033 int i; 3034 3035 cp = kmem_zalloc(sizeof (struct sd_scsi_probe_cache), 3036 KM_SLEEP); 3037 cp->pdip = pdip; 3038 cp->next = sd_scsi_probe_cache_head; 3039 sd_scsi_probe_cache_head = cp; 3040 for (i = 0; i < NTARGETS_WIDE; i++) { 3041 cp->cache[i] = SCSIPROBE_EXISTS; 3042 } 3043 } 3044 3045 mutex_exit(&sd_scsi_probe_cache_mutex); 3046 3047 /* Recompute the cache for this target if LUN zero */ 3048 if (lun == 0) { 3049 cp->cache[tgt] = SCSIPROBE_EXISTS; 3050 } 3051 3052 /* Don't probe if cache remembers a NORESP from a previous LUN. */ 3053 if (cp->cache[tgt] != SCSIPROBE_EXISTS) { 3054 return (SCSIPROBE_NORESP); 3055 } 3056 3057 /* Do the actual probe; save & return the result */ 3058 return (cp->cache[tgt] = scsi_probe(devp, waitfn)); 3059 } 3060 3061 3062 /* 3063 * Function: sd_scsi_target_lun_init 3064 * 3065 * Description: Initializes the attached lun chain mutex and head pointer. 3066 * 3067 * Context: Kernel thread context 3068 */ 3069 3070 static void 3071 sd_scsi_target_lun_init(void) 3072 { 3073 mutex_init(&sd_scsi_target_lun_mutex, NULL, MUTEX_DRIVER, NULL); 3074 sd_scsi_target_lun_head = NULL; 3075 } 3076 3077 3078 /* 3079 * Function: sd_scsi_target_lun_fini 3080 * 3081 * Description: Frees all resources associated with the attached lun 3082 * chain 3083 * 3084 * Context: Kernel thread context 3085 */ 3086 3087 static void 3088 sd_scsi_target_lun_fini(void) 3089 { 3090 struct sd_scsi_hba_tgt_lun *cp; 3091 struct sd_scsi_hba_tgt_lun *ncp; 3092 3093 for (cp = sd_scsi_target_lun_head; cp != NULL; cp = ncp) { 3094 ncp = cp->next; 3095 kmem_free(cp, sizeof (struct sd_scsi_hba_tgt_lun)); 3096 } 3097 sd_scsi_target_lun_head = NULL; 3098 mutex_destroy(&sd_scsi_target_lun_mutex); 3099 } 3100 3101 3102 /* 3103 * Function: sd_scsi_get_target_lun_count 3104 * 3105 * Description: This routine will check in the attached lun chain to see 3106 * how many luns are attached on the required SCSI controller 3107 * and target. Currently, some capabilities like tagged queue 3108 * are supported per target based by HBA. So all luns in a 3109 * target have the same capabilities. Based on this assumption, 3110 * sd should only set these capabilities once per target. This 3111 * function is called when sd needs to decide how many luns 3112 * already attached on a target. 3113 * 3114 * Arguments: dip - Pointer to the system's dev_info_t for the SCSI 3115 * controller device. 3116 * target - The target ID on the controller's SCSI bus. 3117 * 3118 * Return Code: The number of luns attached on the required target and 3119 * controller. 3120 * -1 if target ID is not in parallel SCSI scope or the given 3121 * dip is not in the chain. 3122 * 3123 * Context: Kernel thread context 3124 */ 3125 3126 static int 3127 sd_scsi_get_target_lun_count(dev_info_t *dip, int target) 3128 { 3129 struct sd_scsi_hba_tgt_lun *cp; 3130 3131 if ((target < 0) || (target >= NTARGETS_WIDE)) { 3132 return (-1); 3133 } 3134 3135 mutex_enter(&sd_scsi_target_lun_mutex); 3136 3137 for (cp = sd_scsi_target_lun_head; cp != NULL; cp = cp->next) { 3138 if (cp->pdip == dip) { 3139 break; 3140 } 3141 } 3142 3143 mutex_exit(&sd_scsi_target_lun_mutex); 3144 3145 if (cp == NULL) { 3146 return (-1); 3147 } 3148 3149 return (cp->nlun[target]); 3150 } 3151 3152 3153 /* 3154 * Function: sd_scsi_update_lun_on_target 3155 * 3156 * Description: This routine is used to update the attached lun chain when a 3157 * lun is attached or detached on a target. 3158 * 3159 * Arguments: dip - Pointer to the system's dev_info_t for the SCSI 3160 * controller device. 3161 * target - The target ID on the controller's SCSI bus. 3162 * flag - Indicate the lun is attached or detached. 3163 * 3164 * Context: Kernel thread context 3165 */ 3166 3167 static void 3168 sd_scsi_update_lun_on_target(dev_info_t *dip, int target, int flag) 3169 { 3170 struct sd_scsi_hba_tgt_lun *cp; 3171 3172 mutex_enter(&sd_scsi_target_lun_mutex); 3173 3174 for (cp = sd_scsi_target_lun_head; cp != NULL; cp = cp->next) { 3175 if (cp->pdip == dip) { 3176 break; 3177 } 3178 } 3179 3180 if ((cp == NULL) && (flag == SD_SCSI_LUN_ATTACH)) { 3181 cp = kmem_zalloc(sizeof (struct sd_scsi_hba_tgt_lun), 3182 KM_SLEEP); 3183 cp->pdip = dip; 3184 cp->next = sd_scsi_target_lun_head; 3185 sd_scsi_target_lun_head = cp; 3186 } 3187 3188 mutex_exit(&sd_scsi_target_lun_mutex); 3189 3190 if (cp != NULL) { 3191 if (flag == SD_SCSI_LUN_ATTACH) { 3192 cp->nlun[target] ++; 3193 } else { 3194 cp->nlun[target] --; 3195 } 3196 } 3197 } 3198 3199 3200 /* 3201 * Function: sd_spin_up_unit 3202 * 3203 * Description: Issues the following commands to spin-up the device: 3204 * START STOP UNIT, and INQUIRY. 3205 * 3206 * Arguments: ssc - ssc contains pointer to driver soft state (unit) 3207 * structure for this target. 3208 * 3209 * Return Code: 0 - success 3210 * EIO - failure 3211 * EACCES - reservation conflict 3212 * 3213 * Context: Kernel thread context 3214 */ 3215 3216 static int 3217 sd_spin_up_unit(sd_ssc_t *ssc) 3218 { 3219 size_t resid = 0; 3220 int has_conflict = FALSE; 3221 uchar_t *bufaddr; 3222 int status; 3223 struct sd_lun *un; 3224 3225 ASSERT(ssc != NULL); 3226 un = ssc->ssc_un; 3227 ASSERT(un != NULL); 3228 3229 /* 3230 * Send a throwaway START UNIT command. 3231 * 3232 * If we fail on this, we don't care presently what precisely 3233 * is wrong. EMC's arrays will also fail this with a check 3234 * condition (0x2/0x4/0x3) if the device is "inactive," but 3235 * we don't want to fail the attach because it may become 3236 * "active" later. 3237 * We don't know if power condition is supported or not at 3238 * this stage, use START STOP bit. 3239 */ 3240 status = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP, 3241 SD_TARGET_START, SD_PATH_DIRECT); 3242 3243 if (status != 0) { 3244 if (status == EACCES) 3245 has_conflict = TRUE; 3246 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 3247 } 3248 3249 /* 3250 * Send another INQUIRY command to the target. This is necessary for 3251 * non-removable media direct access devices because their INQUIRY data 3252 * may not be fully qualified until they are spun up (perhaps via the 3253 * START command above). Note: This seems to be needed for some 3254 * legacy devices only.) The INQUIRY command should succeed even if a 3255 * Reservation Conflict is present. 3256 */ 3257 bufaddr = kmem_zalloc(SUN_INQSIZE, KM_SLEEP); 3258 3259 if (sd_send_scsi_INQUIRY(ssc, bufaddr, SUN_INQSIZE, 0, 0, &resid) 3260 != 0) { 3261 kmem_free(bufaddr, SUN_INQSIZE); 3262 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK); 3263 return (EIO); 3264 } 3265 3266 /* 3267 * If we got enough INQUIRY data, copy it over the old INQUIRY data. 3268 * Note that this routine does not return a failure here even if the 3269 * INQUIRY command did not return any data. This is a legacy behavior. 3270 */ 3271 if ((SUN_INQSIZE - resid) >= SUN_MIN_INQLEN) { 3272 bcopy(bufaddr, SD_INQUIRY(un), SUN_INQSIZE); 3273 } 3274 3275 kmem_free(bufaddr, SUN_INQSIZE); 3276 3277 /* If we hit a reservation conflict above, tell the caller. */ 3278 if (has_conflict == TRUE) { 3279 return (EACCES); 3280 } 3281 3282 return (0); 3283 } 3284 3285 #ifdef _LP64 3286 /* 3287 * Function: sd_enable_descr_sense 3288 * 3289 * Description: This routine attempts to select descriptor sense format 3290 * using the Control mode page. Devices that support 64 bit 3291 * LBAs (for >2TB luns) should also implement descriptor 3292 * sense data so we will call this function whenever we see 3293 * a lun larger than 2TB. If for some reason the device 3294 * supports 64 bit LBAs but doesn't support descriptor sense 3295 * presumably the mode select will fail. Everything will 3296 * continue to work normally except that we will not get 3297 * complete sense data for commands that fail with an LBA 3298 * larger than 32 bits. 3299 * 3300 * Arguments: ssc - ssc contains pointer to driver soft state (unit) 3301 * structure for this target. 3302 * 3303 * Context: Kernel thread context only 3304 */ 3305 3306 static void 3307 sd_enable_descr_sense(sd_ssc_t *ssc) 3308 { 3309 uchar_t *header; 3310 struct mode_control_scsi3 *ctrl_bufp; 3311 size_t buflen; 3312 size_t bd_len; 3313 int status; 3314 struct sd_lun *un; 3315 3316 ASSERT(ssc != NULL); 3317 un = ssc->ssc_un; 3318 ASSERT(un != NULL); 3319 3320 /* 3321 * Read MODE SENSE page 0xA, Control Mode Page 3322 */ 3323 buflen = MODE_HEADER_LENGTH + MODE_BLK_DESC_LENGTH + 3324 sizeof (struct mode_control_scsi3); 3325 header = kmem_zalloc(buflen, KM_SLEEP); 3326 3327 status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, header, buflen, 3328 MODEPAGE_CTRL_MODE, SD_PATH_DIRECT); 3329 3330 if (status != 0) { 3331 SD_ERROR(SD_LOG_COMMON, un, 3332 "sd_enable_descr_sense: mode sense ctrl page failed\n"); 3333 goto eds_exit; 3334 } 3335 3336 /* 3337 * Determine size of Block Descriptors in order to locate 3338 * the mode page data. ATAPI devices return 0, SCSI devices 3339 * should return MODE_BLK_DESC_LENGTH. 3340 */ 3341 bd_len = ((struct mode_header *)header)->bdesc_length; 3342 3343 /* Clear the mode data length field for MODE SELECT */ 3344 ((struct mode_header *)header)->length = 0; 3345 3346 ctrl_bufp = (struct mode_control_scsi3 *) 3347 (header + MODE_HEADER_LENGTH + bd_len); 3348 3349 /* 3350 * If the page length is smaller than the expected value, 3351 * the target device doesn't support D_SENSE. Bail out here. 3352 */ 3353 if (ctrl_bufp->mode_page.length < 3354 sizeof (struct mode_control_scsi3) - 2) { 3355 SD_ERROR(SD_LOG_COMMON, un, 3356 "sd_enable_descr_sense: enable D_SENSE failed\n"); 3357 goto eds_exit; 3358 } 3359 3360 /* 3361 * Clear PS bit for MODE SELECT 3362 */ 3363 ctrl_bufp->mode_page.ps = 0; 3364 3365 /* 3366 * Set D_SENSE to enable descriptor sense format. 3367 */ 3368 ctrl_bufp->d_sense = 1; 3369 3370 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 3371 3372 /* 3373 * Use MODE SELECT to commit the change to the D_SENSE bit 3374 */ 3375 status = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, header, 3376 buflen, SD_DONTSAVE_PAGE, SD_PATH_DIRECT); 3377 3378 if (status != 0) { 3379 SD_INFO(SD_LOG_COMMON, un, 3380 "sd_enable_descr_sense: mode select ctrl page failed\n"); 3381 } else { 3382 kmem_free(header, buflen); 3383 return; 3384 } 3385 3386 eds_exit: 3387 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 3388 kmem_free(header, buflen); 3389 } 3390 3391 /* 3392 * Function: sd_reenable_dsense_task 3393 * 3394 * Description: Re-enable descriptor sense after device or bus reset 3395 * 3396 * Context: Executes in a taskq() thread context 3397 */ 3398 static void 3399 sd_reenable_dsense_task(void *arg) 3400 { 3401 struct sd_lun *un = arg; 3402 sd_ssc_t *ssc; 3403 3404 ASSERT(un != NULL); 3405 3406 ssc = sd_ssc_init(un); 3407 sd_enable_descr_sense(ssc); 3408 sd_ssc_fini(ssc); 3409 } 3410 #endif /* _LP64 */ 3411 3412 /* 3413 * Function: sd_set_mmc_caps 3414 * 3415 * Description: This routine determines if the device is MMC compliant and if 3416 * the device supports CDDA via a mode sense of the CDVD 3417 * capabilities mode page. Also checks if the device is a 3418 * dvdram writable device. 3419 * 3420 * Arguments: ssc - ssc contains pointer to driver soft state (unit) 3421 * structure for this target. 3422 * 3423 * Context: Kernel thread context only 3424 */ 3425 3426 static void 3427 sd_set_mmc_caps(sd_ssc_t *ssc) 3428 { 3429 struct mode_header_grp2 *sense_mhp; 3430 uchar_t *sense_page; 3431 caddr_t buf; 3432 int bd_len; 3433 int status; 3434 struct uscsi_cmd com; 3435 int rtn; 3436 uchar_t *out_data_rw, *out_data_hd; 3437 uchar_t *rqbuf_rw, *rqbuf_hd; 3438 uchar_t *out_data_gesn; 3439 int gesn_len; 3440 struct sd_lun *un; 3441 3442 ASSERT(ssc != NULL); 3443 un = ssc->ssc_un; 3444 ASSERT(un != NULL); 3445 3446 /* 3447 * The flags which will be set in this function are - mmc compliant, 3448 * dvdram writable device, cdda support. Initialize them to FALSE 3449 * and if a capability is detected - it will be set to TRUE. 3450 */ 3451 un->un_f_mmc_cap = FALSE; 3452 un->un_f_dvdram_writable_device = FALSE; 3453 un->un_f_cfg_cdda = FALSE; 3454 3455 buf = kmem_zalloc(BUFLEN_MODE_CDROM_CAP, KM_SLEEP); 3456 status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, (uchar_t *)buf, 3457 BUFLEN_MODE_CDROM_CAP, MODEPAGE_CDROM_CAP, SD_PATH_DIRECT); 3458 3459 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 3460 3461 if (status != 0) { 3462 /* command failed; just return */ 3463 kmem_free(buf, BUFLEN_MODE_CDROM_CAP); 3464 return; 3465 } 3466 /* 3467 * If the mode sense request for the CDROM CAPABILITIES 3468 * page (0x2A) succeeds the device is assumed to be MMC. 3469 */ 3470 un->un_f_mmc_cap = TRUE; 3471 3472 /* See if GET STATUS EVENT NOTIFICATION is supported */ 3473 if (un->un_f_mmc_gesn_polling) { 3474 gesn_len = SD_GESN_HEADER_LEN + SD_GESN_MEDIA_DATA_LEN; 3475 out_data_gesn = kmem_zalloc(gesn_len, KM_SLEEP); 3476 3477 rtn = sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION(ssc, 3478 out_data_gesn, gesn_len, 1 << SD_GESN_MEDIA_CLASS); 3479 3480 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 3481 3482 if ((rtn != 0) || !sd_gesn_media_data_valid(out_data_gesn)) { 3483 un->un_f_mmc_gesn_polling = FALSE; 3484 SD_INFO(SD_LOG_ATTACH_DETACH, un, 3485 "sd_set_mmc_caps: gesn not supported " 3486 "%d %x %x %x %x\n", rtn, 3487 out_data_gesn[0], out_data_gesn[1], 3488 out_data_gesn[2], out_data_gesn[3]); 3489 } 3490 3491 kmem_free(out_data_gesn, gesn_len); 3492 } 3493 3494 /* Get to the page data */ 3495 sense_mhp = (struct mode_header_grp2 *)buf; 3496 bd_len = (sense_mhp->bdesc_length_hi << 8) | 3497 sense_mhp->bdesc_length_lo; 3498 if (bd_len > MODE_BLK_DESC_LENGTH) { 3499 /* 3500 * We did not get back the expected block descriptor 3501 * length so we cannot determine if the device supports 3502 * CDDA. However, we still indicate the device is MMC 3503 * according to the successful response to the page 3504 * 0x2A mode sense request. 3505 */ 3506 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 3507 "sd_set_mmc_caps: Mode Sense returned " 3508 "invalid block descriptor length\n"); 3509 kmem_free(buf, BUFLEN_MODE_CDROM_CAP); 3510 return; 3511 } 3512 3513 /* See if read CDDA is supported */ 3514 sense_page = (uchar_t *)(buf + MODE_HEADER_LENGTH_GRP2 + 3515 bd_len); 3516 un->un_f_cfg_cdda = (sense_page[5] & 0x01) ? TRUE : FALSE; 3517 3518 /* See if writing DVD RAM is supported. */ 3519 un->un_f_dvdram_writable_device = (sense_page[3] & 0x20) ? TRUE : FALSE; 3520 if (un->un_f_dvdram_writable_device == TRUE) { 3521 kmem_free(buf, BUFLEN_MODE_CDROM_CAP); 3522 return; 3523 } 3524 3525 /* 3526 * If the device presents DVD or CD capabilities in the mode 3527 * page, we can return here since a RRD will not have 3528 * these capabilities. 3529 */ 3530 if ((sense_page[2] & 0x3f) || (sense_page[3] & 0x3f)) { 3531 kmem_free(buf, BUFLEN_MODE_CDROM_CAP); 3532 return; 3533 } 3534 kmem_free(buf, BUFLEN_MODE_CDROM_CAP); 3535 3536 /* 3537 * If un->un_f_dvdram_writable_device is still FALSE, 3538 * check for a Removable Rigid Disk (RRD). A RRD 3539 * device is identified by the features RANDOM_WRITABLE and 3540 * HARDWARE_DEFECT_MANAGEMENT. 3541 */ 3542 out_data_rw = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP); 3543 rqbuf_rw = kmem_zalloc(SENSE_LENGTH, KM_SLEEP); 3544 3545 rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_rw, 3546 SENSE_LENGTH, out_data_rw, SD_CURRENT_FEATURE_LEN, 3547 RANDOM_WRITABLE, SD_PATH_STANDARD); 3548 3549 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 3550 3551 if (rtn != 0) { 3552 kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN); 3553 kmem_free(rqbuf_rw, SENSE_LENGTH); 3554 return; 3555 } 3556 3557 out_data_hd = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP); 3558 rqbuf_hd = kmem_zalloc(SENSE_LENGTH, KM_SLEEP); 3559 3560 rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_hd, 3561 SENSE_LENGTH, out_data_hd, SD_CURRENT_FEATURE_LEN, 3562 HARDWARE_DEFECT_MANAGEMENT, SD_PATH_STANDARD); 3563 3564 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 3565 3566 if (rtn == 0) { 3567 /* 3568 * We have good information, check for random writable 3569 * and hardware defect features. 3570 */ 3571 if ((out_data_rw[9] & RANDOM_WRITABLE) && 3572 (out_data_hd[9] & HARDWARE_DEFECT_MANAGEMENT)) { 3573 un->un_f_dvdram_writable_device = TRUE; 3574 } 3575 } 3576 3577 kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN); 3578 kmem_free(rqbuf_rw, SENSE_LENGTH); 3579 kmem_free(out_data_hd, SD_CURRENT_FEATURE_LEN); 3580 kmem_free(rqbuf_hd, SENSE_LENGTH); 3581 } 3582 3583 /* 3584 * Function: sd_check_for_writable_cd 3585 * 3586 * Description: This routine determines if the media in the device is 3587 * writable or not. It uses the get configuration command (0x46) 3588 * to determine if the media is writable 3589 * 3590 * Arguments: un - driver soft state (unit) structure 3591 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" 3592 * chain and the normal command waitq, or 3593 * SD_PATH_DIRECT_PRIORITY to use the USCSI 3594 * "direct" chain and bypass the normal command 3595 * waitq. 3596 * 3597 * Context: Never called at interrupt context. 3598 */ 3599 3600 static void 3601 sd_check_for_writable_cd(sd_ssc_t *ssc, int path_flag) 3602 { 3603 struct uscsi_cmd com; 3604 uchar_t *out_data; 3605 uchar_t *rqbuf; 3606 int rtn; 3607 uchar_t *out_data_rw, *out_data_hd; 3608 uchar_t *rqbuf_rw, *rqbuf_hd; 3609 struct mode_header_grp2 *sense_mhp; 3610 uchar_t *sense_page; 3611 caddr_t buf; 3612 int bd_len; 3613 int status; 3614 struct sd_lun *un; 3615 3616 ASSERT(ssc != NULL); 3617 un = ssc->ssc_un; 3618 ASSERT(un != NULL); 3619 ASSERT(mutex_owned(SD_MUTEX(un))); 3620 3621 /* 3622 * Initialize the writable media to false, if configuration info. 3623 * tells us otherwise then only we will set it. 3624 */ 3625 un->un_f_mmc_writable_media = FALSE; 3626 mutex_exit(SD_MUTEX(un)); 3627 3628 out_data = kmem_zalloc(SD_PROFILE_HEADER_LEN, KM_SLEEP); 3629 rqbuf = kmem_zalloc(SENSE_LENGTH, KM_SLEEP); 3630 3631 rtn = sd_send_scsi_GET_CONFIGURATION(ssc, &com, rqbuf, SENSE_LENGTH, 3632 out_data, SD_PROFILE_HEADER_LEN, path_flag); 3633 3634 if (rtn != 0) 3635 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 3636 3637 mutex_enter(SD_MUTEX(un)); 3638 if (rtn == 0) { 3639 /* 3640 * We have good information, check for writable DVD. 3641 */ 3642 if ((out_data[6] == 0) && (out_data[7] == 0x12)) { 3643 un->un_f_mmc_writable_media = TRUE; 3644 kmem_free(out_data, SD_PROFILE_HEADER_LEN); 3645 kmem_free(rqbuf, SENSE_LENGTH); 3646 return; 3647 } 3648 } 3649 3650 kmem_free(out_data, SD_PROFILE_HEADER_LEN); 3651 kmem_free(rqbuf, SENSE_LENGTH); 3652 3653 /* 3654 * Determine if this is a RRD type device. 3655 */ 3656 mutex_exit(SD_MUTEX(un)); 3657 buf = kmem_zalloc(BUFLEN_MODE_CDROM_CAP, KM_SLEEP); 3658 status = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, (uchar_t *)buf, 3659 BUFLEN_MODE_CDROM_CAP, MODEPAGE_CDROM_CAP, path_flag); 3660 3661 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 3662 3663 mutex_enter(SD_MUTEX(un)); 3664 if (status != 0) { 3665 /* command failed; just return */ 3666 kmem_free(buf, BUFLEN_MODE_CDROM_CAP); 3667 return; 3668 } 3669 3670 /* Get to the page data */ 3671 sense_mhp = (struct mode_header_grp2 *)buf; 3672 bd_len = (sense_mhp->bdesc_length_hi << 8) | sense_mhp->bdesc_length_lo; 3673 if (bd_len > MODE_BLK_DESC_LENGTH) { 3674 /* 3675 * We did not get back the expected block descriptor length so 3676 * we cannot check the mode page. 3677 */ 3678 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 3679 "sd_check_for_writable_cd: Mode Sense returned " 3680 "invalid block descriptor length\n"); 3681 kmem_free(buf, BUFLEN_MODE_CDROM_CAP); 3682 return; 3683 } 3684 3685 /* 3686 * If the device presents DVD or CD capabilities in the mode 3687 * page, we can return here since a RRD device will not have 3688 * these capabilities. 3689 */ 3690 sense_page = (uchar_t *)(buf + MODE_HEADER_LENGTH_GRP2 + bd_len); 3691 if ((sense_page[2] & 0x3f) || (sense_page[3] & 0x3f)) { 3692 kmem_free(buf, BUFLEN_MODE_CDROM_CAP); 3693 return; 3694 } 3695 kmem_free(buf, BUFLEN_MODE_CDROM_CAP); 3696 3697 /* 3698 * If un->un_f_mmc_writable_media is still FALSE, 3699 * check for RRD type media. A RRD device is identified 3700 * by the features RANDOM_WRITABLE and HARDWARE_DEFECT_MANAGEMENT. 3701 */ 3702 mutex_exit(SD_MUTEX(un)); 3703 out_data_rw = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP); 3704 rqbuf_rw = kmem_zalloc(SENSE_LENGTH, KM_SLEEP); 3705 3706 rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_rw, 3707 SENSE_LENGTH, out_data_rw, SD_CURRENT_FEATURE_LEN, 3708 RANDOM_WRITABLE, path_flag); 3709 3710 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 3711 if (rtn != 0) { 3712 kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN); 3713 kmem_free(rqbuf_rw, SENSE_LENGTH); 3714 mutex_enter(SD_MUTEX(un)); 3715 return; 3716 } 3717 3718 out_data_hd = kmem_zalloc(SD_CURRENT_FEATURE_LEN, KM_SLEEP); 3719 rqbuf_hd = kmem_zalloc(SENSE_LENGTH, KM_SLEEP); 3720 3721 rtn = sd_send_scsi_feature_GET_CONFIGURATION(ssc, &com, rqbuf_hd, 3722 SENSE_LENGTH, out_data_hd, SD_CURRENT_FEATURE_LEN, 3723 HARDWARE_DEFECT_MANAGEMENT, path_flag); 3724 3725 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 3726 mutex_enter(SD_MUTEX(un)); 3727 if (rtn == 0) { 3728 /* 3729 * We have good information, check for random writable 3730 * and hardware defect features as current. 3731 */ 3732 if ((out_data_rw[9] & RANDOM_WRITABLE) && 3733 (out_data_rw[10] & 0x1) && 3734 (out_data_hd[9] & HARDWARE_DEFECT_MANAGEMENT) && 3735 (out_data_hd[10] & 0x1)) { 3736 un->un_f_mmc_writable_media = TRUE; 3737 } 3738 } 3739 3740 kmem_free(out_data_rw, SD_CURRENT_FEATURE_LEN); 3741 kmem_free(rqbuf_rw, SENSE_LENGTH); 3742 kmem_free(out_data_hd, SD_CURRENT_FEATURE_LEN); 3743 kmem_free(rqbuf_hd, SENSE_LENGTH); 3744 } 3745 3746 /* 3747 * Function: sd_read_unit_properties 3748 * 3749 * Description: The following implements a property lookup mechanism. 3750 * Properties for particular disks (keyed on vendor, model 3751 * and rev numbers) are sought in the sd.conf file via 3752 * sd_process_sdconf_file(), and if not found there, are 3753 * looked for in a list hardcoded in this driver via 3754 * sd_process_sdconf_table() Once located the properties 3755 * are used to update the driver unit structure. 3756 * 3757 * Arguments: un - driver soft state (unit) structure 3758 */ 3759 3760 static void 3761 sd_read_unit_properties(struct sd_lun *un) 3762 { 3763 /* 3764 * sd_process_sdconf_file returns SD_FAILURE if it cannot find 3765 * the "sd-config-list" property (from the sd.conf file) or if 3766 * there was not a match for the inquiry vid/pid. If this event 3767 * occurs the static driver configuration table is searched for 3768 * a match. 3769 */ 3770 ASSERT(un != NULL); 3771 if (sd_process_sdconf_file(un) == SD_FAILURE) { 3772 sd_process_sdconf_table(un); 3773 } 3774 3775 /* check for LSI device */ 3776 sd_is_lsi(un); 3777 3778 3779 } 3780 3781 3782 /* 3783 * Function: sd_process_sdconf_file 3784 * 3785 * Description: Use ddi_prop_lookup(9F) to obtain the properties from the 3786 * driver's config file (ie, sd.conf) and update the driver 3787 * soft state structure accordingly. 3788 * 3789 * Arguments: un - driver soft state (unit) structure 3790 * 3791 * Return Code: SD_SUCCESS - The properties were successfully set according 3792 * to the driver configuration file. 3793 * SD_FAILURE - The driver config list was not obtained or 3794 * there was no vid/pid match. This indicates that 3795 * the static config table should be used. 3796 * 3797 * The config file has a property, "sd-config-list". Currently we support 3798 * two kinds of formats. For both formats, the value of this property 3799 * is a list of duplets: 3800 * 3801 * sd-config-list= 3802 * <duplet>, 3803 * [,<duplet>]*; 3804 * 3805 * For the improved format, where 3806 * 3807 * <duplet>:= "<vid+pid>","<tunable-list>" 3808 * 3809 * and 3810 * 3811 * <tunable-list>:= <tunable> [, <tunable> ]*; 3812 * <tunable> = <name> : <value> 3813 * 3814 * The <vid+pid> is the string that is returned by the target device on a 3815 * SCSI inquiry command, the <tunable-list> contains one or more tunables 3816 * to apply to all target devices with the specified <vid+pid>. 3817 * 3818 * Each <tunable> is a "<name> : <value>" pair. 3819 * 3820 * For the old format, the structure of each duplet is as follows: 3821 * 3822 * <duplet>:= "<vid+pid>","<data-property-name_list>" 3823 * 3824 * The first entry of the duplet is the device ID string (the concatenated 3825 * vid & pid; not to be confused with a device_id). This is defined in 3826 * the same way as in the sd_disk_table. 3827 * 3828 * The second part of the duplet is a string that identifies a 3829 * data-property-name-list. The data-property-name-list is defined as 3830 * follows: 3831 * 3832 * <data-property-name-list>:=<data-property-name> [<data-property-name>] 3833 * 3834 * The syntax of <data-property-name> depends on the <version> field. 3835 * 3836 * If version = SD_CONF_VERSION_1 we have the following syntax: 3837 * 3838 * <data-property-name>:=<version>,<flags>,<prop0>,<prop1>,.....<propN> 3839 * 3840 * where the prop0 value will be used to set prop0 if bit0 set in the 3841 * flags, prop1 if bit1 set, etc. and N = SD_CONF_MAX_ITEMS -1 3842 * 3843 */ 3844 3845 static int 3846 sd_process_sdconf_file(struct sd_lun *un) 3847 { 3848 char **config_list = NULL; 3849 uint_t nelements; 3850 char *vidptr; 3851 int vidlen; 3852 char *dnlist_ptr; 3853 char *dataname_ptr; 3854 char *dataname_lasts; 3855 int *data_list = NULL; 3856 uint_t data_list_len; 3857 int rval = SD_FAILURE; 3858 int i; 3859 3860 ASSERT(un != NULL); 3861 3862 /* Obtain the configuration list associated with the .conf file */ 3863 if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, SD_DEVINFO(un), 3864 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, sd_config_list, 3865 &config_list, &nelements) != DDI_PROP_SUCCESS) { 3866 return (SD_FAILURE); 3867 } 3868 3869 /* 3870 * Compare vids in each duplet to the inquiry vid - if a match is 3871 * made, get the data value and update the soft state structure 3872 * accordingly. 3873 * 3874 * Each duplet should show as a pair of strings, return SD_FAILURE 3875 * otherwise. 3876 */ 3877 if (nelements & 1) { 3878 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 3879 "sd-config-list should show as pairs of strings.\n"); 3880 if (config_list) 3881 ddi_prop_free(config_list); 3882 return (SD_FAILURE); 3883 } 3884 3885 for (i = 0; i < nelements; i += 2) { 3886 /* 3887 * Note: The assumption here is that each vid entry is on 3888 * a unique line from its associated duplet. 3889 */ 3890 vidptr = config_list[i]; 3891 vidlen = (int)strlen(vidptr); 3892 if (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 if (strcasecmp(name, "retries-victim") == 0) { 4236 if (ddi_strtol(value, &endptr, 0, &val) == 0) { 4237 un->un_victim_retry_count = val; 4238 } else { 4239 goto value_invalid; 4240 } 4241 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: " 4242 "victim retry count set to %d\n", 4243 un->un_victim_retry_count); 4244 return; 4245 } 4246 4247 /* 4248 * Validate the throttle values. 4249 * If any of the numbers are invalid, set everything to defaults. 4250 */ 4251 if ((un->un_throttle < SD_LOWEST_VALID_THROTTLE) || 4252 (un->un_min_throttle < SD_LOWEST_VALID_THROTTLE) || 4253 (un->un_min_throttle > un->un_throttle)) { 4254 un->un_saved_throttle = un->un_throttle = sd_max_throttle; 4255 un->un_min_throttle = sd_min_throttle; 4256 } 4257 4258 if (strcasecmp(name, "mmc-gesn-polling") == 0) { 4259 if (strcasecmp(value, "true") == 0) { 4260 un->un_f_mmc_gesn_polling = TRUE; 4261 } else if (strcasecmp(value, "false") == 0) { 4262 un->un_f_mmc_gesn_polling = FALSE; 4263 } else { 4264 goto value_invalid; 4265 } 4266 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: " 4267 "mmc-gesn-polling set to %d\n", 4268 un->un_f_mmc_gesn_polling); 4269 } 4270 4271 return; 4272 4273 value_invalid: 4274 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_set_properties: " 4275 "value of prop %s is invalid\n", name); 4276 } 4277 4278 /* 4279 * Function: sd_get_tunables_from_conf() 4280 * 4281 * 4282 * This function reads the data list from the sd.conf file and pulls 4283 * the values that can have numeric values as arguments and places 4284 * the values in the appropriate sd_tunables member. 4285 * Since the order of the data list members varies across platforms 4286 * This function reads them from the data list in a platform specific 4287 * order and places them into the correct sd_tunable member that is 4288 * consistent across all platforms. 4289 */ 4290 static void 4291 sd_get_tunables_from_conf(struct sd_lun *un, int flags, int *data_list, 4292 sd_tunables *values) 4293 { 4294 int i; 4295 int mask; 4296 4297 bzero(values, sizeof (sd_tunables)); 4298 4299 for (i = 0; i < SD_CONF_MAX_ITEMS; i++) { 4300 4301 mask = 1 << i; 4302 if (mask > flags) { 4303 break; 4304 } 4305 4306 switch (mask & flags) { 4307 case 0: /* This mask bit not set in flags */ 4308 continue; 4309 case SD_CONF_BSET_THROTTLE: 4310 values->sdt_throttle = data_list[i]; 4311 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4312 "sd_get_tunables_from_conf: throttle = %d\n", 4313 values->sdt_throttle); 4314 break; 4315 case SD_CONF_BSET_CTYPE: 4316 values->sdt_ctype = data_list[i]; 4317 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4318 "sd_get_tunables_from_conf: ctype = %d\n", 4319 values->sdt_ctype); 4320 break; 4321 case SD_CONF_BSET_NRR_COUNT: 4322 values->sdt_not_rdy_retries = data_list[i]; 4323 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4324 "sd_get_tunables_from_conf: not_rdy_retries = %d\n", 4325 values->sdt_not_rdy_retries); 4326 break; 4327 case SD_CONF_BSET_BSY_RETRY_COUNT: 4328 values->sdt_busy_retries = data_list[i]; 4329 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4330 "sd_get_tunables_from_conf: busy_retries = %d\n", 4331 values->sdt_busy_retries); 4332 break; 4333 case SD_CONF_BSET_RST_RETRIES: 4334 values->sdt_reset_retries = data_list[i]; 4335 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4336 "sd_get_tunables_from_conf: reset_retries = %d\n", 4337 values->sdt_reset_retries); 4338 break; 4339 case SD_CONF_BSET_RSV_REL_TIME: 4340 values->sdt_reserv_rel_time = data_list[i]; 4341 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4342 "sd_get_tunables_from_conf: reserv_rel_time = %d\n", 4343 values->sdt_reserv_rel_time); 4344 break; 4345 case SD_CONF_BSET_MIN_THROTTLE: 4346 values->sdt_min_throttle = data_list[i]; 4347 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4348 "sd_get_tunables_from_conf: min_throttle = %d\n", 4349 values->sdt_min_throttle); 4350 break; 4351 case SD_CONF_BSET_DISKSORT_DISABLED: 4352 values->sdt_disk_sort_dis = data_list[i]; 4353 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4354 "sd_get_tunables_from_conf: disk_sort_dis = %d\n", 4355 values->sdt_disk_sort_dis); 4356 break; 4357 case SD_CONF_BSET_LUN_RESET_ENABLED: 4358 values->sdt_lun_reset_enable = data_list[i]; 4359 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4360 "sd_get_tunables_from_conf: lun_reset_enable = %d" 4361 "\n", values->sdt_lun_reset_enable); 4362 break; 4363 case SD_CONF_BSET_CACHE_IS_NV: 4364 values->sdt_suppress_cache_flush = data_list[i]; 4365 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4366 "sd_get_tunables_from_conf: \ 4367 suppress_cache_flush = %d" 4368 "\n", values->sdt_suppress_cache_flush); 4369 break; 4370 case SD_CONF_BSET_PC_DISABLED: 4371 values->sdt_disk_sort_dis = data_list[i]; 4372 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4373 "sd_get_tunables_from_conf: power_condition_dis = " 4374 "%d\n", values->sdt_power_condition_dis); 4375 break; 4376 } 4377 } 4378 } 4379 4380 /* 4381 * Function: sd_process_sdconf_table 4382 * 4383 * Description: Search the static configuration table for a match on the 4384 * inquiry vid/pid and update the driver soft state structure 4385 * according to the table property values for the device. 4386 * 4387 * The form of a configuration table entry is: 4388 * <vid+pid>,<flags>,<property-data> 4389 * "SEAGATE ST42400N",1,0x40000, 4390 * 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1; 4391 * 4392 * Arguments: un - driver soft state (unit) structure 4393 */ 4394 4395 static void 4396 sd_process_sdconf_table(struct sd_lun *un) 4397 { 4398 char *id = NULL; 4399 int table_index; 4400 int idlen; 4401 4402 ASSERT(un != NULL); 4403 for (table_index = 0; table_index < sd_disk_table_size; 4404 table_index++) { 4405 id = sd_disk_table[table_index].device_id; 4406 idlen = strlen(id); 4407 4408 /* 4409 * The static configuration table currently does not 4410 * implement version 10 properties. Additionally, 4411 * multiple data-property-name entries are not 4412 * implemented in the static configuration table. 4413 */ 4414 if (sd_sdconf_id_match(un, id, idlen) == SD_SUCCESS) { 4415 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4416 "sd_process_sdconf_table: disk %s\n", id); 4417 sd_set_vers1_properties(un, 4418 sd_disk_table[table_index].flags, 4419 sd_disk_table[table_index].properties); 4420 break; 4421 } 4422 } 4423 } 4424 4425 4426 /* 4427 * Function: sd_sdconf_id_match 4428 * 4429 * Description: This local function implements a case sensitive vid/pid 4430 * comparison as well as the boundary cases of wild card and 4431 * multiple blanks. 4432 * 4433 * Note: An implicit assumption made here is that the scsi 4434 * inquiry structure will always keep the vid, pid and 4435 * revision strings in consecutive sequence, so they can be 4436 * read as a single string. If this assumption is not the 4437 * case, a separate string, to be used for the check, needs 4438 * to be built with these strings concatenated. 4439 * 4440 * Arguments: un - driver soft state (unit) structure 4441 * id - table or config file vid/pid 4442 * idlen - length of the vid/pid (bytes) 4443 * 4444 * Return Code: SD_SUCCESS - Indicates a match with the inquiry vid/pid 4445 * SD_FAILURE - Indicates no match with the inquiry vid/pid 4446 */ 4447 4448 static int 4449 sd_sdconf_id_match(struct sd_lun *un, char *id, int idlen) 4450 { 4451 struct scsi_inquiry *sd_inq; 4452 int rval = SD_SUCCESS; 4453 4454 ASSERT(un != NULL); 4455 sd_inq = un->un_sd->sd_inq; 4456 ASSERT(id != NULL); 4457 4458 /* 4459 * We use the inq_vid as a pointer to a buffer containing the 4460 * vid and pid and use the entire vid/pid length of the table 4461 * entry for the comparison. This works because the inq_pid 4462 * data member follows inq_vid in the scsi_inquiry structure. 4463 */ 4464 if (strncasecmp(sd_inq->inq_vid, id, idlen) != 0) { 4465 /* 4466 * The user id string is compared to the inquiry vid/pid 4467 * using a case insensitive comparison and ignoring 4468 * multiple spaces. 4469 */ 4470 rval = sd_blank_cmp(un, id, idlen); 4471 if (rval != SD_SUCCESS) { 4472 /* 4473 * User id strings that start and end with a "*" 4474 * are a special case. These do not have a 4475 * specific vendor, and the product string can 4476 * appear anywhere in the 16 byte PID portion of 4477 * the inquiry data. This is a simple strstr() 4478 * type search for the user id in the inquiry data. 4479 */ 4480 if ((id[0] == '*') && (id[idlen - 1] == '*')) { 4481 char *pidptr = &id[1]; 4482 int i; 4483 int j; 4484 int pidstrlen = idlen - 2; 4485 j = sizeof (SD_INQUIRY(un)->inq_pid) - 4486 pidstrlen; 4487 4488 if (j < 0) { 4489 return (SD_FAILURE); 4490 } 4491 for (i = 0; i < j; i++) { 4492 if (bcmp(&SD_INQUIRY(un)->inq_pid[i], 4493 pidptr, pidstrlen) == 0) { 4494 rval = SD_SUCCESS; 4495 break; 4496 } 4497 } 4498 } 4499 } 4500 } 4501 return (rval); 4502 } 4503 4504 4505 /* 4506 * Function: sd_blank_cmp 4507 * 4508 * Description: If the id string starts and ends with a space, treat 4509 * multiple consecutive spaces as equivalent to a single 4510 * space. For example, this causes a sd_disk_table entry 4511 * of " NEC CDROM " to match a device's id string of 4512 * "NEC CDROM". 4513 * 4514 * Note: The success exit condition for this routine is if 4515 * the pointer to the table entry is '\0' and the cnt of 4516 * the inquiry length is zero. This will happen if the inquiry 4517 * string returned by the device is padded with spaces to be 4518 * exactly 24 bytes in length (8 byte vid + 16 byte pid). The 4519 * SCSI spec states that the inquiry string is to be padded with 4520 * spaces. 4521 * 4522 * Arguments: un - driver soft state (unit) structure 4523 * id - table or config file vid/pid 4524 * idlen - length of the vid/pid (bytes) 4525 * 4526 * Return Code: SD_SUCCESS - Indicates a match with the inquiry vid/pid 4527 * SD_FAILURE - Indicates no match with the inquiry vid/pid 4528 */ 4529 4530 static int 4531 sd_blank_cmp(struct sd_lun *un, char *id, int idlen) 4532 { 4533 char *p1; 4534 char *p2; 4535 int cnt; 4536 cnt = sizeof (SD_INQUIRY(un)->inq_vid) + 4537 sizeof (SD_INQUIRY(un)->inq_pid); 4538 4539 ASSERT(un != NULL); 4540 p2 = un->un_sd->sd_inq->inq_vid; 4541 ASSERT(id != NULL); 4542 p1 = id; 4543 4544 if ((id[0] == ' ') && (id[idlen - 1] == ' ')) { 4545 /* 4546 * Note: string p1 is terminated by a NUL but string p2 4547 * isn't. The end of p2 is determined by cnt. 4548 */ 4549 for (;;) { 4550 /* skip over any extra blanks in both strings */ 4551 while ((*p1 != '\0') && (*p1 == ' ')) { 4552 p1++; 4553 } 4554 while ((cnt != 0) && (*p2 == ' ')) { 4555 p2++; 4556 cnt--; 4557 } 4558 4559 /* compare the two strings */ 4560 if ((cnt == 0) || 4561 (SD_TOUPPER(*p1) != SD_TOUPPER(*p2))) { 4562 break; 4563 } 4564 while ((cnt > 0) && 4565 (SD_TOUPPER(*p1) == SD_TOUPPER(*p2))) { 4566 p1++; 4567 p2++; 4568 cnt--; 4569 } 4570 } 4571 } 4572 4573 /* return SD_SUCCESS if both strings match */ 4574 return (((*p1 == '\0') && (cnt == 0)) ? SD_SUCCESS : SD_FAILURE); 4575 } 4576 4577 4578 /* 4579 * Function: sd_chk_vers1_data 4580 * 4581 * Description: Verify the version 1 device properties provided by the 4582 * user via the configuration file 4583 * 4584 * Arguments: un - driver soft state (unit) structure 4585 * flags - integer mask indicating properties to be set 4586 * prop_list - integer list of property values 4587 * list_len - number of the elements 4588 * 4589 * Return Code: SD_SUCCESS - Indicates the user provided data is valid 4590 * SD_FAILURE - Indicates the user provided data is invalid 4591 */ 4592 4593 static int 4594 sd_chk_vers1_data(struct sd_lun *un, int flags, int *prop_list, 4595 int list_len, char *dataname_ptr) 4596 { 4597 int i; 4598 int mask = 1; 4599 int index = 0; 4600 4601 ASSERT(un != NULL); 4602 4603 /* Check for a NULL property name and list */ 4604 if (dataname_ptr == NULL) { 4605 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 4606 "sd_chk_vers1_data: NULL data property name."); 4607 return (SD_FAILURE); 4608 } 4609 if (prop_list == NULL) { 4610 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 4611 "sd_chk_vers1_data: %s NULL data property list.", 4612 dataname_ptr); 4613 return (SD_FAILURE); 4614 } 4615 4616 /* Display a warning if undefined bits are set in the flags */ 4617 if (flags & ~SD_CONF_BIT_MASK) { 4618 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 4619 "sd_chk_vers1_data: invalid bits 0x%x in data list %s. " 4620 "Properties not set.", 4621 (flags & ~SD_CONF_BIT_MASK), dataname_ptr); 4622 return (SD_FAILURE); 4623 } 4624 4625 /* 4626 * Verify the length of the list by identifying the highest bit set 4627 * in the flags and validating that the property list has a length 4628 * up to the index of this bit. 4629 */ 4630 for (i = 0; i < SD_CONF_MAX_ITEMS; i++) { 4631 if (flags & mask) { 4632 index++; 4633 } 4634 mask = 1 << i; 4635 } 4636 if (list_len < (index + 2)) { 4637 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 4638 "sd_chk_vers1_data: " 4639 "Data property list %s size is incorrect. " 4640 "Properties not set.", dataname_ptr); 4641 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT, "Size expected: " 4642 "version + 1 flagword + %d properties", SD_CONF_MAX_ITEMS); 4643 return (SD_FAILURE); 4644 } 4645 return (SD_SUCCESS); 4646 } 4647 4648 4649 /* 4650 * Function: sd_set_vers1_properties 4651 * 4652 * Description: Set version 1 device properties based on a property list 4653 * retrieved from the driver configuration file or static 4654 * configuration table. Version 1 properties have the format: 4655 * 4656 * <data-property-name>:=<version>,<flags>,<prop0>,<prop1>,.....<propN> 4657 * 4658 * where the prop0 value will be used to set prop0 if bit0 4659 * is set in the flags 4660 * 4661 * Arguments: un - driver soft state (unit) structure 4662 * flags - integer mask indicating properties to be set 4663 * prop_list - integer list of property values 4664 */ 4665 4666 static void 4667 sd_set_vers1_properties(struct sd_lun *un, int flags, sd_tunables *prop_list) 4668 { 4669 ASSERT(un != NULL); 4670 4671 /* 4672 * Set the flag to indicate cache is to be disabled. An attempt 4673 * to disable the cache via sd_cache_control() will be made 4674 * later during attach once the basic initialization is complete. 4675 */ 4676 if (flags & SD_CONF_BSET_NOCACHE) { 4677 un->un_f_opt_disable_cache = TRUE; 4678 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4679 "sd_set_vers1_properties: caching disabled flag set\n"); 4680 } 4681 4682 /* CD-specific configuration parameters */ 4683 if (flags & SD_CONF_BSET_PLAYMSF_BCD) { 4684 un->un_f_cfg_playmsf_bcd = TRUE; 4685 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4686 "sd_set_vers1_properties: playmsf_bcd set\n"); 4687 } 4688 if (flags & SD_CONF_BSET_READSUB_BCD) { 4689 un->un_f_cfg_readsub_bcd = TRUE; 4690 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4691 "sd_set_vers1_properties: readsub_bcd set\n"); 4692 } 4693 if (flags & SD_CONF_BSET_READ_TOC_TRK_BCD) { 4694 un->un_f_cfg_read_toc_trk_bcd = TRUE; 4695 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4696 "sd_set_vers1_properties: read_toc_trk_bcd set\n"); 4697 } 4698 if (flags & SD_CONF_BSET_READ_TOC_ADDR_BCD) { 4699 un->un_f_cfg_read_toc_addr_bcd = TRUE; 4700 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4701 "sd_set_vers1_properties: read_toc_addr_bcd set\n"); 4702 } 4703 if (flags & SD_CONF_BSET_NO_READ_HEADER) { 4704 un->un_f_cfg_no_read_header = TRUE; 4705 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4706 "sd_set_vers1_properties: no_read_header set\n"); 4707 } 4708 if (flags & SD_CONF_BSET_READ_CD_XD4) { 4709 un->un_f_cfg_read_cd_xd4 = TRUE; 4710 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4711 "sd_set_vers1_properties: read_cd_xd4 set\n"); 4712 } 4713 4714 /* Support for devices which do not have valid/unique serial numbers */ 4715 if (flags & SD_CONF_BSET_FAB_DEVID) { 4716 un->un_f_opt_fab_devid = TRUE; 4717 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4718 "sd_set_vers1_properties: fab_devid bit set\n"); 4719 } 4720 4721 /* Support for user throttle configuration */ 4722 if (flags & SD_CONF_BSET_THROTTLE) { 4723 ASSERT(prop_list != NULL); 4724 un->un_saved_throttle = un->un_throttle = 4725 prop_list->sdt_throttle; 4726 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4727 "sd_set_vers1_properties: throttle set to %d\n", 4728 prop_list->sdt_throttle); 4729 } 4730 4731 /* Set the per disk retry count according to the conf file or table. */ 4732 if (flags & SD_CONF_BSET_NRR_COUNT) { 4733 ASSERT(prop_list != NULL); 4734 if (prop_list->sdt_not_rdy_retries) { 4735 un->un_notready_retry_count = 4736 prop_list->sdt_not_rdy_retries; 4737 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4738 "sd_set_vers1_properties: not ready retry count" 4739 " set to %d\n", un->un_notready_retry_count); 4740 } 4741 } 4742 4743 /* The controller type is reported for generic disk driver ioctls */ 4744 if (flags & SD_CONF_BSET_CTYPE) { 4745 ASSERT(prop_list != NULL); 4746 switch (prop_list->sdt_ctype) { 4747 case CTYPE_CDROM: 4748 un->un_ctype = prop_list->sdt_ctype; 4749 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4750 "sd_set_vers1_properties: ctype set to " 4751 "CTYPE_CDROM\n"); 4752 break; 4753 case CTYPE_CCS: 4754 un->un_ctype = prop_list->sdt_ctype; 4755 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4756 "sd_set_vers1_properties: ctype set to " 4757 "CTYPE_CCS\n"); 4758 break; 4759 case CTYPE_ROD: /* RW optical */ 4760 un->un_ctype = prop_list->sdt_ctype; 4761 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4762 "sd_set_vers1_properties: ctype set to " 4763 "CTYPE_ROD\n"); 4764 break; 4765 default: 4766 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 4767 "sd_set_vers1_properties: Could not set " 4768 "invalid ctype value (%d)", 4769 prop_list->sdt_ctype); 4770 } 4771 } 4772 4773 /* Purple failover timeout */ 4774 if (flags & SD_CONF_BSET_BSY_RETRY_COUNT) { 4775 ASSERT(prop_list != NULL); 4776 un->un_busy_retry_count = 4777 prop_list->sdt_busy_retries; 4778 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4779 "sd_set_vers1_properties: " 4780 "busy retry count set to %d\n", 4781 un->un_busy_retry_count); 4782 } 4783 4784 /* Purple reset retry count */ 4785 if (flags & SD_CONF_BSET_RST_RETRIES) { 4786 ASSERT(prop_list != NULL); 4787 un->un_reset_retry_count = 4788 prop_list->sdt_reset_retries; 4789 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4790 "sd_set_vers1_properties: " 4791 "reset retry count set to %d\n", 4792 un->un_reset_retry_count); 4793 } 4794 4795 /* Purple reservation release timeout */ 4796 if (flags & SD_CONF_BSET_RSV_REL_TIME) { 4797 ASSERT(prop_list != NULL); 4798 un->un_reserve_release_time = 4799 prop_list->sdt_reserv_rel_time; 4800 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4801 "sd_set_vers1_properties: " 4802 "reservation release timeout set to %d\n", 4803 un->un_reserve_release_time); 4804 } 4805 4806 /* 4807 * Driver flag telling the driver to verify that no commands are pending 4808 * for a device before issuing a Test Unit Ready. This is a workaround 4809 * for a firmware bug in some Seagate eliteI drives. 4810 */ 4811 if (flags & SD_CONF_BSET_TUR_CHECK) { 4812 un->un_f_cfg_tur_check = TRUE; 4813 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4814 "sd_set_vers1_properties: tur queue check set\n"); 4815 } 4816 4817 if (flags & SD_CONF_BSET_MIN_THROTTLE) { 4818 un->un_min_throttle = prop_list->sdt_min_throttle; 4819 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4820 "sd_set_vers1_properties: min throttle set to %d\n", 4821 un->un_min_throttle); 4822 } 4823 4824 if (flags & SD_CONF_BSET_DISKSORT_DISABLED) { 4825 un->un_f_disksort_disabled = 4826 (prop_list->sdt_disk_sort_dis != 0) ? 4827 TRUE : FALSE; 4828 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4829 "sd_set_vers1_properties: disksort disabled " 4830 "flag set to %d\n", 4831 prop_list->sdt_disk_sort_dis); 4832 } 4833 4834 if (flags & SD_CONF_BSET_LUN_RESET_ENABLED) { 4835 un->un_f_lun_reset_enabled = 4836 (prop_list->sdt_lun_reset_enable != 0) ? 4837 TRUE : FALSE; 4838 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4839 "sd_set_vers1_properties: lun reset enabled " 4840 "flag set to %d\n", 4841 prop_list->sdt_lun_reset_enable); 4842 } 4843 4844 if (flags & SD_CONF_BSET_CACHE_IS_NV) { 4845 un->un_f_suppress_cache_flush = 4846 (prop_list->sdt_suppress_cache_flush != 0) ? 4847 TRUE : FALSE; 4848 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4849 "sd_set_vers1_properties: suppress_cache_flush " 4850 "flag set to %d\n", 4851 prop_list->sdt_suppress_cache_flush); 4852 } 4853 4854 if (flags & SD_CONF_BSET_PC_DISABLED) { 4855 un->un_f_power_condition_disabled = 4856 (prop_list->sdt_power_condition_dis != 0) ? 4857 TRUE : FALSE; 4858 SD_INFO(SD_LOG_ATTACH_DETACH, un, 4859 "sd_set_vers1_properties: power_condition_disabled " 4860 "flag set to %d\n", 4861 prop_list->sdt_power_condition_dis); 4862 } 4863 4864 /* 4865 * Validate the throttle values. 4866 * If any of the numbers are invalid, set everything to defaults. 4867 */ 4868 if ((un->un_throttle < SD_LOWEST_VALID_THROTTLE) || 4869 (un->un_min_throttle < SD_LOWEST_VALID_THROTTLE) || 4870 (un->un_min_throttle > un->un_throttle)) { 4871 un->un_saved_throttle = un->un_throttle = sd_max_throttle; 4872 un->un_min_throttle = sd_min_throttle; 4873 } 4874 } 4875 4876 /* 4877 * Function: sd_is_lsi() 4878 * 4879 * Description: Check for lsi devices, step through the static device 4880 * table to match vid/pid. 4881 * 4882 * Args: un - ptr to sd_lun 4883 * 4884 * Notes: When creating new LSI property, need to add the new LSI property 4885 * to this function. 4886 */ 4887 static void 4888 sd_is_lsi(struct sd_lun *un) 4889 { 4890 char *id = NULL; 4891 int table_index; 4892 int idlen; 4893 void *prop; 4894 4895 ASSERT(un != NULL); 4896 for (table_index = 0; table_index < sd_disk_table_size; 4897 table_index++) { 4898 id = sd_disk_table[table_index].device_id; 4899 idlen = strlen(id); 4900 if (idlen == 0) { 4901 continue; 4902 } 4903 4904 if (sd_sdconf_id_match(un, id, idlen) == SD_SUCCESS) { 4905 prop = sd_disk_table[table_index].properties; 4906 if (prop == &lsi_properties || 4907 prop == &lsi_oem_properties || 4908 prop == &lsi_properties_scsi || 4909 prop == &symbios_properties) { 4910 un->un_f_cfg_is_lsi = TRUE; 4911 } 4912 break; 4913 } 4914 } 4915 } 4916 4917 /* 4918 * Function: sd_get_physical_geometry 4919 * 4920 * Description: Retrieve the MODE SENSE page 3 (Format Device Page) and 4921 * MODE SENSE page 4 (Rigid Disk Drive Geometry Page) from the 4922 * target, and use this information to initialize the physical 4923 * geometry cache specified by pgeom_p. 4924 * 4925 * MODE SENSE is an optional command, so failure in this case 4926 * does not necessarily denote an error. We want to use the 4927 * MODE SENSE commands to derive the physical geometry of the 4928 * device, but if either command fails, the logical geometry is 4929 * used as the fallback for disk label geometry in cmlb. 4930 * 4931 * This requires that un->un_blockcount and un->un_tgt_blocksize 4932 * have already been initialized for the current target and 4933 * that the current values be passed as args so that we don't 4934 * end up ever trying to use -1 as a valid value. This could 4935 * happen if either value is reset while we're not holding 4936 * the mutex. 4937 * 4938 * Arguments: un - driver soft state (unit) structure 4939 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and 4940 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY 4941 * to use the USCSI "direct" chain and bypass the normal 4942 * command waitq. 4943 * 4944 * Context: Kernel thread only (can sleep). 4945 */ 4946 4947 static int 4948 sd_get_physical_geometry(struct sd_lun *un, cmlb_geom_t *pgeom_p, 4949 diskaddr_t capacity, int lbasize, int path_flag) 4950 { 4951 struct mode_format *page3p; 4952 struct mode_geometry *page4p; 4953 struct mode_header *headerp; 4954 int sector_size; 4955 int nsect; 4956 int nhead; 4957 int ncyl; 4958 int intrlv; 4959 int spc; 4960 diskaddr_t modesense_capacity; 4961 int rpm; 4962 int bd_len; 4963 int mode_header_length; 4964 uchar_t *p3bufp; 4965 uchar_t *p4bufp; 4966 int cdbsize; 4967 int ret = EIO; 4968 sd_ssc_t *ssc; 4969 int status; 4970 4971 ASSERT(un != NULL); 4972 4973 if (lbasize == 0) { 4974 if (ISCD(un)) { 4975 lbasize = 2048; 4976 } else { 4977 lbasize = un->un_sys_blocksize; 4978 } 4979 } 4980 pgeom_p->g_secsize = (unsigned short)lbasize; 4981 4982 /* 4983 * If the unit is a cd/dvd drive MODE SENSE page three 4984 * and MODE SENSE page four are reserved (see SBC spec 4985 * and MMC spec). To prevent soft errors just return 4986 * using the default LBA size. 4987 */ 4988 if (ISCD(un)) 4989 return (ret); 4990 4991 cdbsize = (un->un_f_cfg_is_atapi == TRUE) ? CDB_GROUP2 : CDB_GROUP0; 4992 4993 /* 4994 * Retrieve MODE SENSE page 3 - Format Device Page 4995 */ 4996 p3bufp = kmem_zalloc(SD_MODE_SENSE_PAGE3_LENGTH, KM_SLEEP); 4997 ssc = sd_ssc_init(un); 4998 status = sd_send_scsi_MODE_SENSE(ssc, cdbsize, p3bufp, 4999 SD_MODE_SENSE_PAGE3_LENGTH, SD_MODE_SENSE_PAGE3_CODE, path_flag); 5000 if (status != 0) { 5001 SD_ERROR(SD_LOG_COMMON, un, 5002 "sd_get_physical_geometry: mode sense page 3 failed\n"); 5003 goto page3_exit; 5004 } 5005 5006 /* 5007 * Determine size of Block Descriptors in order to locate the mode 5008 * page data. ATAPI devices return 0, SCSI devices should return 5009 * MODE_BLK_DESC_LENGTH. 5010 */ 5011 headerp = (struct mode_header *)p3bufp; 5012 if (un->un_f_cfg_is_atapi == TRUE) { 5013 struct mode_header_grp2 *mhp = 5014 (struct mode_header_grp2 *)headerp; 5015 mode_header_length = MODE_HEADER_LENGTH_GRP2; 5016 bd_len = (mhp->bdesc_length_hi << 8) | mhp->bdesc_length_lo; 5017 } else { 5018 mode_header_length = MODE_HEADER_LENGTH; 5019 bd_len = ((struct mode_header *)headerp)->bdesc_length; 5020 } 5021 5022 if (bd_len > MODE_BLK_DESC_LENGTH) { 5023 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON, 5024 "sd_get_physical_geometry: received unexpected bd_len " 5025 "of %d, page3\n", bd_len); 5026 status = EIO; 5027 goto page3_exit; 5028 } 5029 5030 page3p = (struct mode_format *) 5031 ((caddr_t)headerp + mode_header_length + bd_len); 5032 5033 if (page3p->mode_page.code != SD_MODE_SENSE_PAGE3_CODE) { 5034 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON, 5035 "sd_get_physical_geometry: mode sense pg3 code mismatch " 5036 "%d\n", page3p->mode_page.code); 5037 status = EIO; 5038 goto page3_exit; 5039 } 5040 5041 /* 5042 * Use this physical geometry data only if BOTH MODE SENSE commands 5043 * complete successfully; otherwise, revert to the logical geometry. 5044 * So, we need to save everything in temporary variables. 5045 */ 5046 sector_size = BE_16(page3p->data_bytes_sect); 5047 5048 /* 5049 * 1243403: The NEC D38x7 drives do not support MODE SENSE sector size 5050 */ 5051 if (sector_size == 0) { 5052 sector_size = un->un_sys_blocksize; 5053 } else { 5054 sector_size &= ~(un->un_sys_blocksize - 1); 5055 } 5056 5057 nsect = BE_16(page3p->sect_track); 5058 intrlv = BE_16(page3p->interleave); 5059 5060 SD_INFO(SD_LOG_COMMON, un, 5061 "sd_get_physical_geometry: Format Parameters (page 3)\n"); 5062 SD_INFO(SD_LOG_COMMON, un, 5063 " mode page: %d; nsect: %d; sector size: %d;\n", 5064 page3p->mode_page.code, nsect, sector_size); 5065 SD_INFO(SD_LOG_COMMON, un, 5066 " interleave: %d; track skew: %d; cylinder skew: %d;\n", intrlv, 5067 BE_16(page3p->track_skew), 5068 BE_16(page3p->cylinder_skew)); 5069 5070 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 5071 5072 /* 5073 * Retrieve MODE SENSE page 4 - Rigid Disk Drive Geometry Page 5074 */ 5075 p4bufp = kmem_zalloc(SD_MODE_SENSE_PAGE4_LENGTH, KM_SLEEP); 5076 status = sd_send_scsi_MODE_SENSE(ssc, cdbsize, p4bufp, 5077 SD_MODE_SENSE_PAGE4_LENGTH, SD_MODE_SENSE_PAGE4_CODE, path_flag); 5078 if (status != 0) { 5079 SD_ERROR(SD_LOG_COMMON, un, 5080 "sd_get_physical_geometry: mode sense page 4 failed\n"); 5081 goto page4_exit; 5082 } 5083 5084 /* 5085 * Determine size of Block Descriptors in order to locate the mode 5086 * page data. ATAPI devices return 0, SCSI devices should return 5087 * MODE_BLK_DESC_LENGTH. 5088 */ 5089 headerp = (struct mode_header *)p4bufp; 5090 if (un->un_f_cfg_is_atapi == TRUE) { 5091 struct mode_header_grp2 *mhp = 5092 (struct mode_header_grp2 *)headerp; 5093 bd_len = (mhp->bdesc_length_hi << 8) | mhp->bdesc_length_lo; 5094 } else { 5095 bd_len = ((struct mode_header *)headerp)->bdesc_length; 5096 } 5097 5098 if (bd_len > MODE_BLK_DESC_LENGTH) { 5099 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON, 5100 "sd_get_physical_geometry: received unexpected bd_len of " 5101 "%d, page4\n", bd_len); 5102 status = EIO; 5103 goto page4_exit; 5104 } 5105 5106 page4p = (struct mode_geometry *) 5107 ((caddr_t)headerp + mode_header_length + bd_len); 5108 5109 if (page4p->mode_page.code != SD_MODE_SENSE_PAGE4_CODE) { 5110 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON, 5111 "sd_get_physical_geometry: mode sense pg4 code mismatch " 5112 "%d\n", page4p->mode_page.code); 5113 status = EIO; 5114 goto page4_exit; 5115 } 5116 5117 /* 5118 * Stash the data now, after we know that both commands completed. 5119 */ 5120 5121 5122 nhead = (int)page4p->heads; /* uchar, so no conversion needed */ 5123 spc = nhead * nsect; 5124 ncyl = (page4p->cyl_ub << 16) + (page4p->cyl_mb << 8) + page4p->cyl_lb; 5125 rpm = BE_16(page4p->rpm); 5126 5127 modesense_capacity = spc * ncyl; 5128 5129 SD_INFO(SD_LOG_COMMON, un, 5130 "sd_get_physical_geometry: Geometry Parameters (page 4)\n"); 5131 SD_INFO(SD_LOG_COMMON, un, 5132 " cylinders: %d; heads: %d; rpm: %d;\n", ncyl, nhead, rpm); 5133 SD_INFO(SD_LOG_COMMON, un, 5134 " computed capacity(h*s*c): %d;\n", modesense_capacity); 5135 SD_INFO(SD_LOG_COMMON, un, " pgeom_p: %p; read cap: %d\n", 5136 (void *)pgeom_p, capacity); 5137 5138 /* 5139 * Compensate if the drive's geometry is not rectangular, i.e., 5140 * the product of C * H * S returned by MODE SENSE >= that returned 5141 * by read capacity. This is an idiosyncrasy of the original x86 5142 * disk subsystem. 5143 */ 5144 if (modesense_capacity >= capacity) { 5145 SD_INFO(SD_LOG_COMMON, un, 5146 "sd_get_physical_geometry: adjusting acyl; " 5147 "old: %d; new: %d\n", pgeom_p->g_acyl, 5148 (modesense_capacity - capacity + spc - 1) / spc); 5149 if (sector_size != 0) { 5150 /* 1243403: NEC D38x7 drives don't support sec size */ 5151 pgeom_p->g_secsize = (unsigned short)sector_size; 5152 } 5153 pgeom_p->g_nsect = (unsigned short)nsect; 5154 pgeom_p->g_nhead = (unsigned short)nhead; 5155 pgeom_p->g_capacity = capacity; 5156 pgeom_p->g_acyl = 5157 (modesense_capacity - pgeom_p->g_capacity + spc - 1) / spc; 5158 pgeom_p->g_ncyl = ncyl - pgeom_p->g_acyl; 5159 } 5160 5161 pgeom_p->g_rpm = (unsigned short)rpm; 5162 pgeom_p->g_intrlv = (unsigned short)intrlv; 5163 ret = 0; 5164 5165 SD_INFO(SD_LOG_COMMON, un, 5166 "sd_get_physical_geometry: mode sense geometry:\n"); 5167 SD_INFO(SD_LOG_COMMON, un, 5168 " nsect: %d; sector size: %d; interlv: %d\n", 5169 nsect, sector_size, intrlv); 5170 SD_INFO(SD_LOG_COMMON, un, 5171 " nhead: %d; ncyl: %d; rpm: %d; capacity(ms): %d\n", 5172 nhead, ncyl, rpm, modesense_capacity); 5173 SD_INFO(SD_LOG_COMMON, un, 5174 "sd_get_physical_geometry: (cached)\n"); 5175 SD_INFO(SD_LOG_COMMON, un, 5176 " ncyl: %ld; acyl: %d; nhead: %d; nsect: %d\n", 5177 pgeom_p->g_ncyl, pgeom_p->g_acyl, 5178 pgeom_p->g_nhead, pgeom_p->g_nsect); 5179 SD_INFO(SD_LOG_COMMON, un, 5180 " lbasize: %d; capacity: %ld; intrlv: %d; rpm: %d\n", 5181 pgeom_p->g_secsize, pgeom_p->g_capacity, 5182 pgeom_p->g_intrlv, pgeom_p->g_rpm); 5183 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 5184 5185 page4_exit: 5186 kmem_free(p4bufp, SD_MODE_SENSE_PAGE4_LENGTH); 5187 5188 page3_exit: 5189 kmem_free(p3bufp, SD_MODE_SENSE_PAGE3_LENGTH); 5190 5191 if (status != 0) { 5192 if (status == EIO) { 5193 /* 5194 * Some disks do not support mode sense(6), we 5195 * should ignore this kind of error(sense key is 5196 * 0x5 - illegal request). 5197 */ 5198 uint8_t *sensep; 5199 int senlen; 5200 5201 sensep = (uint8_t *)ssc->ssc_uscsi_cmd->uscsi_rqbuf; 5202 senlen = (int)(ssc->ssc_uscsi_cmd->uscsi_rqlen - 5203 ssc->ssc_uscsi_cmd->uscsi_rqresid); 5204 5205 if (senlen > 0 && 5206 scsi_sense_key(sensep) == KEY_ILLEGAL_REQUEST) { 5207 sd_ssc_assessment(ssc, 5208 SD_FMT_IGNORE_COMPROMISE); 5209 } else { 5210 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK); 5211 } 5212 } else { 5213 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 5214 } 5215 } 5216 sd_ssc_fini(ssc); 5217 return (ret); 5218 } 5219 5220 /* 5221 * Function: sd_get_virtual_geometry 5222 * 5223 * Description: Ask the controller to tell us about the target device. 5224 * 5225 * Arguments: un - pointer to softstate 5226 * capacity - disk capacity in #blocks 5227 * lbasize - disk block size in bytes 5228 * 5229 * Context: Kernel thread only 5230 */ 5231 5232 static int 5233 sd_get_virtual_geometry(struct sd_lun *un, cmlb_geom_t *lgeom_p, 5234 diskaddr_t capacity, int lbasize) 5235 { 5236 uint_t geombuf; 5237 int spc; 5238 5239 ASSERT(un != NULL); 5240 5241 /* Set sector size, and total number of sectors */ 5242 (void) scsi_ifsetcap(SD_ADDRESS(un), "sector-size", lbasize, 1); 5243 (void) scsi_ifsetcap(SD_ADDRESS(un), "total-sectors", capacity, 1); 5244 5245 /* Let the HBA tell us its geometry */ 5246 geombuf = (uint_t)scsi_ifgetcap(SD_ADDRESS(un), "geometry", 1); 5247 5248 /* A value of -1 indicates an undefined "geometry" property */ 5249 if (geombuf == (-1)) { 5250 return (EINVAL); 5251 } 5252 5253 /* Initialize the logical geometry cache. */ 5254 lgeom_p->g_nhead = (geombuf >> 16) & 0xffff; 5255 lgeom_p->g_nsect = geombuf & 0xffff; 5256 lgeom_p->g_secsize = un->un_sys_blocksize; 5257 5258 spc = lgeom_p->g_nhead * lgeom_p->g_nsect; 5259 5260 /* 5261 * Note: The driver originally converted the capacity value from 5262 * target blocks to system blocks. However, the capacity value passed 5263 * to this routine is already in terms of system blocks (this scaling 5264 * is done when the READ CAPACITY command is issued and processed). 5265 * This 'error' may have gone undetected because the usage of g_ncyl 5266 * (which is based upon g_capacity) is very limited within the driver 5267 */ 5268 lgeom_p->g_capacity = capacity; 5269 5270 /* 5271 * Set ncyl to zero if the hba returned a zero nhead or nsect value. The 5272 * hba may return zero values if the device has been removed. 5273 */ 5274 if (spc == 0) { 5275 lgeom_p->g_ncyl = 0; 5276 } else { 5277 lgeom_p->g_ncyl = lgeom_p->g_capacity / spc; 5278 } 5279 lgeom_p->g_acyl = 0; 5280 5281 SD_INFO(SD_LOG_COMMON, un, "sd_get_virtual_geometry: (cached)\n"); 5282 return (0); 5283 5284 } 5285 /* 5286 * Function: sd_update_block_info 5287 * 5288 * Description: Calculate a byte count to sector count bitshift value 5289 * from sector size. 5290 * 5291 * Arguments: un: unit struct. 5292 * lbasize: new target sector size 5293 * capacity: new target capacity, ie. block count 5294 * 5295 * Context: Kernel thread context 5296 */ 5297 5298 static void 5299 sd_update_block_info(struct sd_lun *un, uint32_t lbasize, uint64_t capacity) 5300 { 5301 if (lbasize != 0) { 5302 un->un_tgt_blocksize = lbasize; 5303 un->un_f_tgt_blocksize_is_valid = TRUE; 5304 if (!un->un_f_has_removable_media) { 5305 un->un_sys_blocksize = lbasize; 5306 } 5307 } 5308 5309 if (capacity != 0) { 5310 un->un_blockcount = capacity; 5311 un->un_f_blockcount_is_valid = TRUE; 5312 5313 /* 5314 * The capacity has changed so update the errstats. 5315 */ 5316 if (un->un_errstats != NULL) { 5317 struct sd_errstats *stp; 5318 5319 capacity *= un->un_sys_blocksize; 5320 stp = (struct sd_errstats *)un->un_errstats->ks_data; 5321 if (stp->sd_capacity.value.ui64 < capacity) 5322 stp->sd_capacity.value.ui64 = capacity; 5323 } 5324 } 5325 } 5326 5327 5328 /* 5329 * Function: sd_register_devid 5330 * 5331 * Description: This routine will obtain the device id information from the 5332 * target, obtain the serial number, and register the device 5333 * id with the ddi framework. 5334 * 5335 * Arguments: devi - the system's dev_info_t for the device. 5336 * un - driver soft state (unit) structure 5337 * reservation_flag - indicates if a reservation conflict 5338 * occurred during attach 5339 * 5340 * Context: Kernel Thread 5341 */ 5342 static void 5343 sd_register_devid(sd_ssc_t *ssc, dev_info_t *devi, int reservation_flag) 5344 { 5345 int rval = 0; 5346 uchar_t *inq80 = NULL; 5347 size_t inq80_len = MAX_INQUIRY_SIZE; 5348 size_t inq80_resid = 0; 5349 uchar_t *inq83 = NULL; 5350 size_t inq83_len = MAX_INQUIRY_SIZE; 5351 size_t inq83_resid = 0; 5352 int dlen, len; 5353 char *sn; 5354 struct sd_lun *un; 5355 5356 ASSERT(ssc != NULL); 5357 un = ssc->ssc_un; 5358 ASSERT(un != NULL); 5359 ASSERT(mutex_owned(SD_MUTEX(un))); 5360 ASSERT((SD_DEVINFO(un)) == devi); 5361 5362 5363 /* 5364 * We check the availability of the World Wide Name (0x83) and Unit 5365 * Serial Number (0x80) pages in sd_check_vpd_page_support(), and using 5366 * un_vpd_page_mask from them, we decide which way to get the WWN. If 5367 * 0x83 is available, that is the best choice. Our next choice is 5368 * 0x80. If neither are available, we munge the devid from the device 5369 * vid/pid/serial # for Sun qualified disks, or use the ddi framework 5370 * to fabricate a devid for non-Sun qualified disks. 5371 */ 5372 if (sd_check_vpd_page_support(ssc) == 0) { 5373 /* collect page 80 data if available */ 5374 if (un->un_vpd_page_mask & SD_VPD_UNIT_SERIAL_PG) { 5375 5376 mutex_exit(SD_MUTEX(un)); 5377 inq80 = kmem_zalloc(inq80_len, KM_SLEEP); 5378 5379 rval = sd_send_scsi_INQUIRY(ssc, inq80, inq80_len, 5380 0x01, 0x80, &inq80_resid); 5381 5382 if (rval != 0) { 5383 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 5384 kmem_free(inq80, inq80_len); 5385 inq80 = NULL; 5386 inq80_len = 0; 5387 } else if (ddi_prop_exists( 5388 DDI_DEV_T_NONE, SD_DEVINFO(un), 5389 DDI_PROP_NOTPROM | DDI_PROP_DONTPASS, 5390 INQUIRY_SERIAL_NO) == 0) { 5391 /* 5392 * If we don't already have a serial number 5393 * property, do quick verify of data returned 5394 * and define property. 5395 */ 5396 dlen = inq80_len - inq80_resid; 5397 len = (size_t)inq80[3]; 5398 if ((dlen >= 4) && ((len + 4) <= dlen)) { 5399 /* 5400 * Ensure sn termination, skip leading 5401 * blanks, and create property 5402 * 'inquiry-serial-no'. 5403 */ 5404 sn = (char *)&inq80[4]; 5405 sn[len] = 0; 5406 while (*sn && (*sn == ' ')) 5407 sn++; 5408 if (*sn) { 5409 (void) ddi_prop_update_string( 5410 DDI_DEV_T_NONE, 5411 SD_DEVINFO(un), 5412 INQUIRY_SERIAL_NO, sn); 5413 } 5414 } 5415 } 5416 mutex_enter(SD_MUTEX(un)); 5417 } 5418 5419 /* collect page 83 data if available */ 5420 if (un->un_vpd_page_mask & SD_VPD_DEVID_WWN_PG) { 5421 mutex_exit(SD_MUTEX(un)); 5422 inq83 = kmem_zalloc(inq83_len, KM_SLEEP); 5423 5424 rval = sd_send_scsi_INQUIRY(ssc, inq83, inq83_len, 5425 0x01, 0x83, &inq83_resid); 5426 5427 if (rval != 0) { 5428 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 5429 kmem_free(inq83, inq83_len); 5430 inq83 = NULL; 5431 inq83_len = 0; 5432 } 5433 mutex_enter(SD_MUTEX(un)); 5434 } 5435 } 5436 5437 /* 5438 * If transport has already registered a devid for this target 5439 * then that takes precedence over the driver's determination 5440 * of the devid. 5441 * 5442 * NOTE: The reason this check is done here instead of at the beginning 5443 * of the function is to allow the code above to create the 5444 * 'inquiry-serial-no' property. 5445 */ 5446 if (ddi_devid_get(SD_DEVINFO(un), &un->un_devid) == DDI_SUCCESS) { 5447 ASSERT(un->un_devid); 5448 un->un_f_devid_transport_defined = TRUE; 5449 goto cleanup; /* use devid registered by the transport */ 5450 } 5451 5452 /* 5453 * This is the case of antiquated Sun disk drives that have the 5454 * FAB_DEVID property set in the disk_table. These drives 5455 * manage the devid's by storing them in last 2 available sectors 5456 * on the drive and have them fabricated by the ddi layer by calling 5457 * ddi_devid_init and passing the DEVID_FAB flag. 5458 */ 5459 if (un->un_f_opt_fab_devid == TRUE) { 5460 /* 5461 * Depending on EINVAL isn't reliable, since a reserved disk 5462 * may result in invalid geometry, so check to make sure a 5463 * reservation conflict did not occur during attach. 5464 */ 5465 if ((sd_get_devid(ssc) == EINVAL) && 5466 (reservation_flag != SD_TARGET_IS_RESERVED)) { 5467 /* 5468 * The devid is invalid AND there is no reservation 5469 * conflict. Fabricate a new devid. 5470 */ 5471 (void) sd_create_devid(ssc); 5472 } 5473 5474 /* Register the devid if it exists */ 5475 if (un->un_devid != NULL) { 5476 (void) ddi_devid_register(SD_DEVINFO(un), 5477 un->un_devid); 5478 SD_INFO(SD_LOG_ATTACH_DETACH, un, 5479 "sd_register_devid: Devid Fabricated\n"); 5480 } 5481 goto cleanup; 5482 } 5483 5484 /* encode best devid possible based on data available */ 5485 if (ddi_devid_scsi_encode(DEVID_SCSI_ENCODE_VERSION_LATEST, 5486 (char *)ddi_driver_name(SD_DEVINFO(un)), 5487 (uchar_t *)SD_INQUIRY(un), sizeof (*SD_INQUIRY(un)), 5488 inq80, inq80_len - inq80_resid, inq83, inq83_len - 5489 inq83_resid, &un->un_devid) == DDI_SUCCESS) { 5490 5491 /* devid successfully encoded, register devid */ 5492 (void) ddi_devid_register(SD_DEVINFO(un), un->un_devid); 5493 5494 } else { 5495 /* 5496 * Unable to encode a devid based on data available. 5497 * This is not a Sun qualified disk. Older Sun disk 5498 * drives that have the SD_FAB_DEVID property 5499 * set in the disk_table and non Sun qualified 5500 * disks are treated in the same manner. These 5501 * drives manage the devid's by storing them in 5502 * last 2 available sectors on the drive and 5503 * have them fabricated by the ddi layer by 5504 * calling ddi_devid_init and passing the 5505 * DEVID_FAB flag. 5506 * Create a fabricate devid only if there's no 5507 * fabricate devid existed. 5508 */ 5509 if (sd_get_devid(ssc) == EINVAL) { 5510 (void) sd_create_devid(ssc); 5511 } 5512 un->un_f_opt_fab_devid = TRUE; 5513 5514 /* Register the devid if it exists */ 5515 if (un->un_devid != NULL) { 5516 (void) ddi_devid_register(SD_DEVINFO(un), 5517 un->un_devid); 5518 SD_INFO(SD_LOG_ATTACH_DETACH, un, 5519 "sd_register_devid: devid fabricated using " 5520 "ddi framework\n"); 5521 } 5522 } 5523 5524 cleanup: 5525 /* clean up resources */ 5526 if (inq80 != NULL) { 5527 kmem_free(inq80, inq80_len); 5528 } 5529 if (inq83 != NULL) { 5530 kmem_free(inq83, inq83_len); 5531 } 5532 } 5533 5534 5535 5536 /* 5537 * Function: sd_get_devid 5538 * 5539 * Description: This routine will return 0 if a valid device id has been 5540 * obtained from the target and stored in the soft state. If a 5541 * valid device id has not been previously read and stored, a 5542 * read attempt will be made. 5543 * 5544 * Arguments: un - driver soft state (unit) structure 5545 * 5546 * Return Code: 0 if we successfully get the device id 5547 * 5548 * Context: Kernel Thread 5549 */ 5550 5551 static int 5552 sd_get_devid(sd_ssc_t *ssc) 5553 { 5554 struct dk_devid *dkdevid; 5555 ddi_devid_t tmpid; 5556 uint_t *ip; 5557 size_t sz; 5558 diskaddr_t blk; 5559 int status; 5560 int chksum; 5561 int i; 5562 size_t buffer_size; 5563 struct sd_lun *un; 5564 5565 ASSERT(ssc != NULL); 5566 un = ssc->ssc_un; 5567 ASSERT(un != NULL); 5568 ASSERT(mutex_owned(SD_MUTEX(un))); 5569 5570 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_get_devid: entry: un: 0x%p\n", 5571 un); 5572 5573 if (un->un_devid != NULL) { 5574 return (0); 5575 } 5576 5577 mutex_exit(SD_MUTEX(un)); 5578 if (cmlb_get_devid_block(un->un_cmlbhandle, &blk, 5579 (void *)SD_PATH_DIRECT) != 0) { 5580 mutex_enter(SD_MUTEX(un)); 5581 return (EINVAL); 5582 } 5583 5584 /* 5585 * Read and verify device id, stored in the reserved cylinders at the 5586 * end of the disk. Backup label is on the odd sectors of the last 5587 * track of the last cylinder. Device id will be on track of the next 5588 * to last cylinder. 5589 */ 5590 mutex_enter(SD_MUTEX(un)); 5591 buffer_size = SD_REQBYTES2TGTBYTES(un, sizeof (struct dk_devid)); 5592 mutex_exit(SD_MUTEX(un)); 5593 dkdevid = kmem_alloc(buffer_size, KM_SLEEP); 5594 status = sd_send_scsi_READ(ssc, dkdevid, buffer_size, blk, 5595 SD_PATH_DIRECT); 5596 5597 if (status != 0) { 5598 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 5599 goto error; 5600 } 5601 5602 /* Validate the revision */ 5603 if ((dkdevid->dkd_rev_hi != DK_DEVID_REV_MSB) || 5604 (dkdevid->dkd_rev_lo != DK_DEVID_REV_LSB)) { 5605 status = EINVAL; 5606 goto error; 5607 } 5608 5609 /* Calculate the checksum */ 5610 chksum = 0; 5611 ip = (uint_t *)dkdevid; 5612 for (i = 0; i < ((DEV_BSIZE - sizeof (int)) / sizeof (int)); 5613 i++) { 5614 chksum ^= ip[i]; 5615 } 5616 5617 /* Compare the checksums */ 5618 if (DKD_GETCHKSUM(dkdevid) != chksum) { 5619 status = EINVAL; 5620 goto error; 5621 } 5622 5623 /* Validate the device id */ 5624 if (ddi_devid_valid((ddi_devid_t)&dkdevid->dkd_devid) != DDI_SUCCESS) { 5625 status = EINVAL; 5626 goto error; 5627 } 5628 5629 /* 5630 * Store the device id in the driver soft state 5631 */ 5632 sz = ddi_devid_sizeof((ddi_devid_t)&dkdevid->dkd_devid); 5633 tmpid = kmem_alloc(sz, KM_SLEEP); 5634 5635 mutex_enter(SD_MUTEX(un)); 5636 5637 un->un_devid = tmpid; 5638 bcopy(&dkdevid->dkd_devid, un->un_devid, sz); 5639 5640 kmem_free(dkdevid, buffer_size); 5641 5642 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_get_devid: exit: un:0x%p\n", un); 5643 5644 return (status); 5645 error: 5646 mutex_enter(SD_MUTEX(un)); 5647 kmem_free(dkdevid, buffer_size); 5648 return (status); 5649 } 5650 5651 5652 /* 5653 * Function: sd_create_devid 5654 * 5655 * Description: This routine will fabricate the device id and write it 5656 * to the disk. 5657 * 5658 * Arguments: un - driver soft state (unit) structure 5659 * 5660 * Return Code: value of the fabricated device id 5661 * 5662 * Context: Kernel Thread 5663 */ 5664 5665 static ddi_devid_t 5666 sd_create_devid(sd_ssc_t *ssc) 5667 { 5668 struct sd_lun *un; 5669 5670 ASSERT(ssc != NULL); 5671 un = ssc->ssc_un; 5672 ASSERT(un != NULL); 5673 5674 /* Fabricate the devid */ 5675 if (ddi_devid_init(SD_DEVINFO(un), DEVID_FAB, 0, NULL, &un->un_devid) 5676 == DDI_FAILURE) { 5677 return (NULL); 5678 } 5679 5680 /* Write the devid to disk */ 5681 if (sd_write_deviceid(ssc) != 0) { 5682 ddi_devid_free(un->un_devid); 5683 un->un_devid = NULL; 5684 } 5685 5686 return (un->un_devid); 5687 } 5688 5689 5690 /* 5691 * Function: sd_write_deviceid 5692 * 5693 * Description: This routine will write the device id to the disk 5694 * reserved sector. 5695 * 5696 * Arguments: un - driver soft state (unit) structure 5697 * 5698 * Return Code: EINVAL 5699 * value returned by sd_send_scsi_cmd 5700 * 5701 * Context: Kernel Thread 5702 */ 5703 5704 static int 5705 sd_write_deviceid(sd_ssc_t *ssc) 5706 { 5707 struct dk_devid *dkdevid; 5708 uchar_t *buf; 5709 diskaddr_t blk; 5710 uint_t *ip, chksum; 5711 int status; 5712 int i; 5713 struct sd_lun *un; 5714 5715 ASSERT(ssc != NULL); 5716 un = ssc->ssc_un; 5717 ASSERT(un != NULL); 5718 ASSERT(mutex_owned(SD_MUTEX(un))); 5719 5720 mutex_exit(SD_MUTEX(un)); 5721 if (cmlb_get_devid_block(un->un_cmlbhandle, &blk, 5722 (void *)SD_PATH_DIRECT) != 0) { 5723 mutex_enter(SD_MUTEX(un)); 5724 return (-1); 5725 } 5726 5727 5728 /* Allocate the buffer */ 5729 buf = kmem_zalloc(un->un_sys_blocksize, KM_SLEEP); 5730 dkdevid = (struct dk_devid *)buf; 5731 5732 /* Fill in the revision */ 5733 dkdevid->dkd_rev_hi = DK_DEVID_REV_MSB; 5734 dkdevid->dkd_rev_lo = DK_DEVID_REV_LSB; 5735 5736 /* Copy in the device id */ 5737 mutex_enter(SD_MUTEX(un)); 5738 bcopy(un->un_devid, &dkdevid->dkd_devid, 5739 ddi_devid_sizeof(un->un_devid)); 5740 mutex_exit(SD_MUTEX(un)); 5741 5742 /* Calculate the checksum */ 5743 chksum = 0; 5744 ip = (uint_t *)dkdevid; 5745 for (i = 0; i < ((DEV_BSIZE - sizeof (int)) / sizeof (int)); 5746 i++) { 5747 chksum ^= ip[i]; 5748 } 5749 5750 /* Fill-in checksum */ 5751 DKD_FORMCHKSUM(chksum, dkdevid); 5752 5753 /* Write the reserved sector */ 5754 status = sd_send_scsi_WRITE(ssc, buf, un->un_sys_blocksize, blk, 5755 SD_PATH_DIRECT); 5756 if (status != 0) 5757 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 5758 5759 kmem_free(buf, un->un_sys_blocksize); 5760 5761 mutex_enter(SD_MUTEX(un)); 5762 return (status); 5763 } 5764 5765 5766 /* 5767 * Function: sd_check_vpd_page_support 5768 * 5769 * Description: This routine sends an inquiry command with the EVPD bit set and 5770 * a page code of 0x00 to the device. It is used to determine which 5771 * vital product pages are available to find the devid. We are 5772 * looking for pages 0x83 0x80 or 0xB1. If we return a negative 1, 5773 * the device does not support that command. 5774 * 5775 * Arguments: un - driver soft state (unit) structure 5776 * 5777 * Return Code: 0 - success 5778 * 1 - check condition 5779 * 5780 * Context: This routine can sleep. 5781 */ 5782 5783 static int 5784 sd_check_vpd_page_support(sd_ssc_t *ssc) 5785 { 5786 uchar_t *page_list = NULL; 5787 uchar_t page_length = 0xff; /* Use max possible length */ 5788 uchar_t evpd = 0x01; /* Set the EVPD bit */ 5789 uchar_t page_code = 0x00; /* Supported VPD Pages */ 5790 int rval = 0; 5791 int counter; 5792 struct sd_lun *un; 5793 5794 ASSERT(ssc != NULL); 5795 un = ssc->ssc_un; 5796 ASSERT(un != NULL); 5797 ASSERT(mutex_owned(SD_MUTEX(un))); 5798 5799 mutex_exit(SD_MUTEX(un)); 5800 5801 /* 5802 * We'll set the page length to the maximum to save figuring it out 5803 * with an additional call. 5804 */ 5805 page_list = kmem_zalloc(page_length, KM_SLEEP); 5806 5807 rval = sd_send_scsi_INQUIRY(ssc, page_list, page_length, evpd, 5808 page_code, NULL); 5809 5810 if (rval != 0) 5811 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 5812 5813 mutex_enter(SD_MUTEX(un)); 5814 5815 /* 5816 * Now we must validate that the device accepted the command, as some 5817 * drives do not support it. If the drive does support it, we will 5818 * return 0, and the supported pages will be in un_vpd_page_mask. If 5819 * not, we return -1. 5820 */ 5821 if ((rval == 0) && (page_list[VPD_MODE_PAGE] == 0x00)) { 5822 /* Loop to find one of the 2 pages we need */ 5823 counter = 4; /* Supported pages start at byte 4, with 0x00 */ 5824 5825 /* 5826 * Pages are returned in ascending order, and 0x83 is what we 5827 * are hoping for. 5828 */ 5829 while ((page_list[counter] <= 0xB1) && 5830 (counter <= (page_list[VPD_PAGE_LENGTH] + 5831 VPD_HEAD_OFFSET))) { 5832 /* 5833 * Add 3 because page_list[3] is the number of 5834 * pages minus 3 5835 */ 5836 5837 switch (page_list[counter]) { 5838 case 0x00: 5839 un->un_vpd_page_mask |= SD_VPD_SUPPORTED_PG; 5840 break; 5841 case 0x80: 5842 un->un_vpd_page_mask |= SD_VPD_UNIT_SERIAL_PG; 5843 break; 5844 case 0x81: 5845 un->un_vpd_page_mask |= SD_VPD_OPERATING_PG; 5846 break; 5847 case 0x82: 5848 un->un_vpd_page_mask |= SD_VPD_ASCII_OP_PG; 5849 break; 5850 case 0x83: 5851 un->un_vpd_page_mask |= SD_VPD_DEVID_WWN_PG; 5852 break; 5853 case 0x86: 5854 un->un_vpd_page_mask |= SD_VPD_EXTENDED_DATA_PG; 5855 break; 5856 case 0xB1: 5857 un->un_vpd_page_mask |= SD_VPD_DEV_CHARACTER_PG; 5858 break; 5859 } 5860 counter++; 5861 } 5862 5863 } else { 5864 rval = -1; 5865 5866 SD_INFO(SD_LOG_ATTACH_DETACH, un, 5867 "sd_check_vpd_page_support: This drive does not implement " 5868 "VPD pages.\n"); 5869 } 5870 5871 kmem_free(page_list, page_length); 5872 5873 return (rval); 5874 } 5875 5876 5877 /* 5878 * Function: sd_setup_pm 5879 * 5880 * Description: Initialize Power Management on the device 5881 * 5882 * Context: Kernel Thread 5883 */ 5884 5885 static void 5886 sd_setup_pm(sd_ssc_t *ssc, dev_info_t *devi) 5887 { 5888 uint_t log_page_size; 5889 uchar_t *log_page_data; 5890 int rval = 0; 5891 struct sd_lun *un; 5892 5893 ASSERT(ssc != NULL); 5894 un = ssc->ssc_un; 5895 ASSERT(un != NULL); 5896 5897 /* 5898 * Since we are called from attach, holding a mutex for 5899 * un is unnecessary. Because some of the routines called 5900 * from here require SD_MUTEX to not be held, assert this 5901 * right up front. 5902 */ 5903 ASSERT(!mutex_owned(SD_MUTEX(un))); 5904 /* 5905 * Since the sd device does not have the 'reg' property, 5906 * cpr will not call its DDI_SUSPEND/DDI_RESUME entries. 5907 * The following code is to tell cpr that this device 5908 * DOES need to be suspended and resumed. 5909 */ 5910 (void) ddi_prop_update_string(DDI_DEV_T_NONE, devi, 5911 "pm-hardware-state", "needs-suspend-resume"); 5912 5913 /* 5914 * This complies with the new power management framework 5915 * for certain desktop machines. Create the pm_components 5916 * property as a string array property. 5917 * If un_f_pm_supported is TRUE, that means the disk 5918 * attached HBA has set the "pm-capable" property and 5919 * the value of this property is bigger than 0. 5920 */ 5921 if (un->un_f_pm_supported) { 5922 /* 5923 * not all devices have a motor, try it first. 5924 * some devices may return ILLEGAL REQUEST, some 5925 * will hang 5926 * The following START_STOP_UNIT is used to check if target 5927 * device has a motor. 5928 */ 5929 un->un_f_start_stop_supported = TRUE; 5930 5931 if (un->un_f_power_condition_supported) { 5932 rval = sd_send_scsi_START_STOP_UNIT(ssc, 5933 SD_POWER_CONDITION, SD_TARGET_ACTIVE, 5934 SD_PATH_DIRECT); 5935 if (rval != 0) { 5936 un->un_f_power_condition_supported = FALSE; 5937 } 5938 } 5939 if (!un->un_f_power_condition_supported) { 5940 rval = sd_send_scsi_START_STOP_UNIT(ssc, 5941 SD_START_STOP, SD_TARGET_START, SD_PATH_DIRECT); 5942 } 5943 if (rval != 0) { 5944 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 5945 un->un_f_start_stop_supported = FALSE; 5946 } 5947 5948 /* 5949 * create pm properties anyways otherwise the parent can't 5950 * go to sleep 5951 */ 5952 un->un_f_pm_is_enabled = TRUE; 5953 (void) sd_create_pm_components(devi, un); 5954 5955 /* 5956 * If it claims that log sense is supported, check it out. 5957 */ 5958 if (un->un_f_log_sense_supported) { 5959 rval = sd_log_page_supported(ssc, 5960 START_STOP_CYCLE_PAGE); 5961 if (rval == 1) { 5962 /* Page found, use it. */ 5963 un->un_start_stop_cycle_page = 5964 START_STOP_CYCLE_PAGE; 5965 } else { 5966 /* 5967 * Page not found or log sense is not 5968 * supported. 5969 * Notice we do not check the old style 5970 * START_STOP_CYCLE_VU_PAGE because this 5971 * code path does not apply to old disks. 5972 */ 5973 un->un_f_log_sense_supported = FALSE; 5974 un->un_f_pm_log_sense_smart = FALSE; 5975 } 5976 } 5977 5978 return; 5979 } 5980 5981 /* 5982 * For the disk whose attached HBA has not set the "pm-capable" 5983 * property, check if it supports the power management. 5984 */ 5985 if (!un->un_f_log_sense_supported) { 5986 un->un_power_level = SD_SPINDLE_ON; 5987 un->un_f_pm_is_enabled = FALSE; 5988 return; 5989 } 5990 5991 rval = sd_log_page_supported(ssc, START_STOP_CYCLE_PAGE); 5992 5993 #ifdef SDDEBUG 5994 if (sd_force_pm_supported) { 5995 /* Force a successful result */ 5996 rval = 1; 5997 } 5998 #endif 5999 6000 /* 6001 * If the start-stop cycle counter log page is not supported 6002 * or if the pm-capable property is set to be false (0), 6003 * then we should not create the pm_components property. 6004 */ 6005 if (rval == -1) { 6006 /* 6007 * Error. 6008 * Reading log sense failed, most likely this is 6009 * an older drive that does not support log sense. 6010 * If this fails auto-pm is not supported. 6011 */ 6012 un->un_power_level = SD_SPINDLE_ON; 6013 un->un_f_pm_is_enabled = FALSE; 6014 6015 } else if (rval == 0) { 6016 /* 6017 * Page not found. 6018 * The start stop cycle counter is implemented as page 6019 * START_STOP_CYCLE_PAGE_VU_PAGE (0x31) in older disks. For 6020 * newer disks it is implemented as START_STOP_CYCLE_PAGE (0xE). 6021 */ 6022 if (sd_log_page_supported(ssc, START_STOP_CYCLE_VU_PAGE) == 1) { 6023 /* 6024 * Page found, use this one. 6025 */ 6026 un->un_start_stop_cycle_page = START_STOP_CYCLE_VU_PAGE; 6027 un->un_f_pm_is_enabled = TRUE; 6028 } else { 6029 /* 6030 * Error or page not found. 6031 * auto-pm is not supported for this device. 6032 */ 6033 un->un_power_level = SD_SPINDLE_ON; 6034 un->un_f_pm_is_enabled = FALSE; 6035 } 6036 } else { 6037 /* 6038 * Page found, use it. 6039 */ 6040 un->un_start_stop_cycle_page = START_STOP_CYCLE_PAGE; 6041 un->un_f_pm_is_enabled = TRUE; 6042 } 6043 6044 6045 if (un->un_f_pm_is_enabled == TRUE) { 6046 log_page_size = START_STOP_CYCLE_COUNTER_PAGE_SIZE; 6047 log_page_data = kmem_zalloc(log_page_size, KM_SLEEP); 6048 6049 rval = sd_send_scsi_LOG_SENSE(ssc, log_page_data, 6050 log_page_size, un->un_start_stop_cycle_page, 6051 0x01, 0, SD_PATH_DIRECT); 6052 6053 if (rval != 0) { 6054 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 6055 } 6056 6057 #ifdef SDDEBUG 6058 if (sd_force_pm_supported) { 6059 /* Force a successful result */ 6060 rval = 0; 6061 } 6062 #endif 6063 6064 /* 6065 * If the Log sense for Page( Start/stop cycle counter page) 6066 * succeeds, then power management is supported and we can 6067 * enable auto-pm. 6068 */ 6069 if (rval == 0) { 6070 (void) sd_create_pm_components(devi, un); 6071 } else { 6072 un->un_power_level = SD_SPINDLE_ON; 6073 un->un_f_pm_is_enabled = FALSE; 6074 } 6075 6076 kmem_free(log_page_data, log_page_size); 6077 } 6078 } 6079 6080 6081 /* 6082 * Function: sd_create_pm_components 6083 * 6084 * Description: Initialize PM property. 6085 * 6086 * Context: Kernel thread context 6087 */ 6088 6089 static void 6090 sd_create_pm_components(dev_info_t *devi, struct sd_lun *un) 6091 { 6092 ASSERT(!mutex_owned(SD_MUTEX(un))); 6093 6094 if (un->un_f_power_condition_supported) { 6095 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, devi, 6096 "pm-components", sd_pwr_pc.pm_comp, 5) 6097 != DDI_PROP_SUCCESS) { 6098 un->un_power_level = SD_SPINDLE_ACTIVE; 6099 un->un_f_pm_is_enabled = FALSE; 6100 return; 6101 } 6102 } else { 6103 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, devi, 6104 "pm-components", sd_pwr_ss.pm_comp, 3) 6105 != DDI_PROP_SUCCESS) { 6106 un->un_power_level = SD_SPINDLE_ON; 6107 un->un_f_pm_is_enabled = FALSE; 6108 return; 6109 } 6110 } 6111 /* 6112 * When components are initially created they are idle, 6113 * power up any non-removables. 6114 * Note: the return value of pm_raise_power can't be used 6115 * for determining if PM should be enabled for this device. 6116 * Even if you check the return values and remove this 6117 * property created above, the PM framework will not honor the 6118 * change after the first call to pm_raise_power. Hence, 6119 * removal of that property does not help if pm_raise_power 6120 * fails. In the case of removable media, the start/stop 6121 * will fail if the media is not present. 6122 */ 6123 if (un->un_f_attach_spinup && (pm_raise_power(SD_DEVINFO(un), 0, 6124 SD_PM_STATE_ACTIVE(un)) == DDI_SUCCESS)) { 6125 mutex_enter(SD_MUTEX(un)); 6126 un->un_power_level = SD_PM_STATE_ACTIVE(un); 6127 mutex_enter(&un->un_pm_mutex); 6128 /* Set to on and not busy. */ 6129 un->un_pm_count = 0; 6130 } else { 6131 mutex_enter(SD_MUTEX(un)); 6132 un->un_power_level = SD_PM_STATE_STOPPED(un); 6133 mutex_enter(&un->un_pm_mutex); 6134 /* Set to off. */ 6135 un->un_pm_count = -1; 6136 } 6137 mutex_exit(&un->un_pm_mutex); 6138 mutex_exit(SD_MUTEX(un)); 6139 } 6140 6141 6142 /* 6143 * Function: sd_ddi_suspend 6144 * 6145 * Description: Performs system power-down operations. This includes 6146 * setting the drive state to indicate its suspended so 6147 * that no new commands will be accepted. Also, wait for 6148 * all commands that are in transport or queued to a timer 6149 * for retry to complete. All timeout threads are cancelled. 6150 * 6151 * Return Code: DDI_FAILURE or DDI_SUCCESS 6152 * 6153 * Context: Kernel thread context 6154 */ 6155 6156 static int 6157 sd_ddi_suspend(dev_info_t *devi) 6158 { 6159 struct sd_lun *un; 6160 clock_t wait_cmds_complete; 6161 6162 un = ddi_get_soft_state(sd_state, ddi_get_instance(devi)); 6163 if (un == NULL) { 6164 return (DDI_FAILURE); 6165 } 6166 6167 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: entry\n"); 6168 6169 mutex_enter(SD_MUTEX(un)); 6170 6171 /* Return success if the device is already suspended. */ 6172 if (un->un_state == SD_STATE_SUSPENDED) { 6173 mutex_exit(SD_MUTEX(un)); 6174 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: " 6175 "device already suspended, exiting\n"); 6176 return (DDI_SUCCESS); 6177 } 6178 6179 /* Return failure if the device is being used by HA */ 6180 if (un->un_resvd_status & 6181 (SD_RESERVE | SD_WANT_RESERVE | SD_LOST_RESERVE)) { 6182 mutex_exit(SD_MUTEX(un)); 6183 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: " 6184 "device in use by HA, exiting\n"); 6185 return (DDI_FAILURE); 6186 } 6187 6188 /* 6189 * Return failure if the device is in a resource wait 6190 * or power changing state. 6191 */ 6192 if ((un->un_state == SD_STATE_RWAIT) || 6193 (un->un_state == SD_STATE_PM_CHANGING)) { 6194 mutex_exit(SD_MUTEX(un)); 6195 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: " 6196 "device in resource wait state, exiting\n"); 6197 return (DDI_FAILURE); 6198 } 6199 6200 6201 un->un_save_state = un->un_last_state; 6202 New_state(un, SD_STATE_SUSPENDED); 6203 6204 /* 6205 * Wait for all commands that are in transport or queued to a timer 6206 * for retry to complete. 6207 * 6208 * While waiting, no new commands will be accepted or sent because of 6209 * the new state we set above. 6210 * 6211 * Wait till current operation has completed. If we are in the resource 6212 * wait state (with an intr outstanding) then we need to wait till the 6213 * intr completes and starts the next cmd. We want to wait for 6214 * SD_WAIT_CMDS_COMPLETE seconds before failing the DDI_SUSPEND. 6215 */ 6216 wait_cmds_complete = ddi_get_lbolt() + 6217 drv_sectohz(sd_wait_cmds_complete); 6218 6219 while (un->un_ncmds_in_transport != 0) { 6220 /* 6221 * Fail if commands do not finish in the specified time. 6222 */ 6223 if (cv_timedwait(&un->un_disk_busy_cv, SD_MUTEX(un), 6224 wait_cmds_complete) == -1) { 6225 /* 6226 * Undo the state changes made above. Everything 6227 * must go back to it's original value. 6228 */ 6229 Restore_state(un); 6230 un->un_last_state = un->un_save_state; 6231 /* Wake up any threads that might be waiting. */ 6232 cv_broadcast(&un->un_suspend_cv); 6233 mutex_exit(SD_MUTEX(un)); 6234 SD_ERROR(SD_LOG_IO_PM, un, 6235 "sd_ddi_suspend: failed due to outstanding cmds\n"); 6236 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: exiting\n"); 6237 return (DDI_FAILURE); 6238 } 6239 } 6240 6241 /* 6242 * Cancel SCSI watch thread and timeouts, if any are active 6243 */ 6244 6245 if (SD_OK_TO_SUSPEND_SCSI_WATCHER(un)) { 6246 opaque_t temp_token = un->un_swr_token; 6247 mutex_exit(SD_MUTEX(un)); 6248 scsi_watch_suspend(temp_token); 6249 mutex_enter(SD_MUTEX(un)); 6250 } 6251 6252 if (un->un_reset_throttle_timeid != NULL) { 6253 timeout_id_t temp_id = un->un_reset_throttle_timeid; 6254 un->un_reset_throttle_timeid = NULL; 6255 mutex_exit(SD_MUTEX(un)); 6256 (void) untimeout(temp_id); 6257 mutex_enter(SD_MUTEX(un)); 6258 } 6259 6260 if (un->un_dcvb_timeid != NULL) { 6261 timeout_id_t temp_id = un->un_dcvb_timeid; 6262 un->un_dcvb_timeid = NULL; 6263 mutex_exit(SD_MUTEX(un)); 6264 (void) untimeout(temp_id); 6265 mutex_enter(SD_MUTEX(un)); 6266 } 6267 6268 mutex_enter(&un->un_pm_mutex); 6269 if (un->un_pm_timeid != NULL) { 6270 timeout_id_t temp_id = un->un_pm_timeid; 6271 un->un_pm_timeid = NULL; 6272 mutex_exit(&un->un_pm_mutex); 6273 mutex_exit(SD_MUTEX(un)); 6274 (void) untimeout(temp_id); 6275 mutex_enter(SD_MUTEX(un)); 6276 } else { 6277 mutex_exit(&un->un_pm_mutex); 6278 } 6279 6280 if (un->un_rmw_msg_timeid != NULL) { 6281 timeout_id_t temp_id = un->un_rmw_msg_timeid; 6282 un->un_rmw_msg_timeid = NULL; 6283 mutex_exit(SD_MUTEX(un)); 6284 (void) untimeout(temp_id); 6285 mutex_enter(SD_MUTEX(un)); 6286 } 6287 6288 if (un->un_retry_timeid != NULL) { 6289 timeout_id_t temp_id = un->un_retry_timeid; 6290 un->un_retry_timeid = NULL; 6291 mutex_exit(SD_MUTEX(un)); 6292 (void) untimeout(temp_id); 6293 mutex_enter(SD_MUTEX(un)); 6294 6295 if (un->un_retry_bp != NULL) { 6296 un->un_retry_bp->av_forw = un->un_waitq_headp; 6297 un->un_waitq_headp = un->un_retry_bp; 6298 if (un->un_waitq_tailp == NULL) { 6299 un->un_waitq_tailp = un->un_retry_bp; 6300 } 6301 un->un_retry_bp = NULL; 6302 un->un_retry_statp = NULL; 6303 } 6304 } 6305 6306 if (un->un_direct_priority_timeid != NULL) { 6307 timeout_id_t temp_id = un->un_direct_priority_timeid; 6308 un->un_direct_priority_timeid = NULL; 6309 mutex_exit(SD_MUTEX(un)); 6310 (void) untimeout(temp_id); 6311 mutex_enter(SD_MUTEX(un)); 6312 } 6313 6314 if (un->un_f_is_fibre == TRUE) { 6315 /* 6316 * Remove callbacks for insert and remove events 6317 */ 6318 if (un->un_insert_event != NULL) { 6319 mutex_exit(SD_MUTEX(un)); 6320 (void) ddi_remove_event_handler(un->un_insert_cb_id); 6321 mutex_enter(SD_MUTEX(un)); 6322 un->un_insert_event = NULL; 6323 } 6324 6325 if (un->un_remove_event != NULL) { 6326 mutex_exit(SD_MUTEX(un)); 6327 (void) ddi_remove_event_handler(un->un_remove_cb_id); 6328 mutex_enter(SD_MUTEX(un)); 6329 un->un_remove_event = NULL; 6330 } 6331 } 6332 6333 mutex_exit(SD_MUTEX(un)); 6334 6335 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_suspend: exit\n"); 6336 6337 return (DDI_SUCCESS); 6338 } 6339 6340 6341 /* 6342 * Function: sd_ddi_resume 6343 * 6344 * Description: Performs system power-up operations.. 6345 * 6346 * Return Code: DDI_SUCCESS 6347 * DDI_FAILURE 6348 * 6349 * Context: Kernel thread context 6350 */ 6351 6352 static int 6353 sd_ddi_resume(dev_info_t *devi) 6354 { 6355 struct sd_lun *un; 6356 6357 un = ddi_get_soft_state(sd_state, ddi_get_instance(devi)); 6358 if (un == NULL) { 6359 return (DDI_FAILURE); 6360 } 6361 6362 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_resume: entry\n"); 6363 6364 mutex_enter(SD_MUTEX(un)); 6365 Restore_state(un); 6366 6367 /* 6368 * Restore the state which was saved to give the 6369 * the right state in un_last_state 6370 */ 6371 un->un_last_state = un->un_save_state; 6372 /* 6373 * Note: throttle comes back at full. 6374 * Also note: this MUST be done before calling pm_raise_power 6375 * otherwise the system can get hung in biowait. The scenario where 6376 * this'll happen is under cpr suspend. Writing of the system 6377 * state goes through sddump, which writes 0 to un_throttle. If 6378 * writing the system state then fails, example if the partition is 6379 * too small, then cpr attempts a resume. If throttle isn't restored 6380 * from the saved value until after calling pm_raise_power then 6381 * cmds sent in sdpower are not transported and sd_send_scsi_cmd hangs 6382 * in biowait. 6383 */ 6384 un->un_throttle = un->un_saved_throttle; 6385 6386 /* 6387 * The chance of failure is very rare as the only command done in power 6388 * entry point is START command when you transition from 0->1 or 6389 * unknown->1. Put it to SPINDLE ON state irrespective of the state at 6390 * which suspend was done. Ignore the return value as the resume should 6391 * not be failed. In the case of removable media the media need not be 6392 * inserted and hence there is a chance that raise power will fail with 6393 * media not present. 6394 */ 6395 if (un->un_f_attach_spinup) { 6396 mutex_exit(SD_MUTEX(un)); 6397 (void) pm_raise_power(SD_DEVINFO(un), 0, 6398 SD_PM_STATE_ACTIVE(un)); 6399 mutex_enter(SD_MUTEX(un)); 6400 } 6401 6402 /* 6403 * Don't broadcast to the suspend cv and therefore possibly 6404 * start I/O until after power has been restored. 6405 */ 6406 cv_broadcast(&un->un_suspend_cv); 6407 cv_broadcast(&un->un_state_cv); 6408 6409 /* restart thread */ 6410 if (SD_OK_TO_RESUME_SCSI_WATCHER(un)) { 6411 scsi_watch_resume(un->un_swr_token); 6412 } 6413 6414 #if (defined(__fibre)) 6415 if (un->un_f_is_fibre == TRUE) { 6416 /* 6417 * Add callbacks for insert and remove events 6418 */ 6419 if (strcmp(un->un_node_type, DDI_NT_BLOCK_CHAN)) { 6420 sd_init_event_callbacks(un); 6421 } 6422 } 6423 #endif 6424 6425 /* 6426 * Transport any pending commands to the target. 6427 * 6428 * If this is a low-activity device commands in queue will have to wait 6429 * until new commands come in, which may take awhile. Also, we 6430 * specifically don't check un_ncmds_in_transport because we know that 6431 * there really are no commands in progress after the unit was 6432 * suspended and we could have reached the throttle level, been 6433 * suspended, and have no new commands coming in for awhile. Highly 6434 * unlikely, but so is the low-activity disk scenario. 6435 */ 6436 ddi_xbuf_dispatch(un->un_xbuf_attr); 6437 6438 sd_start_cmds(un, NULL); 6439 mutex_exit(SD_MUTEX(un)); 6440 6441 SD_TRACE(SD_LOG_IO_PM, un, "sd_ddi_resume: exit\n"); 6442 6443 return (DDI_SUCCESS); 6444 } 6445 6446 6447 /* 6448 * Function: sd_pm_state_change 6449 * 6450 * Description: Change the driver power state. 6451 * Someone else is required to actually change the driver 6452 * power level. 6453 * 6454 * Arguments: un - driver soft state (unit) structure 6455 * level - the power level that is changed to 6456 * flag - to decide how to change the power state 6457 * 6458 * Return Code: DDI_SUCCESS 6459 * 6460 * Context: Kernel thread context 6461 */ 6462 static int 6463 sd_pm_state_change(struct sd_lun *un, int level, int flag) 6464 { 6465 ASSERT(un != NULL); 6466 SD_TRACE(SD_LOG_POWER, un, "sd_pm_state_change: entry\n"); 6467 6468 ASSERT(!mutex_owned(SD_MUTEX(un))); 6469 mutex_enter(SD_MUTEX(un)); 6470 6471 if (flag == SD_PM_STATE_ROLLBACK || SD_PM_IS_IO_CAPABLE(un, level)) { 6472 un->un_power_level = level; 6473 ASSERT(!mutex_owned(&un->un_pm_mutex)); 6474 mutex_enter(&un->un_pm_mutex); 6475 if (SD_DEVICE_IS_IN_LOW_POWER(un)) { 6476 un->un_pm_count++; 6477 ASSERT(un->un_pm_count == 0); 6478 } 6479 mutex_exit(&un->un_pm_mutex); 6480 } else { 6481 /* 6482 * Exit if power management is not enabled for this device, 6483 * or if the device is being used by HA. 6484 */ 6485 if ((un->un_f_pm_is_enabled == FALSE) || (un->un_resvd_status & 6486 (SD_RESERVE | SD_WANT_RESERVE | SD_LOST_RESERVE))) { 6487 mutex_exit(SD_MUTEX(un)); 6488 SD_TRACE(SD_LOG_POWER, un, 6489 "sd_pm_state_change: exiting\n"); 6490 return (DDI_FAILURE); 6491 } 6492 6493 SD_INFO(SD_LOG_POWER, un, "sd_pm_state_change: " 6494 "un_ncmds_in_driver=%ld\n", un->un_ncmds_in_driver); 6495 6496 /* 6497 * See if the device is not busy, ie.: 6498 * - we have no commands in the driver for this device 6499 * - not waiting for resources 6500 */ 6501 if ((un->un_ncmds_in_driver == 0) && 6502 (un->un_state != SD_STATE_RWAIT)) { 6503 /* 6504 * The device is not busy, so it is OK to go to low 6505 * power state. Indicate low power, but rely on someone 6506 * else to actually change it. 6507 */ 6508 mutex_enter(&un->un_pm_mutex); 6509 un->un_pm_count = -1; 6510 mutex_exit(&un->un_pm_mutex); 6511 un->un_power_level = level; 6512 } 6513 } 6514 6515 mutex_exit(SD_MUTEX(un)); 6516 6517 SD_TRACE(SD_LOG_POWER, un, "sd_pm_state_change: exit\n"); 6518 6519 return (DDI_SUCCESS); 6520 } 6521 6522 6523 /* 6524 * Function: sd_pm_idletimeout_handler 6525 * 6526 * Description: A timer routine that's active only while a device is busy. 6527 * The purpose is to extend slightly the pm framework's busy 6528 * view of the device to prevent busy/idle thrashing for 6529 * back-to-back commands. Do this by comparing the current time 6530 * to the time at which the last command completed and when the 6531 * difference is greater than sd_pm_idletime, call 6532 * pm_idle_component. In addition to indicating idle to the pm 6533 * framework, update the chain type to again use the internal pm 6534 * layers of the driver. 6535 * 6536 * Arguments: arg - driver soft state (unit) structure 6537 * 6538 * Context: Executes in a timeout(9F) thread context 6539 */ 6540 6541 static void 6542 sd_pm_idletimeout_handler(void *arg) 6543 { 6544 const hrtime_t idletime = sd_pm_idletime * NANOSEC; 6545 struct sd_lun *un = arg; 6546 6547 mutex_enter(&sd_detach_mutex); 6548 if (un->un_detach_count != 0) { 6549 /* Abort if the instance is detaching */ 6550 mutex_exit(&sd_detach_mutex); 6551 return; 6552 } 6553 mutex_exit(&sd_detach_mutex); 6554 6555 /* 6556 * Grab both mutexes, in the proper order, since we're accessing 6557 * both PM and softstate variables. 6558 */ 6559 mutex_enter(SD_MUTEX(un)); 6560 mutex_enter(&un->un_pm_mutex); 6561 if (((gethrtime() - un->un_pm_idle_time) > idletime) && 6562 (un->un_ncmds_in_driver == 0) && (un->un_pm_count == 0)) { 6563 /* 6564 * Update the chain types. 6565 * This takes affect on the next new command received. 6566 */ 6567 if (un->un_f_non_devbsize_supported) { 6568 un->un_buf_chain_type = SD_CHAIN_INFO_RMMEDIA; 6569 } else { 6570 un->un_buf_chain_type = SD_CHAIN_INFO_DISK; 6571 } 6572 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD; 6573 6574 SD_TRACE(SD_LOG_IO_PM, un, 6575 "sd_pm_idletimeout_handler: idling device\n"); 6576 (void) pm_idle_component(SD_DEVINFO(un), 0); 6577 un->un_pm_idle_timeid = NULL; 6578 } else { 6579 un->un_pm_idle_timeid = 6580 timeout(sd_pm_idletimeout_handler, un, 6581 (drv_usectohz((clock_t)300000))); /* 300 ms. */ 6582 } 6583 mutex_exit(&un->un_pm_mutex); 6584 mutex_exit(SD_MUTEX(un)); 6585 } 6586 6587 6588 /* 6589 * Function: sd_pm_timeout_handler 6590 * 6591 * Description: Callback to tell framework we are idle. 6592 * 6593 * Context: timeout(9f) thread context. 6594 */ 6595 6596 static void 6597 sd_pm_timeout_handler(void *arg) 6598 { 6599 struct sd_lun *un = arg; 6600 6601 (void) pm_idle_component(SD_DEVINFO(un), 0); 6602 mutex_enter(&un->un_pm_mutex); 6603 un->un_pm_timeid = NULL; 6604 mutex_exit(&un->un_pm_mutex); 6605 } 6606 6607 6608 /* 6609 * Function: sdpower 6610 * 6611 * Description: PM entry point. 6612 * 6613 * Return Code: DDI_SUCCESS 6614 * DDI_FAILURE 6615 * 6616 * Context: Kernel thread context 6617 */ 6618 6619 static int 6620 sdpower(dev_info_t *devi, int component, int level) 6621 { 6622 struct sd_lun *un; 6623 int instance; 6624 int rval = DDI_SUCCESS; 6625 uint_t i, log_page_size, maxcycles, ncycles; 6626 uchar_t *log_page_data; 6627 int log_sense_page; 6628 int medium_present; 6629 time_t intvlp; 6630 struct pm_trans_data sd_pm_tran_data; 6631 uchar_t save_state; 6632 int sval; 6633 uchar_t state_before_pm; 6634 int got_semaphore_here; 6635 sd_ssc_t *ssc; 6636 int last_power_level; 6637 6638 instance = ddi_get_instance(devi); 6639 6640 if (((un = ddi_get_soft_state(sd_state, instance)) == NULL) || 6641 !SD_PM_IS_LEVEL_VALID(un, level) || component != 0) { 6642 return (DDI_FAILURE); 6643 } 6644 6645 ssc = sd_ssc_init(un); 6646 6647 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: entry, level = %d\n", level); 6648 6649 /* 6650 * Must synchronize power down with close. 6651 * Attempt to decrement/acquire the open/close semaphore, 6652 * but do NOT wait on it. If it's not greater than zero, 6653 * ie. it can't be decremented without waiting, then 6654 * someone else, either open or close, already has it 6655 * and the try returns 0. Use that knowledge here to determine 6656 * if it's OK to change the device power level. 6657 * Also, only increment it on exit if it was decremented, ie. gotten, 6658 * here. 6659 */ 6660 got_semaphore_here = sema_tryp(&un->un_semoclose); 6661 6662 mutex_enter(SD_MUTEX(un)); 6663 6664 SD_INFO(SD_LOG_POWER, un, "sdpower: un_ncmds_in_driver = %ld\n", 6665 un->un_ncmds_in_driver); 6666 6667 /* 6668 * If un_ncmds_in_driver is non-zero it indicates commands are 6669 * already being processed in the driver, or if the semaphore was 6670 * not gotten here it indicates an open or close is being processed. 6671 * At the same time somebody is requesting to go to a lower power 6672 * that can't perform I/O, which can't happen, therefore we need to 6673 * return failure. 6674 */ 6675 if ((!SD_PM_IS_IO_CAPABLE(un, level)) && 6676 ((un->un_ncmds_in_driver != 0) || (got_semaphore_here == 0))) { 6677 mutex_exit(SD_MUTEX(un)); 6678 6679 if (got_semaphore_here != 0) { 6680 sema_v(&un->un_semoclose); 6681 } 6682 SD_TRACE(SD_LOG_IO_PM, un, 6683 "sdpower: exit, device has queued cmds.\n"); 6684 6685 goto sdpower_failed; 6686 } 6687 6688 /* 6689 * if it is OFFLINE that means the disk is completely dead 6690 * in our case we have to put the disk in on or off by sending commands 6691 * Of course that will fail anyway so return back here. 6692 * 6693 * Power changes to a device that's OFFLINE or SUSPENDED 6694 * are not allowed. 6695 */ 6696 if ((un->un_state == SD_STATE_OFFLINE) || 6697 (un->un_state == SD_STATE_SUSPENDED)) { 6698 mutex_exit(SD_MUTEX(un)); 6699 6700 if (got_semaphore_here != 0) { 6701 sema_v(&un->un_semoclose); 6702 } 6703 SD_TRACE(SD_LOG_IO_PM, un, 6704 "sdpower: exit, device is off-line.\n"); 6705 6706 goto sdpower_failed; 6707 } 6708 6709 /* 6710 * Change the device's state to indicate it's power level 6711 * is being changed. Do this to prevent a power off in the 6712 * middle of commands, which is especially bad on devices 6713 * that are really powered off instead of just spun down. 6714 */ 6715 state_before_pm = un->un_state; 6716 un->un_state = SD_STATE_PM_CHANGING; 6717 6718 mutex_exit(SD_MUTEX(un)); 6719 6720 /* 6721 * If log sense command is not supported, bypass the 6722 * following checking, otherwise, check the log sense 6723 * information for this device. 6724 */ 6725 if (SD_PM_STOP_MOTOR_NEEDED(un, level) && 6726 un->un_f_log_sense_supported) { 6727 /* 6728 * Get the log sense information to understand whether the 6729 * the powercycle counts have gone beyond the threshhold. 6730 */ 6731 log_page_size = START_STOP_CYCLE_COUNTER_PAGE_SIZE; 6732 log_page_data = kmem_zalloc(log_page_size, KM_SLEEP); 6733 6734 mutex_enter(SD_MUTEX(un)); 6735 log_sense_page = un->un_start_stop_cycle_page; 6736 mutex_exit(SD_MUTEX(un)); 6737 6738 rval = sd_send_scsi_LOG_SENSE(ssc, log_page_data, 6739 log_page_size, log_sense_page, 0x01, 0, SD_PATH_DIRECT); 6740 6741 if (rval != 0) { 6742 if (rval == EIO) 6743 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK); 6744 else 6745 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 6746 } 6747 6748 #ifdef SDDEBUG 6749 if (sd_force_pm_supported) { 6750 /* Force a successful result */ 6751 rval = 0; 6752 } 6753 #endif 6754 if (rval != 0) { 6755 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 6756 "Log Sense Failed\n"); 6757 6758 kmem_free(log_page_data, log_page_size); 6759 /* Cannot support power management on those drives */ 6760 6761 if (got_semaphore_here != 0) { 6762 sema_v(&un->un_semoclose); 6763 } 6764 /* 6765 * On exit put the state back to it's original value 6766 * and broadcast to anyone waiting for the power 6767 * change completion. 6768 */ 6769 mutex_enter(SD_MUTEX(un)); 6770 un->un_state = state_before_pm; 6771 cv_broadcast(&un->un_suspend_cv); 6772 mutex_exit(SD_MUTEX(un)); 6773 SD_TRACE(SD_LOG_IO_PM, un, 6774 "sdpower: exit, Log Sense Failed.\n"); 6775 6776 goto sdpower_failed; 6777 } 6778 6779 /* 6780 * From the page data - Convert the essential information to 6781 * pm_trans_data 6782 */ 6783 maxcycles = 6784 (log_page_data[0x1c] << 24) | (log_page_data[0x1d] << 16) | 6785 (log_page_data[0x1E] << 8) | log_page_data[0x1F]; 6786 6787 ncycles = 6788 (log_page_data[0x24] << 24) | (log_page_data[0x25] << 16) | 6789 (log_page_data[0x26] << 8) | log_page_data[0x27]; 6790 6791 if (un->un_f_pm_log_sense_smart) { 6792 sd_pm_tran_data.un.smart_count.allowed = maxcycles; 6793 sd_pm_tran_data.un.smart_count.consumed = ncycles; 6794 sd_pm_tran_data.un.smart_count.flag = 0; 6795 sd_pm_tran_data.format = DC_SMART_FORMAT; 6796 } else { 6797 sd_pm_tran_data.un.scsi_cycles.lifemax = maxcycles; 6798 sd_pm_tran_data.un.scsi_cycles.ncycles = ncycles; 6799 for (i = 0; i < DC_SCSI_MFR_LEN; i++) { 6800 sd_pm_tran_data.un.scsi_cycles.svc_date[i] = 6801 log_page_data[8+i]; 6802 } 6803 sd_pm_tran_data.un.scsi_cycles.flag = 0; 6804 sd_pm_tran_data.format = DC_SCSI_FORMAT; 6805 } 6806 6807 kmem_free(log_page_data, log_page_size); 6808 6809 /* 6810 * Call pm_trans_check routine to get the Ok from 6811 * the global policy 6812 */ 6813 rval = pm_trans_check(&sd_pm_tran_data, &intvlp); 6814 #ifdef SDDEBUG 6815 if (sd_force_pm_supported) { 6816 /* Force a successful result */ 6817 rval = 1; 6818 } 6819 #endif 6820 switch (rval) { 6821 case 0: 6822 /* 6823 * Not Ok to Power cycle or error in parameters passed 6824 * Would have given the advised time to consider power 6825 * cycle. Based on the new intvlp parameter we are 6826 * supposed to pretend we are busy so that pm framework 6827 * will never call our power entry point. Because of 6828 * that install a timeout handler and wait for the 6829 * recommended time to elapse so that power management 6830 * can be effective again. 6831 * 6832 * To effect this behavior, call pm_busy_component to 6833 * indicate to the framework this device is busy. 6834 * By not adjusting un_pm_count the rest of PM in 6835 * the driver will function normally, and independent 6836 * of this but because the framework is told the device 6837 * is busy it won't attempt powering down until it gets 6838 * a matching idle. The timeout handler sends this. 6839 * Note: sd_pm_entry can't be called here to do this 6840 * because sdpower may have been called as a result 6841 * of a call to pm_raise_power from within sd_pm_entry. 6842 * 6843 * If a timeout handler is already active then 6844 * don't install another. 6845 */ 6846 mutex_enter(&un->un_pm_mutex); 6847 if (un->un_pm_timeid == NULL) { 6848 un->un_pm_timeid = 6849 timeout(sd_pm_timeout_handler, 6850 un, drv_sectohz(intvlp)); 6851 mutex_exit(&un->un_pm_mutex); 6852 (void) pm_busy_component(SD_DEVINFO(un), 0); 6853 } else { 6854 mutex_exit(&un->un_pm_mutex); 6855 } 6856 if (got_semaphore_here != 0) { 6857 sema_v(&un->un_semoclose); 6858 } 6859 /* 6860 * On exit put the state back to it's original value 6861 * and broadcast to anyone waiting for the power 6862 * change completion. 6863 */ 6864 mutex_enter(SD_MUTEX(un)); 6865 un->un_state = state_before_pm; 6866 cv_broadcast(&un->un_suspend_cv); 6867 mutex_exit(SD_MUTEX(un)); 6868 6869 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: exit, " 6870 "trans check Failed, not ok to power cycle.\n"); 6871 6872 goto sdpower_failed; 6873 case -1: 6874 if (got_semaphore_here != 0) { 6875 sema_v(&un->un_semoclose); 6876 } 6877 /* 6878 * On exit put the state back to it's original value 6879 * and broadcast to anyone waiting for the power 6880 * change completion. 6881 */ 6882 mutex_enter(SD_MUTEX(un)); 6883 un->un_state = state_before_pm; 6884 cv_broadcast(&un->un_suspend_cv); 6885 mutex_exit(SD_MUTEX(un)); 6886 SD_TRACE(SD_LOG_IO_PM, un, 6887 "sdpower: exit, trans check command Failed.\n"); 6888 6889 goto sdpower_failed; 6890 } 6891 } 6892 6893 if (!SD_PM_IS_IO_CAPABLE(un, level)) { 6894 /* 6895 * Save the last state... if the STOP FAILS we need it 6896 * for restoring 6897 */ 6898 mutex_enter(SD_MUTEX(un)); 6899 save_state = un->un_last_state; 6900 last_power_level = un->un_power_level; 6901 /* 6902 * There must not be any cmds. getting processed 6903 * in the driver when we get here. Power to the 6904 * device is potentially going off. 6905 */ 6906 ASSERT(un->un_ncmds_in_driver == 0); 6907 mutex_exit(SD_MUTEX(un)); 6908 6909 /* 6910 * For now PM suspend the device completely before spindle is 6911 * turned off 6912 */ 6913 if ((rval = sd_pm_state_change(un, level, SD_PM_STATE_CHANGE)) 6914 == DDI_FAILURE) { 6915 if (got_semaphore_here != 0) { 6916 sema_v(&un->un_semoclose); 6917 } 6918 /* 6919 * On exit put the state back to it's original value 6920 * and broadcast to anyone waiting for the power 6921 * change completion. 6922 */ 6923 mutex_enter(SD_MUTEX(un)); 6924 un->un_state = state_before_pm; 6925 un->un_power_level = last_power_level; 6926 cv_broadcast(&un->un_suspend_cv); 6927 mutex_exit(SD_MUTEX(un)); 6928 SD_TRACE(SD_LOG_IO_PM, un, 6929 "sdpower: exit, PM suspend Failed.\n"); 6930 6931 goto sdpower_failed; 6932 } 6933 } 6934 6935 /* 6936 * The transition from SPINDLE_OFF to SPINDLE_ON can happen in open, 6937 * close, or strategy. Dump no long uses this routine, it uses it's 6938 * own code so it can be done in polled mode. 6939 */ 6940 6941 medium_present = TRUE; 6942 6943 /* 6944 * When powering up, issue a TUR in case the device is at unit 6945 * attention. Don't do retries. Bypass the PM layer, otherwise 6946 * a deadlock on un_pm_busy_cv will occur. 6947 */ 6948 if (SD_PM_IS_IO_CAPABLE(un, level)) { 6949 sval = sd_send_scsi_TEST_UNIT_READY(ssc, 6950 SD_DONT_RETRY_TUR | SD_BYPASS_PM); 6951 if (sval != 0) 6952 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 6953 } 6954 6955 if (un->un_f_power_condition_supported) { 6956 char *pm_condition_name[] = {"STOPPED", "STANDBY", 6957 "IDLE", "ACTIVE"}; 6958 SD_TRACE(SD_LOG_IO_PM, un, 6959 "sdpower: sending \'%s\' power condition", 6960 pm_condition_name[level]); 6961 sval = sd_send_scsi_START_STOP_UNIT(ssc, SD_POWER_CONDITION, 6962 sd_pl2pc[level], SD_PATH_DIRECT); 6963 } else { 6964 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: sending \'%s\' unit\n", 6965 ((level == SD_SPINDLE_ON) ? "START" : "STOP")); 6966 sval = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP, 6967 ((level == SD_SPINDLE_ON) ? SD_TARGET_START : 6968 SD_TARGET_STOP), SD_PATH_DIRECT); 6969 } 6970 if (sval != 0) { 6971 if (sval == EIO) 6972 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK); 6973 else 6974 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 6975 } 6976 6977 /* Command failed, check for media present. */ 6978 if ((sval == ENXIO) && un->un_f_has_removable_media) { 6979 medium_present = FALSE; 6980 } 6981 6982 /* 6983 * The conditions of interest here are: 6984 * if a spindle off with media present fails, 6985 * then restore the state and return an error. 6986 * else if a spindle on fails, 6987 * then return an error (there's no state to restore). 6988 * In all other cases we setup for the new state 6989 * and return success. 6990 */ 6991 if (!SD_PM_IS_IO_CAPABLE(un, level)) { 6992 if ((medium_present == TRUE) && (sval != 0)) { 6993 /* The stop command from above failed */ 6994 rval = DDI_FAILURE; 6995 /* 6996 * The stop command failed, and we have media 6997 * present. Put the level back by calling the 6998 * sd_pm_resume() and set the state back to 6999 * it's previous value. 7000 */ 7001 (void) sd_pm_state_change(un, last_power_level, 7002 SD_PM_STATE_ROLLBACK); 7003 mutex_enter(SD_MUTEX(un)); 7004 un->un_last_state = save_state; 7005 mutex_exit(SD_MUTEX(un)); 7006 } else if (un->un_f_monitor_media_state) { 7007 /* 7008 * The stop command from above succeeded. 7009 * Terminate watch thread in case of removable media 7010 * devices going into low power state. This is as per 7011 * the requirements of pm framework, otherwise commands 7012 * will be generated for the device (through watch 7013 * thread), even when the device is in low power state. 7014 */ 7015 mutex_enter(SD_MUTEX(un)); 7016 un->un_f_watcht_stopped = FALSE; 7017 if (un->un_swr_token != NULL) { 7018 opaque_t temp_token = un->un_swr_token; 7019 un->un_f_watcht_stopped = TRUE; 7020 un->un_swr_token = NULL; 7021 mutex_exit(SD_MUTEX(un)); 7022 (void) scsi_watch_request_terminate(temp_token, 7023 SCSI_WATCH_TERMINATE_ALL_WAIT); 7024 } else { 7025 mutex_exit(SD_MUTEX(un)); 7026 } 7027 } 7028 } else { 7029 /* 7030 * The level requested is I/O capable. 7031 * Legacy behavior: return success on a failed spinup 7032 * if there is no media in the drive. 7033 * Do this by looking at medium_present here. 7034 */ 7035 if ((sval != 0) && medium_present) { 7036 /* The start command from above failed */ 7037 rval = DDI_FAILURE; 7038 } else { 7039 /* 7040 * The start command from above succeeded 7041 * PM resume the devices now that we have 7042 * started the disks 7043 */ 7044 (void) sd_pm_state_change(un, level, 7045 SD_PM_STATE_CHANGE); 7046 7047 /* 7048 * Resume the watch thread since it was suspended 7049 * when the device went into low power mode. 7050 */ 7051 if (un->un_f_monitor_media_state) { 7052 mutex_enter(SD_MUTEX(un)); 7053 if (un->un_f_watcht_stopped == TRUE) { 7054 opaque_t temp_token; 7055 7056 un->un_f_watcht_stopped = FALSE; 7057 mutex_exit(SD_MUTEX(un)); 7058 temp_token = 7059 sd_watch_request_submit(un); 7060 mutex_enter(SD_MUTEX(un)); 7061 un->un_swr_token = temp_token; 7062 } 7063 mutex_exit(SD_MUTEX(un)); 7064 } 7065 } 7066 } 7067 7068 if (got_semaphore_here != 0) { 7069 sema_v(&un->un_semoclose); 7070 } 7071 /* 7072 * On exit put the state back to it's original value 7073 * and broadcast to anyone waiting for the power 7074 * change completion. 7075 */ 7076 mutex_enter(SD_MUTEX(un)); 7077 un->un_state = state_before_pm; 7078 cv_broadcast(&un->un_suspend_cv); 7079 mutex_exit(SD_MUTEX(un)); 7080 7081 SD_TRACE(SD_LOG_IO_PM, un, "sdpower: exit, status = 0x%x\n", rval); 7082 7083 sd_ssc_fini(ssc); 7084 return (rval); 7085 7086 sdpower_failed: 7087 7088 sd_ssc_fini(ssc); 7089 return (DDI_FAILURE); 7090 } 7091 7092 7093 7094 /* 7095 * Function: sdattach 7096 * 7097 * Description: Driver's attach(9e) entry point function. 7098 * 7099 * Arguments: devi - opaque device info handle 7100 * cmd - attach type 7101 * 7102 * Return Code: DDI_SUCCESS 7103 * DDI_FAILURE 7104 * 7105 * Context: Kernel thread context 7106 */ 7107 7108 static int 7109 sdattach(dev_info_t *devi, ddi_attach_cmd_t cmd) 7110 { 7111 switch (cmd) { 7112 case DDI_ATTACH: 7113 return (sd_unit_attach(devi)); 7114 case DDI_RESUME: 7115 return (sd_ddi_resume(devi)); 7116 default: 7117 break; 7118 } 7119 return (DDI_FAILURE); 7120 } 7121 7122 7123 /* 7124 * Function: sddetach 7125 * 7126 * Description: Driver's detach(9E) entry point function. 7127 * 7128 * Arguments: devi - opaque device info handle 7129 * cmd - detach type 7130 * 7131 * Return Code: DDI_SUCCESS 7132 * DDI_FAILURE 7133 * 7134 * Context: Kernel thread context 7135 */ 7136 7137 static int 7138 sddetach(dev_info_t *devi, ddi_detach_cmd_t cmd) 7139 { 7140 switch (cmd) { 7141 case DDI_DETACH: 7142 return (sd_unit_detach(devi)); 7143 case DDI_SUSPEND: 7144 return (sd_ddi_suspend(devi)); 7145 default: 7146 break; 7147 } 7148 return (DDI_FAILURE); 7149 } 7150 7151 7152 /* 7153 * Function: sd_sync_with_callback 7154 * 7155 * Description: Prevents sd_unit_attach or sd_unit_detach from freeing the soft 7156 * state while the callback routine is active. 7157 * 7158 * Arguments: un: softstate structure for the instance 7159 * 7160 * Context: Kernel thread context 7161 */ 7162 7163 static void 7164 sd_sync_with_callback(struct sd_lun *un) 7165 { 7166 ASSERT(un != NULL); 7167 7168 mutex_enter(SD_MUTEX(un)); 7169 7170 ASSERT(un->un_in_callback >= 0); 7171 7172 while (un->un_in_callback > 0) { 7173 mutex_exit(SD_MUTEX(un)); 7174 delay(2); 7175 mutex_enter(SD_MUTEX(un)); 7176 } 7177 7178 mutex_exit(SD_MUTEX(un)); 7179 } 7180 7181 /* 7182 * Function: sd_unit_attach 7183 * 7184 * Description: Performs DDI_ATTACH processing for sdattach(). Allocates 7185 * the soft state structure for the device and performs 7186 * all necessary structure and device initializations. 7187 * 7188 * Arguments: devi: the system's dev_info_t for the device. 7189 * 7190 * Return Code: DDI_SUCCESS if attach is successful. 7191 * DDI_FAILURE if any part of the attach fails. 7192 * 7193 * Context: Called at attach(9e) time for the DDI_ATTACH flag. 7194 * Kernel thread context only. Can sleep. 7195 */ 7196 7197 static int 7198 sd_unit_attach(dev_info_t *devi) 7199 { 7200 struct scsi_device *devp; 7201 struct sd_lun *un; 7202 char *variantp; 7203 char name_str[48]; 7204 int reservation_flag = SD_TARGET_IS_UNRESERVED; 7205 int instance; 7206 int rval; 7207 int wc_enabled; 7208 int tgt; 7209 uint64_t capacity; 7210 uint_t lbasize = 0; 7211 dev_info_t *pdip = ddi_get_parent(devi); 7212 int offbyone = 0; 7213 int geom_label_valid = 0; 7214 sd_ssc_t *ssc; 7215 int status; 7216 struct sd_fm_internal *sfip = NULL; 7217 int max_xfer_size; 7218 7219 /* 7220 * Retrieve the target driver's private data area. This was set 7221 * up by the HBA. 7222 */ 7223 devp = ddi_get_driver_private(devi); 7224 7225 /* 7226 * Retrieve the target ID of the device. 7227 */ 7228 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 7229 SCSI_ADDR_PROP_TARGET, -1); 7230 7231 /* 7232 * Since we have no idea what state things were left in by the last 7233 * user of the device, set up some 'default' settings, ie. turn 'em 7234 * off. The scsi_ifsetcap calls force re-negotiations with the drive. 7235 * Do this before the scsi_probe, which sends an inquiry. 7236 * This is a fix for bug (4430280). 7237 * Of special importance is wide-xfer. The drive could have been left 7238 * in wide transfer mode by the last driver to communicate with it, 7239 * this includes us. If that's the case, and if the following is not 7240 * setup properly or we don't re-negotiate with the drive prior to 7241 * transferring data to/from the drive, it causes bus parity errors, 7242 * data overruns, and unexpected interrupts. This first occurred when 7243 * the fix for bug (4378686) was made. 7244 */ 7245 (void) scsi_ifsetcap(&devp->sd_address, "lun-reset", 0, 1); 7246 (void) scsi_ifsetcap(&devp->sd_address, "wide-xfer", 0, 1); 7247 (void) scsi_ifsetcap(&devp->sd_address, "auto-rqsense", 0, 1); 7248 7249 /* 7250 * Currently, scsi_ifsetcap sets tagged-qing capability for all LUNs 7251 * on a target. Setting it per lun instance actually sets the 7252 * capability of this target, which affects those luns already 7253 * attached on the same target. So during attach, we can only disable 7254 * this capability only when no other lun has been attached on this 7255 * target. By doing this, we assume a target has the same tagged-qing 7256 * capability for every lun. The condition can be removed when HBA 7257 * is changed to support per lun based tagged-qing capability. 7258 */ 7259 if (sd_scsi_get_target_lun_count(pdip, tgt) < 1) { 7260 (void) scsi_ifsetcap(&devp->sd_address, "tagged-qing", 0, 1); 7261 } 7262 7263 /* 7264 * Use scsi_probe() to issue an INQUIRY command to the device. 7265 * This call will allocate and fill in the scsi_inquiry structure 7266 * and point the sd_inq member of the scsi_device structure to it. 7267 * If the attach succeeds, then this memory will not be de-allocated 7268 * (via scsi_unprobe()) until the instance is detached. 7269 */ 7270 if (scsi_probe(devp, SLEEP_FUNC) != SCSIPROBE_EXISTS) { 7271 goto probe_failed; 7272 } 7273 7274 /* 7275 * Check the device type as specified in the inquiry data and 7276 * claim it if it is of a type that we support. 7277 */ 7278 switch (devp->sd_inq->inq_dtype) { 7279 case DTYPE_DIRECT: 7280 break; 7281 case DTYPE_RODIRECT: 7282 break; 7283 case DTYPE_OPTICAL: 7284 break; 7285 case DTYPE_NOTPRESENT: 7286 default: 7287 /* Unsupported device type; fail the attach. */ 7288 goto probe_failed; 7289 } 7290 7291 /* 7292 * Allocate the soft state structure for this unit. 7293 * 7294 * We rely upon this memory being set to all zeroes by 7295 * ddi_soft_state_zalloc(). We assume that any member of the 7296 * soft state structure that is not explicitly initialized by 7297 * this routine will have a value of zero. 7298 */ 7299 instance = ddi_get_instance(devp->sd_dev); 7300 #ifndef XPV_HVM_DRIVER 7301 if (ddi_soft_state_zalloc(sd_state, instance) != DDI_SUCCESS) { 7302 goto probe_failed; 7303 } 7304 #endif /* !XPV_HVM_DRIVER */ 7305 7306 /* 7307 * Retrieve a pointer to the newly-allocated soft state. 7308 * 7309 * This should NEVER fail if the ddi_soft_state_zalloc() call above 7310 * was successful, unless something has gone horribly wrong and the 7311 * ddi's soft state internals are corrupt (in which case it is 7312 * probably better to halt here than just fail the attach....) 7313 */ 7314 if ((un = ddi_get_soft_state(sd_state, instance)) == NULL) { 7315 panic("sd_unit_attach: NULL soft state on instance:0x%x", 7316 instance); 7317 /*NOTREACHED*/ 7318 } 7319 7320 /* 7321 * Link the back ptr of the driver soft state to the scsi_device 7322 * struct for this lun. 7323 * Save a pointer to the softstate in the driver-private area of 7324 * the scsi_device struct. 7325 * Note: We cannot call SD_INFO, SD_TRACE, SD_ERROR, or SD_DIAG until 7326 * we first set un->un_sd below. 7327 */ 7328 un->un_sd = devp; 7329 devp->sd_private = (opaque_t)un; 7330 7331 /* 7332 * The following must be after devp is stored in the soft state struct. 7333 */ 7334 #ifdef SDDEBUG 7335 SD_TRACE(SD_LOG_ATTACH_DETACH, un, 7336 "%s_unit_attach: un:0x%p instance:%d\n", 7337 ddi_driver_name(devi), un, instance); 7338 #endif 7339 7340 /* 7341 * Set up the device type and node type (for the minor nodes). 7342 * By default we assume that the device can at least support the 7343 * Common Command Set. Call it a CD-ROM if it reports itself 7344 * as a RODIRECT device. 7345 */ 7346 switch (devp->sd_inq->inq_dtype) { 7347 case DTYPE_RODIRECT: 7348 un->un_node_type = DDI_NT_CD_CHAN; 7349 un->un_ctype = CTYPE_CDROM; 7350 break; 7351 case DTYPE_OPTICAL: 7352 un->un_node_type = DDI_NT_BLOCK_CHAN; 7353 un->un_ctype = CTYPE_ROD; 7354 break; 7355 default: 7356 un->un_node_type = DDI_NT_BLOCK_CHAN; 7357 un->un_ctype = CTYPE_CCS; 7358 break; 7359 } 7360 7361 /* 7362 * Try to read the interconnect type from the HBA. 7363 * 7364 * Note: This driver is currently compiled as two binaries, a parallel 7365 * scsi version (sd) and a fibre channel version (ssd). All functional 7366 * differences are determined at compile time. In the future a single 7367 * binary will be provided and the interconnect type will be used to 7368 * differentiate between fibre and parallel scsi behaviors. At that time 7369 * it will be necessary for all fibre channel HBAs to support this 7370 * property. 7371 * 7372 * set un_f_is_fiber to TRUE ( default fiber ) 7373 */ 7374 un->un_f_is_fibre = TRUE; 7375 switch (scsi_ifgetcap(SD_ADDRESS(un), "interconnect-type", -1)) { 7376 case INTERCONNECT_SSA: 7377 un->un_interconnect_type = SD_INTERCONNECT_SSA; 7378 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7379 "sd_unit_attach: un:0x%p SD_INTERCONNECT_SSA\n", un); 7380 break; 7381 case INTERCONNECT_PARALLEL: 7382 un->un_f_is_fibre = FALSE; 7383 un->un_interconnect_type = SD_INTERCONNECT_PARALLEL; 7384 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7385 "sd_unit_attach: un:0x%p SD_INTERCONNECT_PARALLEL\n", un); 7386 break; 7387 case INTERCONNECT_SAS: 7388 un->un_f_is_fibre = FALSE; 7389 un->un_interconnect_type = SD_INTERCONNECT_SAS; 7390 un->un_node_type = DDI_NT_BLOCK_SAS; 7391 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7392 "sd_unit_attach: un:0x%p SD_INTERCONNECT_SAS\n", un); 7393 break; 7394 case INTERCONNECT_SATA: 7395 un->un_f_is_fibre = FALSE; 7396 un->un_interconnect_type = SD_INTERCONNECT_SATA; 7397 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7398 "sd_unit_attach: un:0x%p SD_INTERCONNECT_SATA\n", un); 7399 break; 7400 case INTERCONNECT_FIBRE: 7401 un->un_interconnect_type = SD_INTERCONNECT_FIBRE; 7402 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7403 "sd_unit_attach: un:0x%p SD_INTERCONNECT_FIBRE\n", un); 7404 break; 7405 case INTERCONNECT_FABRIC: 7406 un->un_interconnect_type = SD_INTERCONNECT_FABRIC; 7407 un->un_node_type = DDI_NT_BLOCK_FABRIC; 7408 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7409 "sd_unit_attach: un:0x%p SD_INTERCONNECT_FABRIC\n", un); 7410 break; 7411 default: 7412 #ifdef SD_DEFAULT_INTERCONNECT_TYPE 7413 /* 7414 * The HBA does not support the "interconnect-type" property 7415 * (or did not provide a recognized type). 7416 * 7417 * Note: This will be obsoleted when a single fibre channel 7418 * and parallel scsi driver is delivered. In the meantime the 7419 * interconnect type will be set to the platform default.If that 7420 * type is not parallel SCSI, it means that we should be 7421 * assuming "ssd" semantics. However, here this also means that 7422 * the FC HBA is not supporting the "interconnect-type" property 7423 * like we expect it to, so log this occurrence. 7424 */ 7425 un->un_interconnect_type = SD_DEFAULT_INTERCONNECT_TYPE; 7426 if (!SD_IS_PARALLEL_SCSI(un)) { 7427 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7428 "sd_unit_attach: un:0x%p Assuming " 7429 "INTERCONNECT_FIBRE\n", un); 7430 } else { 7431 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7432 "sd_unit_attach: un:0x%p Assuming " 7433 "INTERCONNECT_PARALLEL\n", un); 7434 un->un_f_is_fibre = FALSE; 7435 } 7436 #else 7437 /* 7438 * Note: This source will be implemented when a single fibre 7439 * channel and parallel scsi driver is delivered. The default 7440 * will be to assume that if a device does not support the 7441 * "interconnect-type" property it is a parallel SCSI HBA and 7442 * we will set the interconnect type for parallel scsi. 7443 */ 7444 un->un_interconnect_type = SD_INTERCONNECT_PARALLEL; 7445 un->un_f_is_fibre = FALSE; 7446 #endif 7447 break; 7448 } 7449 7450 if (un->un_f_is_fibre == TRUE) { 7451 if (scsi_ifgetcap(SD_ADDRESS(un), "scsi-version", 1) == 7452 SCSI_VERSION_3) { 7453 switch (un->un_interconnect_type) { 7454 case SD_INTERCONNECT_FIBRE: 7455 case SD_INTERCONNECT_SSA: 7456 un->un_node_type = DDI_NT_BLOCK_WWN; 7457 break; 7458 default: 7459 break; 7460 } 7461 } 7462 } 7463 7464 /* 7465 * Initialize the Request Sense command for the target 7466 */ 7467 if (sd_alloc_rqs(devp, un) != DDI_SUCCESS) { 7468 goto alloc_rqs_failed; 7469 } 7470 7471 /* 7472 * Set un_retry_count with SD_RETRY_COUNT, this is ok for Sparc 7473 * with separate binary for sd and ssd. 7474 * 7475 * x86 has 1 binary, un_retry_count is set base on connection type. 7476 * The hardcoded values will go away when Sparc uses 1 binary 7477 * for sd and ssd. This hardcoded values need to match 7478 * SD_RETRY_COUNT in sddef.h 7479 * The value used is base on interconnect type. 7480 * fibre = 3, parallel = 5 7481 */ 7482 #if defined(__i386) || defined(__amd64) 7483 un->un_retry_count = un->un_f_is_fibre ? 3 : 5; 7484 #else 7485 un->un_retry_count = SD_RETRY_COUNT; 7486 #endif 7487 7488 /* 7489 * Set the per disk retry count to the default number of retries 7490 * for disks and CDROMs. This value can be overridden by the 7491 * disk property list or an entry in sd.conf. 7492 */ 7493 un->un_notready_retry_count = 7494 ISCD(un) ? CD_NOT_READY_RETRY_COUNT(un) 7495 : DISK_NOT_READY_RETRY_COUNT(un); 7496 7497 /* 7498 * Set the busy retry count to the default value of un_retry_count. 7499 * This can be overridden by entries in sd.conf or the device 7500 * config table. 7501 */ 7502 un->un_busy_retry_count = un->un_retry_count; 7503 7504 /* 7505 * Init the reset threshold for retries. This number determines 7506 * how many retries must be performed before a reset can be issued 7507 * (for certain error conditions). This can be overridden by entries 7508 * in sd.conf or the device config table. 7509 */ 7510 un->un_reset_retry_count = (un->un_retry_count / 2); 7511 7512 /* 7513 * Set the victim_retry_count to the default un_retry_count 7514 */ 7515 un->un_victim_retry_count = (2 * un->un_retry_count); 7516 7517 /* 7518 * Set the reservation release timeout to the default value of 7519 * 5 seconds. This can be overridden by entries in ssd.conf or the 7520 * device config table. 7521 */ 7522 un->un_reserve_release_time = 5; 7523 7524 /* 7525 * Set up the default maximum transfer size. Note that this may 7526 * get updated later in the attach, when setting up default wide 7527 * operations for disks. 7528 */ 7529 #if defined(__i386) || defined(__amd64) 7530 un->un_max_xfer_size = (uint_t)SD_DEFAULT_MAX_XFER_SIZE; 7531 un->un_partial_dma_supported = 1; 7532 #else 7533 un->un_max_xfer_size = (uint_t)maxphys; 7534 #endif 7535 7536 /* 7537 * Get "allow bus device reset" property (defaults to "enabled" if 7538 * the property was not defined). This is to disable bus resets for 7539 * certain kinds of error recovery. Note: In the future when a run-time 7540 * fibre check is available the soft state flag should default to 7541 * enabled. 7542 */ 7543 if (un->un_f_is_fibre == TRUE) { 7544 un->un_f_allow_bus_device_reset = TRUE; 7545 } else { 7546 if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 7547 "allow-bus-device-reset", 1) != 0) { 7548 un->un_f_allow_bus_device_reset = TRUE; 7549 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7550 "sd_unit_attach: un:0x%p Bus device reset " 7551 "enabled\n", un); 7552 } else { 7553 un->un_f_allow_bus_device_reset = FALSE; 7554 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7555 "sd_unit_attach: un:0x%p Bus device reset " 7556 "disabled\n", un); 7557 } 7558 } 7559 7560 /* 7561 * Check if this is an ATAPI device. ATAPI devices use Group 1 7562 * Read/Write commands and Group 2 Mode Sense/Select commands. 7563 * 7564 * Note: The "obsolete" way of doing this is to check for the "atapi" 7565 * property. The new "variant" property with a value of "atapi" has been 7566 * introduced so that future 'variants' of standard SCSI behavior (like 7567 * atapi) could be specified by the underlying HBA drivers by supplying 7568 * a new value for the "variant" property, instead of having to define a 7569 * new property. 7570 */ 7571 if (ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0, "atapi", -1) != -1) { 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 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, devi, 0, "variant", 7577 &variantp) == DDI_PROP_SUCCESS) { 7578 if (strcmp(variantp, "atapi") == 0) { 7579 un->un_f_cfg_is_atapi = TRUE; 7580 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7581 "sd_unit_attach: un:0x%p Atapi device\n", un); 7582 } 7583 ddi_prop_free(variantp); 7584 } 7585 7586 un->un_cmd_timeout = SD_IO_TIME; 7587 7588 un->un_busy_timeout = SD_BSY_TIMEOUT; 7589 7590 /* Info on current states, statuses, etc. (Updated frequently) */ 7591 un->un_state = SD_STATE_NORMAL; 7592 un->un_last_state = SD_STATE_NORMAL; 7593 7594 /* Control & status info for command throttling */ 7595 un->un_throttle = sd_max_throttle; 7596 un->un_saved_throttle = sd_max_throttle; 7597 un->un_min_throttle = sd_min_throttle; 7598 7599 if (un->un_f_is_fibre == TRUE) { 7600 un->un_f_use_adaptive_throttle = TRUE; 7601 } else { 7602 un->un_f_use_adaptive_throttle = FALSE; 7603 } 7604 7605 /* Removable media support. */ 7606 cv_init(&un->un_state_cv, NULL, CV_DRIVER, NULL); 7607 un->un_mediastate = DKIO_NONE; 7608 un->un_specified_mediastate = DKIO_NONE; 7609 7610 /* CVs for suspend/resume (PM or DR) */ 7611 cv_init(&un->un_suspend_cv, NULL, CV_DRIVER, NULL); 7612 cv_init(&un->un_disk_busy_cv, NULL, CV_DRIVER, NULL); 7613 7614 /* Power management support. */ 7615 un->un_power_level = SD_SPINDLE_UNINIT; 7616 7617 cv_init(&un->un_wcc_cv, NULL, CV_DRIVER, NULL); 7618 un->un_f_wcc_inprog = 0; 7619 7620 /* 7621 * The open/close semaphore is used to serialize threads executing 7622 * in the driver's open & close entry point routines for a given 7623 * instance. 7624 */ 7625 (void) sema_init(&un->un_semoclose, 1, NULL, SEMA_DRIVER, NULL); 7626 7627 /* 7628 * The conf file entry and softstate variable is a forceful override, 7629 * meaning a non-zero value must be entered to change the default. 7630 */ 7631 un->un_f_disksort_disabled = FALSE; 7632 un->un_f_rmw_type = SD_RMW_TYPE_DEFAULT; 7633 un->un_f_enable_rmw = FALSE; 7634 7635 /* 7636 * GET EVENT STATUS NOTIFICATION media polling enabled by default, but 7637 * can be overridden via [s]sd-config-list "mmc-gesn-polling" property. 7638 */ 7639 un->un_f_mmc_gesn_polling = TRUE; 7640 7641 /* 7642 * physical sector size defaults to DEV_BSIZE currently. We can 7643 * override this value via the driver configuration file so we must 7644 * set it before calling sd_read_unit_properties(). 7645 */ 7646 un->un_phy_blocksize = DEV_BSIZE; 7647 7648 /* 7649 * Retrieve the properties from the static driver table or the driver 7650 * configuration file (.conf) for this unit and update the soft state 7651 * for the device as needed for the indicated properties. 7652 * Note: the property configuration needs to occur here as some of the 7653 * following routines may have dependencies on soft state flags set 7654 * as part of the driver property configuration. 7655 */ 7656 sd_read_unit_properties(un); 7657 SD_TRACE(SD_LOG_ATTACH_DETACH, un, 7658 "sd_unit_attach: un:0x%p property configuration complete.\n", un); 7659 7660 /* 7661 * Only if a device has "hotpluggable" property, it is 7662 * treated as hotpluggable device. Otherwise, it is 7663 * regarded as non-hotpluggable one. 7664 */ 7665 if (ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0, "hotpluggable", 7666 -1) != -1) { 7667 un->un_f_is_hotpluggable = TRUE; 7668 } 7669 7670 /* 7671 * set unit's attributes(flags) according to "hotpluggable" and 7672 * RMB bit in INQUIRY data. 7673 */ 7674 sd_set_unit_attributes(un, devi); 7675 7676 /* 7677 * By default, we mark the capacity, lbasize, and geometry 7678 * as invalid. Only if we successfully read a valid capacity 7679 * will we update the un_blockcount and un_tgt_blocksize with the 7680 * valid values (the geometry will be validated later). 7681 */ 7682 un->un_f_blockcount_is_valid = FALSE; 7683 un->un_f_tgt_blocksize_is_valid = FALSE; 7684 7685 /* 7686 * Use DEV_BSIZE and DEV_BSHIFT as defaults, until we can determine 7687 * otherwise. 7688 */ 7689 un->un_tgt_blocksize = un->un_sys_blocksize = DEV_BSIZE; 7690 un->un_blockcount = 0; 7691 7692 /* 7693 * Set up the per-instance info needed to determine the correct 7694 * CDBs and other info for issuing commands to the target. 7695 */ 7696 sd_init_cdb_limits(un); 7697 7698 /* 7699 * Set up the IO chains to use, based upon the target type. 7700 */ 7701 if (un->un_f_non_devbsize_supported) { 7702 un->un_buf_chain_type = SD_CHAIN_INFO_RMMEDIA; 7703 } else { 7704 un->un_buf_chain_type = SD_CHAIN_INFO_DISK; 7705 } 7706 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD; 7707 un->un_direct_chain_type = SD_CHAIN_INFO_DIRECT_CMD; 7708 un->un_priority_chain_type = SD_CHAIN_INFO_PRIORITY_CMD; 7709 7710 un->un_xbuf_attr = ddi_xbuf_attr_create(sizeof (struct sd_xbuf), 7711 sd_xbuf_strategy, un, sd_xbuf_active_limit, sd_xbuf_reserve_limit, 7712 ddi_driver_major(devi), DDI_XBUF_QTHREAD_DRIVER); 7713 ddi_xbuf_attr_register_devinfo(un->un_xbuf_attr, devi); 7714 7715 7716 if (ISCD(un)) { 7717 un->un_additional_codes = sd_additional_codes; 7718 } else { 7719 un->un_additional_codes = NULL; 7720 } 7721 7722 /* 7723 * Create the kstats here so they can be available for attach-time 7724 * routines that send commands to the unit (either polled or via 7725 * sd_send_scsi_cmd). 7726 * 7727 * Note: This is a critical sequence that needs to be maintained: 7728 * 1) Instantiate the kstats here, before any routines using the 7729 * iopath (i.e. sd_send_scsi_cmd). 7730 * 2) Instantiate and initialize the partition stats 7731 * (sd_set_pstats). 7732 * 3) Initialize the error stats (sd_set_errstats), following 7733 * sd_validate_geometry(),sd_register_devid(), 7734 * and sd_cache_control(). 7735 */ 7736 7737 un->un_stats = kstat_create(sd_label, instance, 7738 NULL, "disk", KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT); 7739 if (un->un_stats != NULL) { 7740 un->un_stats->ks_lock = SD_MUTEX(un); 7741 kstat_install(un->un_stats); 7742 } 7743 SD_TRACE(SD_LOG_ATTACH_DETACH, un, 7744 "sd_unit_attach: un:0x%p un_stats created\n", un); 7745 7746 sd_create_errstats(un, instance); 7747 if (un->un_errstats == NULL) { 7748 goto create_errstats_failed; 7749 } 7750 SD_TRACE(SD_LOG_ATTACH_DETACH, un, 7751 "sd_unit_attach: un:0x%p errstats created\n", un); 7752 7753 /* 7754 * The following if/else code was relocated here from below as part 7755 * of the fix for bug (4430280). However with the default setup added 7756 * on entry to this routine, it's no longer absolutely necessary for 7757 * this to be before the call to sd_spin_up_unit. 7758 */ 7759 if (SD_IS_PARALLEL_SCSI(un) || SD_IS_SERIAL(un)) { 7760 int tq_trigger_flag = (((devp->sd_inq->inq_ansi == 4) || 7761 (devp->sd_inq->inq_ansi == 5)) && 7762 devp->sd_inq->inq_bque) || devp->sd_inq->inq_cmdque; 7763 7764 /* 7765 * If tagged queueing is supported by the target 7766 * and by the host adapter then we will enable it 7767 */ 7768 un->un_tagflags = 0; 7769 if ((devp->sd_inq->inq_rdf == RDF_SCSI2) && tq_trigger_flag && 7770 (un->un_f_arq_enabled == TRUE)) { 7771 if (scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 7772 1, 1) == 1) { 7773 un->un_tagflags = FLAG_STAG; 7774 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7775 "sd_unit_attach: un:0x%p tag queueing " 7776 "enabled\n", un); 7777 } else if (scsi_ifgetcap(SD_ADDRESS(un), 7778 "untagged-qing", 0) == 1) { 7779 un->un_f_opt_queueing = TRUE; 7780 un->un_saved_throttle = un->un_throttle = 7781 min(un->un_throttle, 3); 7782 } else { 7783 un->un_f_opt_queueing = FALSE; 7784 un->un_saved_throttle = un->un_throttle = 1; 7785 } 7786 } else if ((scsi_ifgetcap(SD_ADDRESS(un), "untagged-qing", 0) 7787 == 1) && (un->un_f_arq_enabled == TRUE)) { 7788 /* The Host Adapter supports internal queueing. */ 7789 un->un_f_opt_queueing = TRUE; 7790 un->un_saved_throttle = un->un_throttle = 7791 min(un->un_throttle, 3); 7792 } else { 7793 un->un_f_opt_queueing = FALSE; 7794 un->un_saved_throttle = un->un_throttle = 1; 7795 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7796 "sd_unit_attach: un:0x%p no tag queueing\n", un); 7797 } 7798 7799 /* 7800 * Enable large transfers for SATA/SAS drives 7801 */ 7802 if (SD_IS_SERIAL(un)) { 7803 un->un_max_xfer_size = 7804 ddi_getprop(DDI_DEV_T_ANY, devi, 0, 7805 sd_max_xfer_size, SD_MAX_XFER_SIZE); 7806 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7807 "sd_unit_attach: un:0x%p max transfer " 7808 "size=0x%x\n", un, un->un_max_xfer_size); 7809 7810 } 7811 7812 /* Setup or tear down default wide operations for disks */ 7813 7814 /* 7815 * Note: Legacy: it may be possible for both "sd_max_xfer_size" 7816 * and "ssd_max_xfer_size" to exist simultaneously on the same 7817 * system and be set to different values. In the future this 7818 * code may need to be updated when the ssd module is 7819 * obsoleted and removed from the system. (4299588) 7820 */ 7821 if (SD_IS_PARALLEL_SCSI(un) && 7822 (devp->sd_inq->inq_rdf == RDF_SCSI2) && 7823 (devp->sd_inq->inq_wbus16 || devp->sd_inq->inq_wbus32)) { 7824 if (scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer", 7825 1, 1) == 1) { 7826 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7827 "sd_unit_attach: un:0x%p Wide Transfer " 7828 "enabled\n", un); 7829 } 7830 7831 /* 7832 * If tagged queuing has also been enabled, then 7833 * enable large xfers 7834 */ 7835 if (un->un_saved_throttle == sd_max_throttle) { 7836 un->un_max_xfer_size = 7837 ddi_getprop(DDI_DEV_T_ANY, devi, 0, 7838 sd_max_xfer_size, SD_MAX_XFER_SIZE); 7839 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7840 "sd_unit_attach: un:0x%p max transfer " 7841 "size=0x%x\n", un, un->un_max_xfer_size); 7842 } 7843 } else { 7844 if (scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer", 7845 0, 1) == 1) { 7846 SD_INFO(SD_LOG_ATTACH_DETACH, un, 7847 "sd_unit_attach: un:0x%p " 7848 "Wide Transfer disabled\n", un); 7849 } 7850 } 7851 } else { 7852 un->un_tagflags = FLAG_STAG; 7853 un->un_max_xfer_size = ddi_getprop(DDI_DEV_T_ANY, 7854 devi, 0, sd_max_xfer_size, SD_MAX_XFER_SIZE); 7855 } 7856 7857 /* 7858 * If this target supports LUN reset, try to enable it. 7859 */ 7860 if (un->un_f_lun_reset_enabled) { 7861 if (scsi_ifsetcap(SD_ADDRESS(un), "lun-reset", 1, 1) == 1) { 7862 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_unit_attach: " 7863 "un:0x%p lun_reset capability set\n", un); 7864 } else { 7865 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_unit_attach: " 7866 "un:0x%p lun-reset capability not set\n", un); 7867 } 7868 } 7869 7870 /* 7871 * Adjust the maximum transfer size. This is to fix 7872 * the problem of partial DMA support on SPARC. Some 7873 * HBA driver, like aac, has very small dma_attr_maxxfer 7874 * size, which requires partial DMA support on SPARC. 7875 * In the future the SPARC pci nexus driver may solve 7876 * the problem instead of this fix. 7877 */ 7878 max_xfer_size = scsi_ifgetcap(SD_ADDRESS(un), "dma-max", 1); 7879 if ((max_xfer_size > 0) && (max_xfer_size < un->un_max_xfer_size)) { 7880 /* We need DMA partial even on sparc to ensure sddump() works */ 7881 un->un_max_xfer_size = max_xfer_size; 7882 if (un->un_partial_dma_supported == 0) 7883 un->un_partial_dma_supported = 1; 7884 } 7885 if (ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un), 7886 DDI_PROP_DONTPASS, "buf_break", 0) == 1) { 7887 if (ddi_xbuf_attr_setup_brk(un->un_xbuf_attr, 7888 un->un_max_xfer_size) == 1) { 7889 un->un_buf_breakup_supported = 1; 7890 SD_INFO(SD_LOG_ATTACH_DETACH, un, "sd_unit_attach: " 7891 "un:0x%p Buf breakup enabled\n", un); 7892 } 7893 } 7894 7895 /* 7896 * Set PKT_DMA_PARTIAL flag. 7897 */ 7898 if (un->un_partial_dma_supported == 1) { 7899 un->un_pkt_flags = PKT_DMA_PARTIAL; 7900 } else { 7901 un->un_pkt_flags = 0; 7902 } 7903 7904 /* Initialize sd_ssc_t for internal uscsi commands */ 7905 ssc = sd_ssc_init(un); 7906 scsi_fm_init(devp); 7907 7908 /* 7909 * Allocate memory for SCSI FMA stuffs. 7910 */ 7911 un->un_fm_private = 7912 kmem_zalloc(sizeof (struct sd_fm_internal), KM_SLEEP); 7913 sfip = (struct sd_fm_internal *)un->un_fm_private; 7914 sfip->fm_ssc.ssc_uscsi_cmd = &sfip->fm_ucmd; 7915 sfip->fm_ssc.ssc_uscsi_info = &sfip->fm_uinfo; 7916 sfip->fm_ssc.ssc_un = un; 7917 7918 if (ISCD(un) || 7919 un->un_f_has_removable_media || 7920 devp->sd_fm_capable == DDI_FM_NOT_CAPABLE) { 7921 /* 7922 * We don't touch CDROM or the DDI_FM_NOT_CAPABLE device. 7923 * Their log are unchanged. 7924 */ 7925 sfip->fm_log_level = SD_FM_LOG_NSUP; 7926 } else { 7927 /* 7928 * If enter here, it should be non-CDROM and FM-capable 7929 * device, and it will not keep the old scsi_log as before 7930 * in /var/adm/messages. However, the property 7931 * "fm-scsi-log" will control whether the FM telemetry will 7932 * be logged in /var/adm/messages. 7933 */ 7934 int fm_scsi_log; 7935 fm_scsi_log = ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un), 7936 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "fm-scsi-log", 0); 7937 7938 if (fm_scsi_log) 7939 sfip->fm_log_level = SD_FM_LOG_EREPORT; 7940 else 7941 sfip->fm_log_level = SD_FM_LOG_SILENT; 7942 } 7943 7944 /* 7945 * At this point in the attach, we have enough info in the 7946 * soft state to be able to issue commands to the target. 7947 * 7948 * All command paths used below MUST issue their commands as 7949 * SD_PATH_DIRECT. This is important as intermediate layers 7950 * are not all initialized yet (such as PM). 7951 */ 7952 7953 /* 7954 * Send a TEST UNIT READY command to the device. This should clear 7955 * any outstanding UNIT ATTENTION that may be present. 7956 * 7957 * Note: Don't check for success, just track if there is a reservation, 7958 * this is a throw away command to clear any unit attentions. 7959 * 7960 * Note: This MUST be the first command issued to the target during 7961 * attach to ensure power on UNIT ATTENTIONS are cleared. 7962 * Pass in flag SD_DONT_RETRY_TUR to prevent the long delays associated 7963 * with attempts at spinning up a device with no media. 7964 */ 7965 status = sd_send_scsi_TEST_UNIT_READY(ssc, SD_DONT_RETRY_TUR); 7966 if (status != 0) { 7967 if (status == EACCES) 7968 reservation_flag = SD_TARGET_IS_RESERVED; 7969 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 7970 } 7971 7972 /* 7973 * If the device is NOT a removable media device, attempt to spin 7974 * it up (using the START_STOP_UNIT command) and read its capacity 7975 * (using the READ CAPACITY command). Note, however, that either 7976 * of these could fail and in some cases we would continue with 7977 * the attach despite the failure (see below). 7978 */ 7979 if (un->un_f_descr_format_supported) { 7980 7981 switch (sd_spin_up_unit(ssc)) { 7982 case 0: 7983 /* 7984 * Spin-up was successful; now try to read the 7985 * capacity. If successful then save the results 7986 * and mark the capacity & lbasize as valid. 7987 */ 7988 SD_TRACE(SD_LOG_ATTACH_DETACH, un, 7989 "sd_unit_attach: un:0x%p spin-up successful\n", un); 7990 7991 status = sd_send_scsi_READ_CAPACITY(ssc, &capacity, 7992 &lbasize, SD_PATH_DIRECT); 7993 7994 switch (status) { 7995 case 0: { 7996 if (capacity > DK_MAX_BLOCKS) { 7997 #ifdef _LP64 7998 if ((capacity + 1) > 7999 SD_GROUP1_MAX_ADDRESS) { 8000 /* 8001 * Enable descriptor format 8002 * sense data so that we can 8003 * get 64 bit sense data 8004 * fields. 8005 */ 8006 sd_enable_descr_sense(ssc); 8007 } 8008 #else 8009 /* 32-bit kernels can't handle this */ 8010 scsi_log(SD_DEVINFO(un), 8011 sd_label, CE_WARN, 8012 "disk has %llu blocks, which " 8013 "is too large for a 32-bit " 8014 "kernel", capacity); 8015 8016 #if defined(__i386) || defined(__amd64) 8017 /* 8018 * 1TB disk was treated as (1T - 512)B 8019 * in the past, so that it might have 8020 * valid VTOC and solaris partitions, 8021 * we have to allow it to continue to 8022 * work. 8023 */ 8024 if (capacity -1 > DK_MAX_BLOCKS) 8025 #endif 8026 goto spinup_failed; 8027 #endif 8028 } 8029 8030 /* 8031 * Here it's not necessary to check the case: 8032 * the capacity of the device is bigger than 8033 * what the max hba cdb can support. Because 8034 * sd_send_scsi_READ_CAPACITY will retrieve 8035 * the capacity by sending USCSI command, which 8036 * is constrained by the max hba cdb. Actually, 8037 * sd_send_scsi_READ_CAPACITY will return 8038 * EINVAL when using bigger cdb than required 8039 * cdb length. Will handle this case in 8040 * "case EINVAL". 8041 */ 8042 8043 /* 8044 * The following relies on 8045 * sd_send_scsi_READ_CAPACITY never 8046 * returning 0 for capacity and/or lbasize. 8047 */ 8048 sd_update_block_info(un, lbasize, capacity); 8049 8050 SD_INFO(SD_LOG_ATTACH_DETACH, un, 8051 "sd_unit_attach: un:0x%p capacity = %ld " 8052 "blocks; lbasize= %ld.\n", un, 8053 un->un_blockcount, un->un_tgt_blocksize); 8054 8055 break; 8056 } 8057 case EINVAL: 8058 /* 8059 * In the case where the max-cdb-length property 8060 * is smaller than the required CDB length for 8061 * a SCSI device, a target driver can fail to 8062 * attach to that device. 8063 */ 8064 scsi_log(SD_DEVINFO(un), 8065 sd_label, CE_WARN, 8066 "disk capacity is too large " 8067 "for current cdb length"); 8068 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 8069 8070 goto spinup_failed; 8071 case EACCES: 8072 /* 8073 * Should never get here if the spin-up 8074 * succeeded, but code it in anyway. 8075 * From here, just continue with the attach... 8076 */ 8077 SD_INFO(SD_LOG_ATTACH_DETACH, un, 8078 "sd_unit_attach: un:0x%p " 8079 "sd_send_scsi_READ_CAPACITY " 8080 "returned reservation conflict\n", un); 8081 reservation_flag = SD_TARGET_IS_RESERVED; 8082 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 8083 break; 8084 default: 8085 /* 8086 * Likewise, should never get here if the 8087 * spin-up succeeded. Just continue with 8088 * the attach... 8089 */ 8090 if (status == EIO) 8091 sd_ssc_assessment(ssc, 8092 SD_FMT_STATUS_CHECK); 8093 else 8094 sd_ssc_assessment(ssc, 8095 SD_FMT_IGNORE); 8096 break; 8097 } 8098 break; 8099 case EACCES: 8100 /* 8101 * Device is reserved by another host. In this case 8102 * we could not spin it up or read the capacity, but 8103 * we continue with the attach anyway. 8104 */ 8105 SD_INFO(SD_LOG_ATTACH_DETACH, un, 8106 "sd_unit_attach: un:0x%p spin-up reservation " 8107 "conflict.\n", un); 8108 reservation_flag = SD_TARGET_IS_RESERVED; 8109 break; 8110 default: 8111 /* Fail the attach if the spin-up failed. */ 8112 SD_INFO(SD_LOG_ATTACH_DETACH, un, 8113 "sd_unit_attach: un:0x%p spin-up failed.", un); 8114 goto spinup_failed; 8115 } 8116 8117 } 8118 8119 /* 8120 * Check to see if this is a MMC drive 8121 */ 8122 if (ISCD(un)) { 8123 sd_set_mmc_caps(ssc); 8124 } 8125 8126 /* 8127 * Add a zero-length attribute to tell the world we support 8128 * kernel ioctls (for layered drivers) 8129 */ 8130 (void) ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP, 8131 DDI_KERNEL_IOCTL, NULL, 0); 8132 8133 /* 8134 * Add a boolean property to tell the world we support 8135 * the B_FAILFAST flag (for layered drivers) 8136 */ 8137 (void) ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP, 8138 "ddi-failfast-supported", NULL, 0); 8139 8140 /* 8141 * Initialize power management 8142 */ 8143 mutex_init(&un->un_pm_mutex, NULL, MUTEX_DRIVER, NULL); 8144 cv_init(&un->un_pm_busy_cv, NULL, CV_DRIVER, NULL); 8145 sd_setup_pm(ssc, devi); 8146 if (un->un_f_pm_is_enabled == FALSE) { 8147 /* 8148 * For performance, point to a jump table that does 8149 * not include pm. 8150 * The direct and priority chains don't change with PM. 8151 * 8152 * Note: this is currently done based on individual device 8153 * capabilities. When an interface for determining system 8154 * power enabled state becomes available, or when additional 8155 * layers are added to the command chain, these values will 8156 * have to be re-evaluated for correctness. 8157 */ 8158 if (un->un_f_non_devbsize_supported) { 8159 un->un_buf_chain_type = SD_CHAIN_INFO_RMMEDIA_NO_PM; 8160 } else { 8161 un->un_buf_chain_type = SD_CHAIN_INFO_DISK_NO_PM; 8162 } 8163 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD_NO_PM; 8164 } 8165 8166 /* 8167 * This property is set to 0 by HA software to avoid retries 8168 * on a reserved disk. (The preferred property name is 8169 * "retry-on-reservation-conflict") (1189689) 8170 * 8171 * Note: The use of a global here can have unintended consequences. A 8172 * per instance variable is preferable to match the capabilities of 8173 * different underlying hba's (4402600) 8174 */ 8175 sd_retry_on_reservation_conflict = ddi_getprop(DDI_DEV_T_ANY, devi, 8176 DDI_PROP_DONTPASS, "retry-on-reservation-conflict", 8177 sd_retry_on_reservation_conflict); 8178 if (sd_retry_on_reservation_conflict != 0) { 8179 sd_retry_on_reservation_conflict = ddi_getprop(DDI_DEV_T_ANY, 8180 devi, DDI_PROP_DONTPASS, sd_resv_conflict_name, 8181 sd_retry_on_reservation_conflict); 8182 } 8183 8184 /* Set up options for QFULL handling. */ 8185 if ((rval = ddi_getprop(DDI_DEV_T_ANY, devi, 0, 8186 "qfull-retries", -1)) != -1) { 8187 (void) scsi_ifsetcap(SD_ADDRESS(un), "qfull-retries", 8188 rval, 1); 8189 } 8190 if ((rval = ddi_getprop(DDI_DEV_T_ANY, devi, 0, 8191 "qfull-retry-interval", -1)) != -1) { 8192 (void) scsi_ifsetcap(SD_ADDRESS(un), "qfull-retry-interval", 8193 rval, 1); 8194 } 8195 8196 /* 8197 * This just prints a message that announces the existence of the 8198 * device. The message is always printed in the system logfile, but 8199 * only appears on the console if the system is booted with the 8200 * -v (verbose) argument. 8201 */ 8202 ddi_report_dev(devi); 8203 8204 un->un_mediastate = DKIO_NONE; 8205 8206 /* 8207 * Check if this is a SSD(Solid State Drive). 8208 */ 8209 sd_check_solid_state(ssc); 8210 8211 /* 8212 * Check whether the drive is in emulation mode. 8213 */ 8214 sd_check_emulation_mode(ssc); 8215 8216 cmlb_alloc_handle(&un->un_cmlbhandle); 8217 8218 #if defined(__i386) || defined(__amd64) 8219 /* 8220 * On x86, compensate for off-by-1 legacy error 8221 */ 8222 if (!un->un_f_has_removable_media && !un->un_f_is_hotpluggable && 8223 (lbasize == un->un_sys_blocksize)) 8224 offbyone = CMLB_OFF_BY_ONE; 8225 #endif 8226 8227 if (cmlb_attach(devi, &sd_tgops, (int)devp->sd_inq->inq_dtype, 8228 VOID2BOOLEAN(un->un_f_has_removable_media != 0), 8229 VOID2BOOLEAN(un->un_f_is_hotpluggable != 0), 8230 un->un_node_type, offbyone, un->un_cmlbhandle, 8231 (void *)SD_PATH_DIRECT) != 0) { 8232 goto cmlb_attach_failed; 8233 } 8234 8235 8236 /* 8237 * Read and validate the device's geometry (ie, disk label) 8238 * A new unformatted drive will not have a valid geometry, but 8239 * the driver needs to successfully attach to this device so 8240 * the drive can be formatted via ioctls. 8241 */ 8242 geom_label_valid = (cmlb_validate(un->un_cmlbhandle, 0, 8243 (void *)SD_PATH_DIRECT) == 0) ? 1: 0; 8244 8245 mutex_enter(SD_MUTEX(un)); 8246 8247 /* 8248 * Read and initialize the devid for the unit. 8249 */ 8250 if (un->un_f_devid_supported) { 8251 sd_register_devid(ssc, devi, reservation_flag); 8252 } 8253 mutex_exit(SD_MUTEX(un)); 8254 8255 #if (defined(__fibre)) 8256 /* 8257 * Register callbacks for fibre only. You can't do this solely 8258 * on the basis of the devid_type because this is hba specific. 8259 * We need to query our hba capabilities to find out whether to 8260 * register or not. 8261 */ 8262 if (un->un_f_is_fibre) { 8263 if (strcmp(un->un_node_type, DDI_NT_BLOCK_CHAN)) { 8264 sd_init_event_callbacks(un); 8265 SD_TRACE(SD_LOG_ATTACH_DETACH, un, 8266 "sd_unit_attach: un:0x%p event callbacks inserted", 8267 un); 8268 } 8269 } 8270 #endif 8271 8272 if (un->un_f_opt_disable_cache == TRUE) { 8273 /* 8274 * Disable both read cache and write cache. This is 8275 * the historic behavior of the keywords in the config file. 8276 */ 8277 if (sd_cache_control(ssc, SD_CACHE_DISABLE, SD_CACHE_DISABLE) != 8278 0) { 8279 SD_ERROR(SD_LOG_ATTACH_DETACH, un, 8280 "sd_unit_attach: un:0x%p Could not disable " 8281 "caching", un); 8282 goto devid_failed; 8283 } 8284 } 8285 8286 /* 8287 * Check the value of the WCE bit now and 8288 * set un_f_write_cache_enabled accordingly. 8289 */ 8290 (void) sd_get_write_cache_enabled(ssc, &wc_enabled); 8291 mutex_enter(SD_MUTEX(un)); 8292 un->un_f_write_cache_enabled = (wc_enabled != 0); 8293 mutex_exit(SD_MUTEX(un)); 8294 8295 if ((un->un_f_rmw_type != SD_RMW_TYPE_RETURN_ERROR && 8296 un->un_tgt_blocksize != DEV_BSIZE) || 8297 un->un_f_enable_rmw) { 8298 if (!(un->un_wm_cache)) { 8299 (void) snprintf(name_str, sizeof (name_str), 8300 "%s%d_cache", 8301 ddi_driver_name(SD_DEVINFO(un)), 8302 ddi_get_instance(SD_DEVINFO(un))); 8303 un->un_wm_cache = kmem_cache_create( 8304 name_str, sizeof (struct sd_w_map), 8305 8, sd_wm_cache_constructor, 8306 sd_wm_cache_destructor, NULL, 8307 (void *)un, NULL, 0); 8308 if (!(un->un_wm_cache)) { 8309 goto wm_cache_failed; 8310 } 8311 } 8312 } 8313 8314 /* 8315 * Check the value of the NV_SUP bit and set 8316 * un_f_suppress_cache_flush accordingly. 8317 */ 8318 sd_get_nv_sup(ssc); 8319 8320 /* 8321 * Find out what type of reservation this disk supports. 8322 */ 8323 status = sd_send_scsi_PERSISTENT_RESERVE_IN(ssc, SD_READ_KEYS, 0, NULL); 8324 8325 switch (status) { 8326 case 0: 8327 /* 8328 * SCSI-3 reservations are supported. 8329 */ 8330 un->un_reservation_type = SD_SCSI3_RESERVATION; 8331 SD_INFO(SD_LOG_ATTACH_DETACH, un, 8332 "sd_unit_attach: un:0x%p SCSI-3 reservations\n", un); 8333 break; 8334 case ENOTSUP: 8335 /* 8336 * The PERSISTENT RESERVE IN command would not be recognized by 8337 * a SCSI-2 device, so assume the reservation type is SCSI-2. 8338 */ 8339 SD_INFO(SD_LOG_ATTACH_DETACH, un, 8340 "sd_unit_attach: un:0x%p SCSI-2 reservations\n", un); 8341 un->un_reservation_type = SD_SCSI2_RESERVATION; 8342 8343 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 8344 break; 8345 default: 8346 /* 8347 * default to SCSI-3 reservations 8348 */ 8349 SD_INFO(SD_LOG_ATTACH_DETACH, un, 8350 "sd_unit_attach: un:0x%p default SCSI3 reservations\n", un); 8351 un->un_reservation_type = SD_SCSI3_RESERVATION; 8352 8353 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 8354 break; 8355 } 8356 8357 /* 8358 * Set the pstat and error stat values here, so data obtained during the 8359 * previous attach-time routines is available. 8360 * 8361 * Note: This is a critical sequence that needs to be maintained: 8362 * 1) Instantiate the kstats before any routines using the iopath 8363 * (i.e. sd_send_scsi_cmd). 8364 * 2) Initialize the error stats (sd_set_errstats) and partition 8365 * stats (sd_set_pstats)here, following 8366 * cmlb_validate_geometry(), sd_register_devid(), and 8367 * sd_cache_control(). 8368 */ 8369 8370 if (un->un_f_pkstats_enabled && geom_label_valid) { 8371 sd_set_pstats(un); 8372 SD_TRACE(SD_LOG_IO_PARTITION, un, 8373 "sd_unit_attach: un:0x%p pstats created and set\n", un); 8374 } 8375 8376 sd_set_errstats(un); 8377 SD_TRACE(SD_LOG_ATTACH_DETACH, un, 8378 "sd_unit_attach: un:0x%p errstats set\n", un); 8379 8380 8381 /* 8382 * After successfully attaching an instance, we record the information 8383 * of how many luns have been attached on the relative target and 8384 * controller for parallel SCSI. This information is used when sd tries 8385 * to set the tagged queuing capability in HBA. 8386 */ 8387 if (SD_IS_PARALLEL_SCSI(un) && (tgt >= 0) && (tgt < NTARGETS_WIDE)) { 8388 sd_scsi_update_lun_on_target(pdip, tgt, SD_SCSI_LUN_ATTACH); 8389 } 8390 8391 SD_TRACE(SD_LOG_ATTACH_DETACH, un, 8392 "sd_unit_attach: un:0x%p exit success\n", un); 8393 8394 /* Uninitialize sd_ssc_t pointer */ 8395 sd_ssc_fini(ssc); 8396 8397 return (DDI_SUCCESS); 8398 8399 /* 8400 * An error occurred during the attach; clean up & return failure. 8401 */ 8402 wm_cache_failed: 8403 devid_failed: 8404 8405 setup_pm_failed: 8406 ddi_remove_minor_node(devi, NULL); 8407 8408 cmlb_attach_failed: 8409 /* 8410 * Cleanup from the scsi_ifsetcap() calls (437868) 8411 */ 8412 (void) scsi_ifsetcap(SD_ADDRESS(un), "lun-reset", 0, 1); 8413 (void) scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer", 0, 1); 8414 8415 /* 8416 * Refer to the comments of setting tagged-qing in the beginning of 8417 * sd_unit_attach. We can only disable tagged queuing when there is 8418 * no lun attached on the target. 8419 */ 8420 if (sd_scsi_get_target_lun_count(pdip, tgt) < 1) { 8421 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1); 8422 } 8423 8424 if (un->un_f_is_fibre == FALSE) { 8425 (void) scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 0, 1); 8426 } 8427 8428 spinup_failed: 8429 8430 /* Uninitialize sd_ssc_t pointer */ 8431 sd_ssc_fini(ssc); 8432 8433 mutex_enter(SD_MUTEX(un)); 8434 8435 /* Deallocate SCSI FMA memory spaces */ 8436 kmem_free(un->un_fm_private, sizeof (struct sd_fm_internal)); 8437 8438 /* Cancel callback for SD_PATH_DIRECT_PRIORITY cmd. restart */ 8439 if (un->un_direct_priority_timeid != NULL) { 8440 timeout_id_t temp_id = un->un_direct_priority_timeid; 8441 un->un_direct_priority_timeid = NULL; 8442 mutex_exit(SD_MUTEX(un)); 8443 (void) untimeout(temp_id); 8444 mutex_enter(SD_MUTEX(un)); 8445 } 8446 8447 /* Cancel any pending start/stop timeouts */ 8448 if (un->un_startstop_timeid != NULL) { 8449 timeout_id_t temp_id = un->un_startstop_timeid; 8450 un->un_startstop_timeid = NULL; 8451 mutex_exit(SD_MUTEX(un)); 8452 (void) untimeout(temp_id); 8453 mutex_enter(SD_MUTEX(un)); 8454 } 8455 8456 /* Cancel any pending reset-throttle timeouts */ 8457 if (un->un_reset_throttle_timeid != NULL) { 8458 timeout_id_t temp_id = un->un_reset_throttle_timeid; 8459 un->un_reset_throttle_timeid = NULL; 8460 mutex_exit(SD_MUTEX(un)); 8461 (void) untimeout(temp_id); 8462 mutex_enter(SD_MUTEX(un)); 8463 } 8464 8465 /* Cancel rmw warning message timeouts */ 8466 if (un->un_rmw_msg_timeid != NULL) { 8467 timeout_id_t temp_id = un->un_rmw_msg_timeid; 8468 un->un_rmw_msg_timeid = NULL; 8469 mutex_exit(SD_MUTEX(un)); 8470 (void) untimeout(temp_id); 8471 mutex_enter(SD_MUTEX(un)); 8472 } 8473 8474 /* Cancel any pending retry timeouts */ 8475 if (un->un_retry_timeid != NULL) { 8476 timeout_id_t temp_id = un->un_retry_timeid; 8477 un->un_retry_timeid = NULL; 8478 mutex_exit(SD_MUTEX(un)); 8479 (void) untimeout(temp_id); 8480 mutex_enter(SD_MUTEX(un)); 8481 } 8482 8483 /* Cancel any pending delayed cv broadcast timeouts */ 8484 if (un->un_dcvb_timeid != NULL) { 8485 timeout_id_t temp_id = un->un_dcvb_timeid; 8486 un->un_dcvb_timeid = NULL; 8487 mutex_exit(SD_MUTEX(un)); 8488 (void) untimeout(temp_id); 8489 mutex_enter(SD_MUTEX(un)); 8490 } 8491 8492 mutex_exit(SD_MUTEX(un)); 8493 8494 /* There should not be any in-progress I/O so ASSERT this check */ 8495 ASSERT(un->un_ncmds_in_transport == 0); 8496 ASSERT(un->un_ncmds_in_driver == 0); 8497 8498 /* Do not free the softstate if the callback routine is active */ 8499 sd_sync_with_callback(un); 8500 8501 /* 8502 * Partition stats apparently are not used with removables. These would 8503 * not have been created during attach, so no need to clean them up... 8504 */ 8505 if (un->un_errstats != NULL) { 8506 kstat_delete(un->un_errstats); 8507 un->un_errstats = NULL; 8508 } 8509 8510 create_errstats_failed: 8511 8512 if (un->un_stats != NULL) { 8513 kstat_delete(un->un_stats); 8514 un->un_stats = NULL; 8515 } 8516 8517 ddi_xbuf_attr_unregister_devinfo(un->un_xbuf_attr, devi); 8518 ddi_xbuf_attr_destroy(un->un_xbuf_attr); 8519 8520 ddi_prop_remove_all(devi); 8521 sema_destroy(&un->un_semoclose); 8522 cv_destroy(&un->un_state_cv); 8523 8524 getrbuf_failed: 8525 8526 sd_free_rqs(un); 8527 8528 alloc_rqs_failed: 8529 8530 devp->sd_private = NULL; 8531 bzero(un, sizeof (struct sd_lun)); /* Clear any stale data! */ 8532 8533 get_softstate_failed: 8534 /* 8535 * Note: the man pages are unclear as to whether or not doing a 8536 * ddi_soft_state_free(sd_state, instance) is the right way to 8537 * clean up after the ddi_soft_state_zalloc() if the subsequent 8538 * ddi_get_soft_state() fails. The implication seems to be 8539 * that the get_soft_state cannot fail if the zalloc succeeds. 8540 */ 8541 #ifndef XPV_HVM_DRIVER 8542 ddi_soft_state_free(sd_state, instance); 8543 #endif /* !XPV_HVM_DRIVER */ 8544 8545 probe_failed: 8546 scsi_unprobe(devp); 8547 8548 return (DDI_FAILURE); 8549 } 8550 8551 8552 /* 8553 * Function: sd_unit_detach 8554 * 8555 * Description: Performs DDI_DETACH processing for sddetach(). 8556 * 8557 * Return Code: DDI_SUCCESS 8558 * DDI_FAILURE 8559 * 8560 * Context: Kernel thread context 8561 */ 8562 8563 static int 8564 sd_unit_detach(dev_info_t *devi) 8565 { 8566 struct scsi_device *devp; 8567 struct sd_lun *un; 8568 int i; 8569 int tgt; 8570 dev_t dev; 8571 dev_info_t *pdip = ddi_get_parent(devi); 8572 #ifndef XPV_HVM_DRIVER 8573 int instance = ddi_get_instance(devi); 8574 #endif /* !XPV_HVM_DRIVER */ 8575 8576 mutex_enter(&sd_detach_mutex); 8577 8578 /* 8579 * Fail the detach for any of the following: 8580 * - Unable to get the sd_lun struct for the instance 8581 * - A layered driver has an outstanding open on the instance 8582 * - Another thread is already detaching this instance 8583 * - Another thread is currently performing an open 8584 */ 8585 devp = ddi_get_driver_private(devi); 8586 if ((devp == NULL) || 8587 ((un = (struct sd_lun *)devp->sd_private) == NULL) || 8588 (un->un_ncmds_in_driver != 0) || (un->un_layer_count != 0) || 8589 (un->un_detach_count != 0) || (un->un_opens_in_progress != 0)) { 8590 mutex_exit(&sd_detach_mutex); 8591 return (DDI_FAILURE); 8592 } 8593 8594 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_unit_detach: entry 0x%p\n", un); 8595 8596 /* 8597 * Mark this instance as currently in a detach, to inhibit any 8598 * opens from a layered driver. 8599 */ 8600 un->un_detach_count++; 8601 mutex_exit(&sd_detach_mutex); 8602 8603 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 8604 SCSI_ADDR_PROP_TARGET, -1); 8605 8606 dev = sd_make_device(SD_DEVINFO(un)); 8607 8608 #ifndef lint 8609 _NOTE(COMPETING_THREADS_NOW); 8610 #endif 8611 8612 mutex_enter(SD_MUTEX(un)); 8613 8614 /* 8615 * Fail the detach if there are any outstanding layered 8616 * opens on this device. 8617 */ 8618 for (i = 0; i < NDKMAP; i++) { 8619 if (un->un_ocmap.lyropen[i] != 0) { 8620 goto err_notclosed; 8621 } 8622 } 8623 8624 /* 8625 * Verify there are NO outstanding commands issued to this device. 8626 * ie, un_ncmds_in_transport == 0. 8627 * It's possible to have outstanding commands through the physio 8628 * code path, even though everything's closed. 8629 */ 8630 if ((un->un_ncmds_in_transport != 0) || (un->un_retry_timeid != NULL) || 8631 (un->un_direct_priority_timeid != NULL) || 8632 (un->un_state == SD_STATE_RWAIT)) { 8633 mutex_exit(SD_MUTEX(un)); 8634 SD_ERROR(SD_LOG_ATTACH_DETACH, un, 8635 "sd_dr_detach: Detach failure due to outstanding cmds\n"); 8636 goto err_stillbusy; 8637 } 8638 8639 /* 8640 * If we have the device reserved, release the reservation. 8641 */ 8642 if ((un->un_resvd_status & SD_RESERVE) && 8643 !(un->un_resvd_status & SD_LOST_RESERVE)) { 8644 mutex_exit(SD_MUTEX(un)); 8645 /* 8646 * Note: sd_reserve_release sends a command to the device 8647 * via the sd_ioctlcmd() path, and can sleep. 8648 */ 8649 if (sd_reserve_release(dev, SD_RELEASE) != 0) { 8650 SD_ERROR(SD_LOG_ATTACH_DETACH, un, 8651 "sd_dr_detach: Cannot release reservation \n"); 8652 } 8653 } else { 8654 mutex_exit(SD_MUTEX(un)); 8655 } 8656 8657 /* 8658 * Untimeout any reserve recover, throttle reset, restart unit 8659 * and delayed broadcast timeout threads. Protect the timeout pointer 8660 * from getting nulled by their callback functions. 8661 */ 8662 mutex_enter(SD_MUTEX(un)); 8663 if (un->un_resvd_timeid != NULL) { 8664 timeout_id_t temp_id = un->un_resvd_timeid; 8665 un->un_resvd_timeid = NULL; 8666 mutex_exit(SD_MUTEX(un)); 8667 (void) untimeout(temp_id); 8668 mutex_enter(SD_MUTEX(un)); 8669 } 8670 8671 if (un->un_reset_throttle_timeid != NULL) { 8672 timeout_id_t temp_id = un->un_reset_throttle_timeid; 8673 un->un_reset_throttle_timeid = NULL; 8674 mutex_exit(SD_MUTEX(un)); 8675 (void) untimeout(temp_id); 8676 mutex_enter(SD_MUTEX(un)); 8677 } 8678 8679 if (un->un_startstop_timeid != NULL) { 8680 timeout_id_t temp_id = un->un_startstop_timeid; 8681 un->un_startstop_timeid = NULL; 8682 mutex_exit(SD_MUTEX(un)); 8683 (void) untimeout(temp_id); 8684 mutex_enter(SD_MUTEX(un)); 8685 } 8686 8687 if (un->un_rmw_msg_timeid != NULL) { 8688 timeout_id_t temp_id = un->un_rmw_msg_timeid; 8689 un->un_rmw_msg_timeid = NULL; 8690 mutex_exit(SD_MUTEX(un)); 8691 (void) untimeout(temp_id); 8692 mutex_enter(SD_MUTEX(un)); 8693 } 8694 8695 if (un->un_dcvb_timeid != NULL) { 8696 timeout_id_t temp_id = un->un_dcvb_timeid; 8697 un->un_dcvb_timeid = NULL; 8698 mutex_exit(SD_MUTEX(un)); 8699 (void) untimeout(temp_id); 8700 } else { 8701 mutex_exit(SD_MUTEX(un)); 8702 } 8703 8704 /* Remove any pending reservation reclaim requests for this device */ 8705 sd_rmv_resv_reclaim_req(dev); 8706 8707 mutex_enter(SD_MUTEX(un)); 8708 8709 /* Cancel any pending callbacks for SD_PATH_DIRECT_PRIORITY cmd. */ 8710 if (un->un_direct_priority_timeid != NULL) { 8711 timeout_id_t temp_id = un->un_direct_priority_timeid; 8712 un->un_direct_priority_timeid = NULL; 8713 mutex_exit(SD_MUTEX(un)); 8714 (void) untimeout(temp_id); 8715 mutex_enter(SD_MUTEX(un)); 8716 } 8717 8718 /* Cancel any active multi-host disk watch thread requests */ 8719 if (un->un_mhd_token != NULL) { 8720 mutex_exit(SD_MUTEX(un)); 8721 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_mhd_token)); 8722 if (scsi_watch_request_terminate(un->un_mhd_token, 8723 SCSI_WATCH_TERMINATE_NOWAIT)) { 8724 SD_ERROR(SD_LOG_ATTACH_DETACH, un, 8725 "sd_dr_detach: Cannot cancel mhd watch request\n"); 8726 /* 8727 * Note: We are returning here after having removed 8728 * some driver timeouts above. This is consistent with 8729 * the legacy implementation but perhaps the watch 8730 * terminate call should be made with the wait flag set. 8731 */ 8732 goto err_stillbusy; 8733 } 8734 mutex_enter(SD_MUTEX(un)); 8735 un->un_mhd_token = NULL; 8736 } 8737 8738 if (un->un_swr_token != NULL) { 8739 mutex_exit(SD_MUTEX(un)); 8740 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_swr_token)); 8741 if (scsi_watch_request_terminate(un->un_swr_token, 8742 SCSI_WATCH_TERMINATE_NOWAIT)) { 8743 SD_ERROR(SD_LOG_ATTACH_DETACH, un, 8744 "sd_dr_detach: Cannot cancel swr watch request\n"); 8745 /* 8746 * Note: We are returning here after having removed 8747 * some driver timeouts above. This is consistent with 8748 * the legacy implementation but perhaps the watch 8749 * terminate call should be made with the wait flag set. 8750 */ 8751 goto err_stillbusy; 8752 } 8753 mutex_enter(SD_MUTEX(un)); 8754 un->un_swr_token = NULL; 8755 } 8756 8757 mutex_exit(SD_MUTEX(un)); 8758 8759 /* 8760 * Clear any scsi_reset_notifies. We clear the reset notifies 8761 * if we have not registered one. 8762 * Note: The sd_mhd_reset_notify_cb() fn tries to acquire SD_MUTEX! 8763 */ 8764 (void) scsi_reset_notify(SD_ADDRESS(un), SCSI_RESET_CANCEL, 8765 sd_mhd_reset_notify_cb, (caddr_t)un); 8766 8767 /* 8768 * protect the timeout pointers from getting nulled by 8769 * their callback functions during the cancellation process. 8770 * In such a scenario untimeout can be invoked with a null value. 8771 */ 8772 _NOTE(NO_COMPETING_THREADS_NOW); 8773 8774 mutex_enter(&un->un_pm_mutex); 8775 if (un->un_pm_idle_timeid != NULL) { 8776 timeout_id_t temp_id = un->un_pm_idle_timeid; 8777 un->un_pm_idle_timeid = NULL; 8778 mutex_exit(&un->un_pm_mutex); 8779 8780 /* 8781 * Timeout is active; cancel it. 8782 * Note that it'll never be active on a device 8783 * that does not support PM therefore we don't 8784 * have to check before calling pm_idle_component. 8785 */ 8786 (void) untimeout(temp_id); 8787 (void) pm_idle_component(SD_DEVINFO(un), 0); 8788 mutex_enter(&un->un_pm_mutex); 8789 } 8790 8791 /* 8792 * Check whether there is already a timeout scheduled for power 8793 * management. If yes then don't lower the power here, that's. 8794 * the timeout handler's job. 8795 */ 8796 if (un->un_pm_timeid != NULL) { 8797 timeout_id_t temp_id = un->un_pm_timeid; 8798 un->un_pm_timeid = NULL; 8799 mutex_exit(&un->un_pm_mutex); 8800 /* 8801 * Timeout is active; cancel it. 8802 * Note that it'll never be active on a device 8803 * that does not support PM therefore we don't 8804 * have to check before calling pm_idle_component. 8805 */ 8806 (void) untimeout(temp_id); 8807 (void) pm_idle_component(SD_DEVINFO(un), 0); 8808 8809 } else { 8810 mutex_exit(&un->un_pm_mutex); 8811 if ((un->un_f_pm_is_enabled == TRUE) && 8812 (pm_lower_power(SD_DEVINFO(un), 0, SD_PM_STATE_STOPPED(un)) 8813 != DDI_SUCCESS)) { 8814 SD_ERROR(SD_LOG_ATTACH_DETACH, un, 8815 "sd_dr_detach: Lower power request failed, ignoring.\n"); 8816 /* 8817 * Fix for bug: 4297749, item # 13 8818 * The above test now includes a check to see if PM is 8819 * supported by this device before call 8820 * pm_lower_power(). 8821 * Note, the following is not dead code. The call to 8822 * pm_lower_power above will generate a call back into 8823 * our sdpower routine which might result in a timeout 8824 * handler getting activated. Therefore the following 8825 * code is valid and necessary. 8826 */ 8827 mutex_enter(&un->un_pm_mutex); 8828 if (un->un_pm_timeid != NULL) { 8829 timeout_id_t temp_id = un->un_pm_timeid; 8830 un->un_pm_timeid = NULL; 8831 mutex_exit(&un->un_pm_mutex); 8832 (void) untimeout(temp_id); 8833 (void) pm_idle_component(SD_DEVINFO(un), 0); 8834 } else { 8835 mutex_exit(&un->un_pm_mutex); 8836 } 8837 } 8838 } 8839 8840 /* 8841 * Cleanup from the scsi_ifsetcap() calls (437868) 8842 * Relocated here from above to be after the call to 8843 * pm_lower_power, which was getting errors. 8844 */ 8845 (void) scsi_ifsetcap(SD_ADDRESS(un), "lun-reset", 0, 1); 8846 (void) scsi_ifsetcap(SD_ADDRESS(un), "wide-xfer", 0, 1); 8847 8848 /* 8849 * Currently, tagged queuing is supported per target based by HBA. 8850 * Setting this per lun instance actually sets the capability of this 8851 * target in HBA, which affects those luns already attached on the 8852 * same target. So during detach, we can only disable this capability 8853 * only when this is the only lun left on this target. By doing 8854 * this, we assume a target has the same tagged queuing capability 8855 * for every lun. The condition can be removed when HBA is changed to 8856 * support per lun based tagged queuing capability. 8857 */ 8858 if (sd_scsi_get_target_lun_count(pdip, tgt) <= 1) { 8859 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1); 8860 } 8861 8862 if (un->un_f_is_fibre == FALSE) { 8863 (void) scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 0, 1); 8864 } 8865 8866 /* 8867 * Remove any event callbacks, fibre only 8868 */ 8869 if (un->un_f_is_fibre == TRUE) { 8870 if ((un->un_insert_event != NULL) && 8871 (ddi_remove_event_handler(un->un_insert_cb_id) != 8872 DDI_SUCCESS)) { 8873 /* 8874 * Note: We are returning here after having done 8875 * substantial cleanup above. This is consistent 8876 * with the legacy implementation but this may not 8877 * be the right thing to do. 8878 */ 8879 SD_ERROR(SD_LOG_ATTACH_DETACH, un, 8880 "sd_dr_detach: Cannot cancel insert event\n"); 8881 goto err_remove_event; 8882 } 8883 un->un_insert_event = NULL; 8884 8885 if ((un->un_remove_event != NULL) && 8886 (ddi_remove_event_handler(un->un_remove_cb_id) != 8887 DDI_SUCCESS)) { 8888 /* 8889 * Note: We are returning here after having done 8890 * substantial cleanup above. This is consistent 8891 * with the legacy implementation but this may not 8892 * be the right thing to do. 8893 */ 8894 SD_ERROR(SD_LOG_ATTACH_DETACH, un, 8895 "sd_dr_detach: Cannot cancel remove event\n"); 8896 goto err_remove_event; 8897 } 8898 un->un_remove_event = NULL; 8899 } 8900 8901 /* Do not free the softstate if the callback routine is active */ 8902 sd_sync_with_callback(un); 8903 8904 cmlb_detach(un->un_cmlbhandle, (void *)SD_PATH_DIRECT); 8905 cmlb_free_handle(&un->un_cmlbhandle); 8906 8907 /* 8908 * Hold the detach mutex here, to make sure that no other threads ever 8909 * can access a (partially) freed soft state structure. 8910 */ 8911 mutex_enter(&sd_detach_mutex); 8912 8913 /* 8914 * Clean up the soft state struct. 8915 * Cleanup is done in reverse order of allocs/inits. 8916 * At this point there should be no competing threads anymore. 8917 */ 8918 8919 scsi_fm_fini(devp); 8920 8921 /* 8922 * Deallocate memory for SCSI FMA. 8923 */ 8924 kmem_free(un->un_fm_private, sizeof (struct sd_fm_internal)); 8925 8926 /* 8927 * Unregister and free device id if it was not registered 8928 * by the transport. 8929 */ 8930 if (un->un_f_devid_transport_defined == FALSE) 8931 ddi_devid_unregister(devi); 8932 8933 /* 8934 * free the devid structure if allocated before (by ddi_devid_init() 8935 * or ddi_devid_get()). 8936 */ 8937 if (un->un_devid) { 8938 ddi_devid_free(un->un_devid); 8939 un->un_devid = NULL; 8940 } 8941 8942 /* 8943 * Destroy wmap cache if it exists. 8944 */ 8945 if (un->un_wm_cache != NULL) { 8946 kmem_cache_destroy(un->un_wm_cache); 8947 un->un_wm_cache = NULL; 8948 } 8949 8950 /* 8951 * kstat cleanup is done in detach for all device types (4363169). 8952 * We do not want to fail detach if the device kstats are not deleted 8953 * since there is a confusion about the devo_refcnt for the device. 8954 * We just delete the kstats and let detach complete successfully. 8955 */ 8956 if (un->un_stats != NULL) { 8957 kstat_delete(un->un_stats); 8958 un->un_stats = NULL; 8959 } 8960 if (un->un_errstats != NULL) { 8961 kstat_delete(un->un_errstats); 8962 un->un_errstats = NULL; 8963 } 8964 8965 /* Remove partition stats */ 8966 if (un->un_f_pkstats_enabled) { 8967 for (i = 0; i < NSDMAP; i++) { 8968 if (un->un_pstats[i] != NULL) { 8969 kstat_delete(un->un_pstats[i]); 8970 un->un_pstats[i] = NULL; 8971 } 8972 } 8973 } 8974 8975 /* Remove xbuf registration */ 8976 ddi_xbuf_attr_unregister_devinfo(un->un_xbuf_attr, devi); 8977 ddi_xbuf_attr_destroy(un->un_xbuf_attr); 8978 8979 /* Remove driver properties */ 8980 ddi_prop_remove_all(devi); 8981 8982 mutex_destroy(&un->un_pm_mutex); 8983 cv_destroy(&un->un_pm_busy_cv); 8984 8985 cv_destroy(&un->un_wcc_cv); 8986 8987 /* Open/close semaphore */ 8988 sema_destroy(&un->un_semoclose); 8989 8990 /* Removable media condvar. */ 8991 cv_destroy(&un->un_state_cv); 8992 8993 /* Suspend/resume condvar. */ 8994 cv_destroy(&un->un_suspend_cv); 8995 cv_destroy(&un->un_disk_busy_cv); 8996 8997 sd_free_rqs(un); 8998 8999 /* Free up soft state */ 9000 devp->sd_private = NULL; 9001 9002 bzero(un, sizeof (struct sd_lun)); 9003 #ifndef XPV_HVM_DRIVER 9004 ddi_soft_state_free(sd_state, instance); 9005 #endif /* !XPV_HVM_DRIVER */ 9006 9007 mutex_exit(&sd_detach_mutex); 9008 9009 /* This frees up the INQUIRY data associated with the device. */ 9010 scsi_unprobe(devp); 9011 9012 /* 9013 * After successfully detaching an instance, we update the information 9014 * of how many luns have been attached in the relative target and 9015 * controller for parallel SCSI. This information is used when sd tries 9016 * to set the tagged queuing capability in HBA. 9017 * Since un has been released, we can't use SD_IS_PARALLEL_SCSI(un) to 9018 * check if the device is parallel SCSI. However, we don't need to 9019 * check here because we've already checked during attach. No device 9020 * that is not parallel SCSI is in the chain. 9021 */ 9022 if ((tgt >= 0) && (tgt < NTARGETS_WIDE)) { 9023 sd_scsi_update_lun_on_target(pdip, tgt, SD_SCSI_LUN_DETACH); 9024 } 9025 9026 return (DDI_SUCCESS); 9027 9028 err_notclosed: 9029 mutex_exit(SD_MUTEX(un)); 9030 9031 err_stillbusy: 9032 _NOTE(NO_COMPETING_THREADS_NOW); 9033 9034 err_remove_event: 9035 mutex_enter(&sd_detach_mutex); 9036 un->un_detach_count--; 9037 mutex_exit(&sd_detach_mutex); 9038 9039 SD_TRACE(SD_LOG_ATTACH_DETACH, un, "sd_unit_detach: exit failure\n"); 9040 return (DDI_FAILURE); 9041 } 9042 9043 9044 /* 9045 * Function: sd_create_errstats 9046 * 9047 * Description: This routine instantiates the device error stats. 9048 * 9049 * Note: During attach the stats are instantiated first so they are 9050 * available for attach-time routines that utilize the driver 9051 * iopath to send commands to the device. The stats are initialized 9052 * separately so data obtained during some attach-time routines is 9053 * available. (4362483) 9054 * 9055 * Arguments: un - driver soft state (unit) structure 9056 * instance - driver instance 9057 * 9058 * Context: Kernel thread context 9059 */ 9060 9061 static void 9062 sd_create_errstats(struct sd_lun *un, int instance) 9063 { 9064 struct sd_errstats *stp; 9065 char kstatmodule_err[KSTAT_STRLEN]; 9066 char kstatname[KSTAT_STRLEN]; 9067 int ndata = (sizeof (struct sd_errstats) / sizeof (kstat_named_t)); 9068 9069 ASSERT(un != NULL); 9070 9071 if (un->un_errstats != NULL) { 9072 return; 9073 } 9074 9075 (void) snprintf(kstatmodule_err, sizeof (kstatmodule_err), 9076 "%serr", sd_label); 9077 (void) snprintf(kstatname, sizeof (kstatname), 9078 "%s%d,err", sd_label, instance); 9079 9080 un->un_errstats = kstat_create(kstatmodule_err, instance, kstatname, 9081 "device_error", KSTAT_TYPE_NAMED, ndata, KSTAT_FLAG_PERSISTENT); 9082 9083 if (un->un_errstats == NULL) { 9084 SD_ERROR(SD_LOG_ATTACH_DETACH, un, 9085 "sd_create_errstats: Failed kstat_create\n"); 9086 return; 9087 } 9088 9089 stp = (struct sd_errstats *)un->un_errstats->ks_data; 9090 kstat_named_init(&stp->sd_softerrs, "Soft Errors", 9091 KSTAT_DATA_UINT32); 9092 kstat_named_init(&stp->sd_harderrs, "Hard Errors", 9093 KSTAT_DATA_UINT32); 9094 kstat_named_init(&stp->sd_transerrs, "Transport Errors", 9095 KSTAT_DATA_UINT32); 9096 kstat_named_init(&stp->sd_vid, "Vendor", 9097 KSTAT_DATA_CHAR); 9098 kstat_named_init(&stp->sd_pid, "Product", 9099 KSTAT_DATA_CHAR); 9100 kstat_named_init(&stp->sd_revision, "Revision", 9101 KSTAT_DATA_CHAR); 9102 kstat_named_init(&stp->sd_serial, "Serial No", 9103 KSTAT_DATA_CHAR); 9104 kstat_named_init(&stp->sd_capacity, "Size", 9105 KSTAT_DATA_ULONGLONG); 9106 kstat_named_init(&stp->sd_rq_media_err, "Media Error", 9107 KSTAT_DATA_UINT32); 9108 kstat_named_init(&stp->sd_rq_ntrdy_err, "Device Not Ready", 9109 KSTAT_DATA_UINT32); 9110 kstat_named_init(&stp->sd_rq_nodev_err, "No Device", 9111 KSTAT_DATA_UINT32); 9112 kstat_named_init(&stp->sd_rq_recov_err, "Recoverable", 9113 KSTAT_DATA_UINT32); 9114 kstat_named_init(&stp->sd_rq_illrq_err, "Illegal Request", 9115 KSTAT_DATA_UINT32); 9116 kstat_named_init(&stp->sd_rq_pfa_err, "Predictive Failure Analysis", 9117 KSTAT_DATA_UINT32); 9118 9119 un->un_errstats->ks_private = un; 9120 un->un_errstats->ks_update = nulldev; 9121 9122 kstat_install(un->un_errstats); 9123 } 9124 9125 9126 /* 9127 * Function: sd_set_errstats 9128 * 9129 * Description: This routine sets the value of the vendor id, product id, 9130 * revision, serial number, and capacity device error stats. 9131 * 9132 * Note: During attach the stats are instantiated first so they are 9133 * available for attach-time routines that utilize the driver 9134 * iopath to send commands to the device. The stats are initialized 9135 * separately so data obtained during some attach-time routines is 9136 * available. (4362483) 9137 * 9138 * Arguments: un - driver soft state (unit) structure 9139 * 9140 * Context: Kernel thread context 9141 */ 9142 9143 static void 9144 sd_set_errstats(struct sd_lun *un) 9145 { 9146 struct sd_errstats *stp; 9147 char *sn; 9148 9149 ASSERT(un != NULL); 9150 ASSERT(un->un_errstats != NULL); 9151 stp = (struct sd_errstats *)un->un_errstats->ks_data; 9152 ASSERT(stp != NULL); 9153 (void) strncpy(stp->sd_vid.value.c, un->un_sd->sd_inq->inq_vid, 8); 9154 (void) strncpy(stp->sd_pid.value.c, un->un_sd->sd_inq->inq_pid, 16); 9155 (void) strncpy(stp->sd_revision.value.c, 9156 un->un_sd->sd_inq->inq_revision, 4); 9157 9158 /* 9159 * All the errstats are persistent across detach/attach, 9160 * so reset all the errstats here in case of the hot 9161 * replacement of disk drives, except for not changed 9162 * Sun qualified drives. 9163 */ 9164 if ((bcmp(&SD_INQUIRY(un)->inq_pid[9], "SUN", 3) != 0) || 9165 (bcmp(&SD_INQUIRY(un)->inq_serial, stp->sd_serial.value.c, 9166 sizeof (SD_INQUIRY(un)->inq_serial)) != 0)) { 9167 stp->sd_softerrs.value.ui32 = 0; 9168 stp->sd_harderrs.value.ui32 = 0; 9169 stp->sd_transerrs.value.ui32 = 0; 9170 stp->sd_rq_media_err.value.ui32 = 0; 9171 stp->sd_rq_ntrdy_err.value.ui32 = 0; 9172 stp->sd_rq_nodev_err.value.ui32 = 0; 9173 stp->sd_rq_recov_err.value.ui32 = 0; 9174 stp->sd_rq_illrq_err.value.ui32 = 0; 9175 stp->sd_rq_pfa_err.value.ui32 = 0; 9176 } 9177 9178 /* 9179 * Set the "Serial No" kstat for Sun qualified drives (indicated by 9180 * "SUN" in bytes 25-27 of the inquiry data (bytes 9-11 of the pid) 9181 * (4376302)) 9182 */ 9183 if (bcmp(&SD_INQUIRY(un)->inq_pid[9], "SUN", 3) == 0) { 9184 bcopy(&SD_INQUIRY(un)->inq_serial, stp->sd_serial.value.c, 9185 sizeof (SD_INQUIRY(un)->inq_serial)); 9186 } else { 9187 /* 9188 * Set the "Serial No" kstat for non-Sun qualified drives 9189 */ 9190 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, SD_DEVINFO(un), 9191 DDI_PROP_NOTPROM | DDI_PROP_DONTPASS, 9192 INQUIRY_SERIAL_NO, &sn) == DDI_SUCCESS) { 9193 (void) strlcpy(stp->sd_serial.value.c, sn, 9194 sizeof (stp->sd_serial.value.c)); 9195 ddi_prop_free(sn); 9196 } 9197 } 9198 9199 if (un->un_f_blockcount_is_valid != TRUE) { 9200 /* 9201 * Set capacity error stat to 0 for no media. This ensures 9202 * a valid capacity is displayed in response to 'iostat -E' 9203 * when no media is present in the device. 9204 */ 9205 stp->sd_capacity.value.ui64 = 0; 9206 } else { 9207 /* 9208 * Multiply un_blockcount by un->un_sys_blocksize to get 9209 * capacity. 9210 * 9211 * Note: for non-512 blocksize devices "un_blockcount" has been 9212 * "scaled" in sd_send_scsi_READ_CAPACITY by multiplying by 9213 * (un_tgt_blocksize / un->un_sys_blocksize). 9214 */ 9215 stp->sd_capacity.value.ui64 = (uint64_t) 9216 ((uint64_t)un->un_blockcount * un->un_sys_blocksize); 9217 } 9218 } 9219 9220 9221 /* 9222 * Function: sd_set_pstats 9223 * 9224 * Description: This routine instantiates and initializes the partition 9225 * stats for each partition with more than zero blocks. 9226 * (4363169) 9227 * 9228 * Arguments: un - driver soft state (unit) structure 9229 * 9230 * Context: Kernel thread context 9231 */ 9232 9233 static void 9234 sd_set_pstats(struct sd_lun *un) 9235 { 9236 char kstatname[KSTAT_STRLEN]; 9237 int instance; 9238 int i; 9239 diskaddr_t nblks = 0; 9240 char *partname = NULL; 9241 9242 ASSERT(un != NULL); 9243 9244 instance = ddi_get_instance(SD_DEVINFO(un)); 9245 9246 /* Note:x86: is this a VTOC8/VTOC16 difference? */ 9247 for (i = 0; i < NSDMAP; i++) { 9248 9249 if (cmlb_partinfo(un->un_cmlbhandle, i, 9250 &nblks, NULL, &partname, NULL, (void *)SD_PATH_DIRECT) != 0) 9251 continue; 9252 mutex_enter(SD_MUTEX(un)); 9253 9254 if ((un->un_pstats[i] == NULL) && 9255 (nblks != 0)) { 9256 9257 (void) snprintf(kstatname, sizeof (kstatname), 9258 "%s%d,%s", sd_label, instance, 9259 partname); 9260 9261 un->un_pstats[i] = kstat_create(sd_label, 9262 instance, kstatname, "partition", KSTAT_TYPE_IO, 9263 1, KSTAT_FLAG_PERSISTENT); 9264 if (un->un_pstats[i] != NULL) { 9265 un->un_pstats[i]->ks_lock = SD_MUTEX(un); 9266 kstat_install(un->un_pstats[i]); 9267 } 9268 } 9269 mutex_exit(SD_MUTEX(un)); 9270 } 9271 } 9272 9273 9274 #if (defined(__fibre)) 9275 /* 9276 * Function: sd_init_event_callbacks 9277 * 9278 * Description: This routine initializes the insertion and removal event 9279 * callbacks. (fibre only) 9280 * 9281 * Arguments: un - driver soft state (unit) structure 9282 * 9283 * Context: Kernel thread context 9284 */ 9285 9286 static void 9287 sd_init_event_callbacks(struct sd_lun *un) 9288 { 9289 ASSERT(un != NULL); 9290 9291 if ((un->un_insert_event == NULL) && 9292 (ddi_get_eventcookie(SD_DEVINFO(un), FCAL_INSERT_EVENT, 9293 &un->un_insert_event) == DDI_SUCCESS)) { 9294 /* 9295 * Add the callback for an insertion event 9296 */ 9297 (void) ddi_add_event_handler(SD_DEVINFO(un), 9298 un->un_insert_event, sd_event_callback, (void *)un, 9299 &(un->un_insert_cb_id)); 9300 } 9301 9302 if ((un->un_remove_event == NULL) && 9303 (ddi_get_eventcookie(SD_DEVINFO(un), FCAL_REMOVE_EVENT, 9304 &un->un_remove_event) == DDI_SUCCESS)) { 9305 /* 9306 * Add the callback for a removal event 9307 */ 9308 (void) ddi_add_event_handler(SD_DEVINFO(un), 9309 un->un_remove_event, sd_event_callback, (void *)un, 9310 &(un->un_remove_cb_id)); 9311 } 9312 } 9313 9314 9315 /* 9316 * Function: sd_event_callback 9317 * 9318 * Description: This routine handles insert/remove events (photon). The 9319 * state is changed to OFFLINE which can be used to supress 9320 * error msgs. (fibre only) 9321 * 9322 * Arguments: un - driver soft state (unit) structure 9323 * 9324 * Context: Callout thread context 9325 */ 9326 /* ARGSUSED */ 9327 static void 9328 sd_event_callback(dev_info_t *dip, ddi_eventcookie_t event, void *arg, 9329 void *bus_impldata) 9330 { 9331 struct sd_lun *un = (struct sd_lun *)arg; 9332 9333 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_insert_event)); 9334 if (event == un->un_insert_event) { 9335 SD_TRACE(SD_LOG_COMMON, un, "sd_event_callback: insert event"); 9336 mutex_enter(SD_MUTEX(un)); 9337 if (un->un_state == SD_STATE_OFFLINE) { 9338 if (un->un_last_state != SD_STATE_SUSPENDED) { 9339 un->un_state = un->un_last_state; 9340 } else { 9341 /* 9342 * We have gone through SUSPEND/RESUME while 9343 * we were offline. Restore the last state 9344 */ 9345 un->un_state = un->un_save_state; 9346 } 9347 } 9348 mutex_exit(SD_MUTEX(un)); 9349 9350 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_remove_event)); 9351 } else if (event == un->un_remove_event) { 9352 SD_TRACE(SD_LOG_COMMON, un, "sd_event_callback: remove event"); 9353 mutex_enter(SD_MUTEX(un)); 9354 /* 9355 * We need to handle an event callback that occurs during 9356 * the suspend operation, since we don't prevent it. 9357 */ 9358 if (un->un_state != SD_STATE_OFFLINE) { 9359 if (un->un_state != SD_STATE_SUSPENDED) { 9360 New_state(un, SD_STATE_OFFLINE); 9361 } else { 9362 un->un_last_state = SD_STATE_OFFLINE; 9363 } 9364 } 9365 mutex_exit(SD_MUTEX(un)); 9366 } else { 9367 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE, 9368 "!Unknown event\n"); 9369 } 9370 9371 } 9372 #endif 9373 9374 /* 9375 * Function: sd_cache_control() 9376 * 9377 * Description: This routine is the driver entry point for setting 9378 * read and write caching by modifying the WCE (write cache 9379 * enable) and RCD (read cache disable) bits of mode 9380 * page 8 (MODEPAGE_CACHING). 9381 * 9382 * Arguments: ssc - ssc contains pointer to driver soft state (unit) 9383 * structure for this target. 9384 * rcd_flag - flag for controlling the read cache 9385 * wce_flag - flag for controlling the write cache 9386 * 9387 * Return Code: EIO 9388 * code returned by sd_send_scsi_MODE_SENSE and 9389 * sd_send_scsi_MODE_SELECT 9390 * 9391 * Context: Kernel Thread 9392 */ 9393 9394 static int 9395 sd_cache_control(sd_ssc_t *ssc, int rcd_flag, int wce_flag) 9396 { 9397 struct mode_caching *mode_caching_page; 9398 uchar_t *header; 9399 size_t buflen; 9400 int hdrlen; 9401 int bd_len; 9402 int rval = 0; 9403 struct mode_header_grp2 *mhp; 9404 struct sd_lun *un; 9405 int status; 9406 9407 ASSERT(ssc != NULL); 9408 un = ssc->ssc_un; 9409 ASSERT(un != NULL); 9410 9411 /* 9412 * Do a test unit ready, otherwise a mode sense may not work if this 9413 * is the first command sent to the device after boot. 9414 */ 9415 status = sd_send_scsi_TEST_UNIT_READY(ssc, 0); 9416 if (status != 0) 9417 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 9418 9419 if (un->un_f_cfg_is_atapi == TRUE) { 9420 hdrlen = MODE_HEADER_LENGTH_GRP2; 9421 } else { 9422 hdrlen = MODE_HEADER_LENGTH; 9423 } 9424 9425 /* 9426 * Allocate memory for the retrieved mode page and its headers. Set 9427 * a pointer to the page itself. Use mode_cache_scsi3 to insure 9428 * we get all of the mode sense data otherwise, the mode select 9429 * will fail. mode_cache_scsi3 is a superset of mode_caching. 9430 */ 9431 buflen = hdrlen + MODE_BLK_DESC_LENGTH + 9432 sizeof (struct mode_cache_scsi3); 9433 9434 header = kmem_zalloc(buflen, KM_SLEEP); 9435 9436 /* Get the information from the device. */ 9437 if (un->un_f_cfg_is_atapi == TRUE) { 9438 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, header, buflen, 9439 MODEPAGE_CACHING, SD_PATH_DIRECT); 9440 } else { 9441 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, header, buflen, 9442 MODEPAGE_CACHING, SD_PATH_DIRECT); 9443 } 9444 9445 if (rval != 0) { 9446 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un, 9447 "sd_cache_control: Mode Sense Failed\n"); 9448 goto mode_sense_failed; 9449 } 9450 9451 /* 9452 * Determine size of Block Descriptors in order to locate 9453 * the mode page data. ATAPI devices return 0, SCSI devices 9454 * should return MODE_BLK_DESC_LENGTH. 9455 */ 9456 if (un->un_f_cfg_is_atapi == TRUE) { 9457 mhp = (struct mode_header_grp2 *)header; 9458 bd_len = (mhp->bdesc_length_hi << 8) | mhp->bdesc_length_lo; 9459 } else { 9460 bd_len = ((struct mode_header *)header)->bdesc_length; 9461 } 9462 9463 if (bd_len > MODE_BLK_DESC_LENGTH) { 9464 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, 0, 9465 "sd_cache_control: Mode Sense returned invalid block " 9466 "descriptor length\n"); 9467 rval = EIO; 9468 goto mode_sense_failed; 9469 } 9470 9471 mode_caching_page = (struct mode_caching *)(header + hdrlen + bd_len); 9472 if (mode_caching_page->mode_page.code != MODEPAGE_CACHING) { 9473 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON, 9474 "sd_cache_control: Mode Sense caching page code mismatch " 9475 "%d\n", mode_caching_page->mode_page.code); 9476 rval = EIO; 9477 goto mode_sense_failed; 9478 } 9479 9480 /* Check the relevant bits on successful mode sense. */ 9481 if ((mode_caching_page->rcd && rcd_flag == SD_CACHE_ENABLE) || 9482 (!mode_caching_page->rcd && rcd_flag == SD_CACHE_DISABLE) || 9483 (mode_caching_page->wce && wce_flag == SD_CACHE_DISABLE) || 9484 (!mode_caching_page->wce && wce_flag == SD_CACHE_ENABLE)) { 9485 9486 size_t sbuflen; 9487 uchar_t save_pg; 9488 9489 /* 9490 * Construct select buffer length based on the 9491 * length of the sense data returned. 9492 */ 9493 sbuflen = hdrlen + bd_len + 9494 sizeof (struct mode_page) + 9495 (int)mode_caching_page->mode_page.length; 9496 9497 /* 9498 * Set the caching bits as requested. 9499 */ 9500 if (rcd_flag == SD_CACHE_ENABLE) 9501 mode_caching_page->rcd = 0; 9502 else if (rcd_flag == SD_CACHE_DISABLE) 9503 mode_caching_page->rcd = 1; 9504 9505 if (wce_flag == SD_CACHE_ENABLE) 9506 mode_caching_page->wce = 1; 9507 else if (wce_flag == SD_CACHE_DISABLE) 9508 mode_caching_page->wce = 0; 9509 9510 /* 9511 * Save the page if the mode sense says the 9512 * drive supports it. 9513 */ 9514 save_pg = mode_caching_page->mode_page.ps ? 9515 SD_SAVE_PAGE : SD_DONTSAVE_PAGE; 9516 9517 /* Clear reserved bits before mode select. */ 9518 mode_caching_page->mode_page.ps = 0; 9519 9520 /* 9521 * Clear out mode header for mode select. 9522 * The rest of the retrieved page will be reused. 9523 */ 9524 bzero(header, hdrlen); 9525 9526 if (un->un_f_cfg_is_atapi == TRUE) { 9527 mhp = (struct mode_header_grp2 *)header; 9528 mhp->bdesc_length_hi = bd_len >> 8; 9529 mhp->bdesc_length_lo = (uchar_t)bd_len & 0xff; 9530 } else { 9531 ((struct mode_header *)header)->bdesc_length = bd_len; 9532 } 9533 9534 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 9535 9536 /* Issue mode select to change the cache settings */ 9537 if (un->un_f_cfg_is_atapi == TRUE) { 9538 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP1, header, 9539 sbuflen, save_pg, SD_PATH_DIRECT); 9540 } else { 9541 rval = sd_send_scsi_MODE_SELECT(ssc, CDB_GROUP0, header, 9542 sbuflen, save_pg, SD_PATH_DIRECT); 9543 } 9544 9545 } 9546 9547 9548 mode_sense_failed: 9549 9550 kmem_free(header, buflen); 9551 9552 if (rval != 0) { 9553 if (rval == EIO) 9554 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK); 9555 else 9556 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 9557 } 9558 return (rval); 9559 } 9560 9561 9562 /* 9563 * Function: sd_get_write_cache_enabled() 9564 * 9565 * Description: This routine is the driver entry point for determining if 9566 * write caching is enabled. It examines the WCE (write cache 9567 * enable) bits of mode page 8 (MODEPAGE_CACHING). 9568 * 9569 * Arguments: ssc - ssc contains pointer to driver soft state (unit) 9570 * structure for this target. 9571 * is_enabled - pointer to int where write cache enabled state 9572 * is returned (non-zero -> write cache enabled) 9573 * 9574 * 9575 * Return Code: EIO 9576 * code returned by sd_send_scsi_MODE_SENSE 9577 * 9578 * Context: Kernel Thread 9579 * 9580 * NOTE: If ioctl is added to disable write cache, this sequence should 9581 * be followed so that no locking is required for accesses to 9582 * un->un_f_write_cache_enabled: 9583 * do mode select to clear wce 9584 * do synchronize cache to flush cache 9585 * set un->un_f_write_cache_enabled = FALSE 9586 * 9587 * Conversely, an ioctl to enable the write cache should be done 9588 * in this order: 9589 * set un->un_f_write_cache_enabled = TRUE 9590 * do mode select to set wce 9591 */ 9592 9593 static int 9594 sd_get_write_cache_enabled(sd_ssc_t *ssc, int *is_enabled) 9595 { 9596 struct mode_caching *mode_caching_page; 9597 uchar_t *header; 9598 size_t buflen; 9599 int hdrlen; 9600 int bd_len; 9601 int rval = 0; 9602 struct sd_lun *un; 9603 int status; 9604 9605 ASSERT(ssc != NULL); 9606 un = ssc->ssc_un; 9607 ASSERT(un != NULL); 9608 ASSERT(is_enabled != NULL); 9609 9610 /* in case of error, flag as enabled */ 9611 *is_enabled = TRUE; 9612 9613 /* 9614 * Do a test unit ready, otherwise a mode sense may not work if this 9615 * is the first command sent to the device after boot. 9616 */ 9617 status = sd_send_scsi_TEST_UNIT_READY(ssc, 0); 9618 9619 if (status != 0) 9620 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 9621 9622 if (un->un_f_cfg_is_atapi == TRUE) { 9623 hdrlen = MODE_HEADER_LENGTH_GRP2; 9624 } else { 9625 hdrlen = MODE_HEADER_LENGTH; 9626 } 9627 9628 /* 9629 * Allocate memory for the retrieved mode page and its headers. Set 9630 * a pointer to the page itself. 9631 */ 9632 buflen = hdrlen + MODE_BLK_DESC_LENGTH + sizeof (struct mode_caching); 9633 header = kmem_zalloc(buflen, KM_SLEEP); 9634 9635 /* Get the information from the device. */ 9636 if (un->un_f_cfg_is_atapi == TRUE) { 9637 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP1, header, buflen, 9638 MODEPAGE_CACHING, SD_PATH_DIRECT); 9639 } else { 9640 rval = sd_send_scsi_MODE_SENSE(ssc, CDB_GROUP0, header, buflen, 9641 MODEPAGE_CACHING, SD_PATH_DIRECT); 9642 } 9643 9644 if (rval != 0) { 9645 SD_ERROR(SD_LOG_IOCTL_RMMEDIA, un, 9646 "sd_get_write_cache_enabled: Mode Sense Failed\n"); 9647 goto mode_sense_failed; 9648 } 9649 9650 /* 9651 * Determine size of Block Descriptors in order to locate 9652 * the mode page data. ATAPI devices return 0, SCSI devices 9653 * should return MODE_BLK_DESC_LENGTH. 9654 */ 9655 if (un->un_f_cfg_is_atapi == TRUE) { 9656 struct mode_header_grp2 *mhp; 9657 mhp = (struct mode_header_grp2 *)header; 9658 bd_len = (mhp->bdesc_length_hi << 8) | mhp->bdesc_length_lo; 9659 } else { 9660 bd_len = ((struct mode_header *)header)->bdesc_length; 9661 } 9662 9663 if (bd_len > MODE_BLK_DESC_LENGTH) { 9664 /* FMA should make upset complain here */ 9665 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, 0, 9666 "sd_get_write_cache_enabled: Mode Sense returned invalid " 9667 "block descriptor length\n"); 9668 rval = EIO; 9669 goto mode_sense_failed; 9670 } 9671 9672 mode_caching_page = (struct mode_caching *)(header + hdrlen + bd_len); 9673 if (mode_caching_page->mode_page.code != MODEPAGE_CACHING) { 9674 /* FMA could make upset complain here */ 9675 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, SD_LOG_COMMON, 9676 "sd_get_write_cache_enabled: Mode Sense caching page " 9677 "code mismatch %d\n", mode_caching_page->mode_page.code); 9678 rval = EIO; 9679 goto mode_sense_failed; 9680 } 9681 *is_enabled = mode_caching_page->wce; 9682 9683 mode_sense_failed: 9684 if (rval == 0) { 9685 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 9686 } else if (rval == EIO) { 9687 /* 9688 * Some disks do not support mode sense(6), we 9689 * should ignore this kind of error(sense key is 9690 * 0x5 - illegal request). 9691 */ 9692 uint8_t *sensep; 9693 int senlen; 9694 9695 sensep = (uint8_t *)ssc->ssc_uscsi_cmd->uscsi_rqbuf; 9696 senlen = (int)(ssc->ssc_uscsi_cmd->uscsi_rqlen - 9697 ssc->ssc_uscsi_cmd->uscsi_rqresid); 9698 9699 if (senlen > 0 && 9700 scsi_sense_key(sensep) == KEY_ILLEGAL_REQUEST) { 9701 sd_ssc_assessment(ssc, SD_FMT_IGNORE_COMPROMISE); 9702 } else { 9703 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK); 9704 } 9705 } else { 9706 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 9707 } 9708 kmem_free(header, buflen); 9709 return (rval); 9710 } 9711 9712 /* 9713 * Function: sd_get_nv_sup() 9714 * 9715 * Description: This routine is the driver entry point for 9716 * determining whether non-volatile cache is supported. This 9717 * determination process works as follows: 9718 * 9719 * 1. sd first queries sd.conf on whether 9720 * suppress_cache_flush bit is set for this device. 9721 * 9722 * 2. if not there, then queries the internal disk table. 9723 * 9724 * 3. if either sd.conf or internal disk table specifies 9725 * cache flush be suppressed, we don't bother checking 9726 * NV_SUP bit. 9727 * 9728 * If SUPPRESS_CACHE_FLUSH bit is not set to 1, sd queries 9729 * the optional INQUIRY VPD page 0x86. If the device 9730 * supports VPD page 0x86, sd examines the NV_SUP 9731 * (non-volatile cache support) bit in the INQUIRY VPD page 9732 * 0x86: 9733 * o If NV_SUP bit is set, sd assumes the device has a 9734 * non-volatile cache and set the 9735 * un_f_sync_nv_supported to TRUE. 9736 * o Otherwise cache is not non-volatile, 9737 * un_f_sync_nv_supported is set to FALSE. 9738 * 9739 * Arguments: un - driver soft state (unit) structure 9740 * 9741 * Return Code: 9742 * 9743 * Context: Kernel Thread 9744 */ 9745 9746 static void 9747 sd_get_nv_sup(sd_ssc_t *ssc) 9748 { 9749 int rval = 0; 9750 uchar_t *inq86 = NULL; 9751 size_t inq86_len = MAX_INQUIRY_SIZE; 9752 size_t inq86_resid = 0; 9753 struct dk_callback *dkc; 9754 struct sd_lun *un; 9755 9756 ASSERT(ssc != NULL); 9757 un = ssc->ssc_un; 9758 ASSERT(un != NULL); 9759 9760 mutex_enter(SD_MUTEX(un)); 9761 9762 /* 9763 * Be conservative on the device's support of 9764 * SYNC_NV bit: un_f_sync_nv_supported is 9765 * initialized to be false. 9766 */ 9767 un->un_f_sync_nv_supported = FALSE; 9768 9769 /* 9770 * If either sd.conf or internal disk table 9771 * specifies cache flush be suppressed, then 9772 * we don't bother checking NV_SUP bit. 9773 */ 9774 if (un->un_f_suppress_cache_flush == TRUE) { 9775 mutex_exit(SD_MUTEX(un)); 9776 return; 9777 } 9778 9779 if (sd_check_vpd_page_support(ssc) == 0 && 9780 un->un_vpd_page_mask & SD_VPD_EXTENDED_DATA_PG) { 9781 mutex_exit(SD_MUTEX(un)); 9782 /* collect page 86 data if available */ 9783 inq86 = kmem_zalloc(inq86_len, KM_SLEEP); 9784 9785 rval = sd_send_scsi_INQUIRY(ssc, inq86, inq86_len, 9786 0x01, 0x86, &inq86_resid); 9787 9788 if (rval == 0 && (inq86_len - inq86_resid > 6)) { 9789 SD_TRACE(SD_LOG_COMMON, un, 9790 "sd_get_nv_sup: \ 9791 successfully get VPD page: %x \ 9792 PAGE LENGTH: %x BYTE 6: %x\n", 9793 inq86[1], inq86[3], inq86[6]); 9794 9795 mutex_enter(SD_MUTEX(un)); 9796 /* 9797 * check the value of NV_SUP bit: only if the device 9798 * reports NV_SUP bit to be 1, the 9799 * un_f_sync_nv_supported bit will be set to true. 9800 */ 9801 if (inq86[6] & SD_VPD_NV_SUP) { 9802 un->un_f_sync_nv_supported = TRUE; 9803 } 9804 mutex_exit(SD_MUTEX(un)); 9805 } else if (rval != 0) { 9806 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 9807 } 9808 9809 kmem_free(inq86, inq86_len); 9810 } else { 9811 mutex_exit(SD_MUTEX(un)); 9812 } 9813 9814 /* 9815 * Send a SYNC CACHE command to check whether 9816 * SYNC_NV bit is supported. This command should have 9817 * un_f_sync_nv_supported set to correct value. 9818 */ 9819 mutex_enter(SD_MUTEX(un)); 9820 if (un->un_f_sync_nv_supported) { 9821 mutex_exit(SD_MUTEX(un)); 9822 dkc = kmem_zalloc(sizeof (struct dk_callback), KM_SLEEP); 9823 dkc->dkc_flag = FLUSH_VOLATILE; 9824 (void) sd_send_scsi_SYNCHRONIZE_CACHE(un, dkc); 9825 9826 /* 9827 * Send a TEST UNIT READY command to the device. This should 9828 * clear any outstanding UNIT ATTENTION that may be present. 9829 */ 9830 rval = sd_send_scsi_TEST_UNIT_READY(ssc, SD_DONT_RETRY_TUR); 9831 if (rval != 0) 9832 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 9833 9834 kmem_free(dkc, sizeof (struct dk_callback)); 9835 } else { 9836 mutex_exit(SD_MUTEX(un)); 9837 } 9838 9839 SD_TRACE(SD_LOG_COMMON, un, "sd_get_nv_sup: \ 9840 un_f_suppress_cache_flush is set to %d\n", 9841 un->un_f_suppress_cache_flush); 9842 } 9843 9844 /* 9845 * Function: sd_make_device 9846 * 9847 * Description: Utility routine to return the Solaris device number from 9848 * the data in the device's dev_info structure. 9849 * 9850 * Return Code: The Solaris device number 9851 * 9852 * Context: Any 9853 */ 9854 9855 static dev_t 9856 sd_make_device(dev_info_t *devi) 9857 { 9858 return (makedevice(ddi_driver_major(devi), 9859 ddi_get_instance(devi) << SDUNIT_SHIFT)); 9860 } 9861 9862 9863 /* 9864 * Function: sd_pm_entry 9865 * 9866 * Description: Called at the start of a new command to manage power 9867 * and busy status of a device. This includes determining whether 9868 * the current power state of the device is sufficient for 9869 * performing the command or whether it must be changed. 9870 * The PM framework is notified appropriately. 9871 * Only with a return status of DDI_SUCCESS will the 9872 * component be busy to the framework. 9873 * 9874 * All callers of sd_pm_entry must check the return status 9875 * and only call sd_pm_exit it it was DDI_SUCCESS. A status 9876 * of DDI_FAILURE indicates the device failed to power up. 9877 * In this case un_pm_count has been adjusted so the result 9878 * on exit is still powered down, ie. count is less than 0. 9879 * Calling sd_pm_exit with this count value hits an ASSERT. 9880 * 9881 * Return Code: DDI_SUCCESS or DDI_FAILURE 9882 * 9883 * Context: Kernel thread context. 9884 */ 9885 9886 static int 9887 sd_pm_entry(struct sd_lun *un) 9888 { 9889 int return_status = DDI_SUCCESS; 9890 9891 ASSERT(!mutex_owned(SD_MUTEX(un))); 9892 ASSERT(!mutex_owned(&un->un_pm_mutex)); 9893 9894 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_entry: entry\n"); 9895 9896 if (un->un_f_pm_is_enabled == FALSE) { 9897 SD_TRACE(SD_LOG_IO_PM, un, 9898 "sd_pm_entry: exiting, PM not enabled\n"); 9899 return (return_status); 9900 } 9901 9902 /* 9903 * Just increment a counter if PM is enabled. On the transition from 9904 * 0 ==> 1, mark the device as busy. The iodone side will decrement 9905 * the count with each IO and mark the device as idle when the count 9906 * hits 0. 9907 * 9908 * If the count is less than 0 the device is powered down. If a powered 9909 * down device is successfully powered up then the count must be 9910 * incremented to reflect the power up. Note that it'll get incremented 9911 * a second time to become busy. 9912 * 9913 * Because the following has the potential to change the device state 9914 * and must release the un_pm_mutex to do so, only one thread can be 9915 * allowed through at a time. 9916 */ 9917 9918 mutex_enter(&un->un_pm_mutex); 9919 while (un->un_pm_busy == TRUE) { 9920 cv_wait(&un->un_pm_busy_cv, &un->un_pm_mutex); 9921 } 9922 un->un_pm_busy = TRUE; 9923 9924 if (un->un_pm_count < 1) { 9925 9926 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_entry: busy component\n"); 9927 9928 /* 9929 * Indicate we are now busy so the framework won't attempt to 9930 * power down the device. This call will only fail if either 9931 * we passed a bad component number or the device has no 9932 * components. Neither of these should ever happen. 9933 */ 9934 mutex_exit(&un->un_pm_mutex); 9935 return_status = pm_busy_component(SD_DEVINFO(un), 0); 9936 ASSERT(return_status == DDI_SUCCESS); 9937 9938 mutex_enter(&un->un_pm_mutex); 9939 9940 if (un->un_pm_count < 0) { 9941 mutex_exit(&un->un_pm_mutex); 9942 9943 SD_TRACE(SD_LOG_IO_PM, un, 9944 "sd_pm_entry: power up component\n"); 9945 9946 /* 9947 * pm_raise_power will cause sdpower to be called 9948 * which brings the device power level to the 9949 * desired state, If successful, un_pm_count and 9950 * un_power_level will be updated appropriately. 9951 */ 9952 return_status = pm_raise_power(SD_DEVINFO(un), 0, 9953 SD_PM_STATE_ACTIVE(un)); 9954 9955 mutex_enter(&un->un_pm_mutex); 9956 9957 if (return_status != DDI_SUCCESS) { 9958 /* 9959 * Power up failed. 9960 * Idle the device and adjust the count 9961 * so the result on exit is that we're 9962 * still powered down, ie. count is less than 0. 9963 */ 9964 SD_TRACE(SD_LOG_IO_PM, un, 9965 "sd_pm_entry: power up failed," 9966 " idle the component\n"); 9967 9968 (void) pm_idle_component(SD_DEVINFO(un), 0); 9969 un->un_pm_count--; 9970 } else { 9971 /* 9972 * Device is powered up, verify the 9973 * count is non-negative. 9974 * This is debug only. 9975 */ 9976 ASSERT(un->un_pm_count == 0); 9977 } 9978 } 9979 9980 if (return_status == DDI_SUCCESS) { 9981 /* 9982 * For performance, now that the device has been tagged 9983 * as busy, and it's known to be powered up, update the 9984 * chain types to use jump tables that do not include 9985 * pm. This significantly lowers the overhead and 9986 * therefore improves performance. 9987 */ 9988 9989 mutex_exit(&un->un_pm_mutex); 9990 mutex_enter(SD_MUTEX(un)); 9991 SD_TRACE(SD_LOG_IO_PM, un, 9992 "sd_pm_entry: changing uscsi_chain_type from %d\n", 9993 un->un_uscsi_chain_type); 9994 9995 if (un->un_f_non_devbsize_supported) { 9996 un->un_buf_chain_type = 9997 SD_CHAIN_INFO_RMMEDIA_NO_PM; 9998 } else { 9999 un->un_buf_chain_type = 10000 SD_CHAIN_INFO_DISK_NO_PM; 10001 } 10002 un->un_uscsi_chain_type = SD_CHAIN_INFO_USCSI_CMD_NO_PM; 10003 10004 SD_TRACE(SD_LOG_IO_PM, un, 10005 " changed uscsi_chain_type to %d\n", 10006 un->un_uscsi_chain_type); 10007 mutex_exit(SD_MUTEX(un)); 10008 mutex_enter(&un->un_pm_mutex); 10009 10010 if (un->un_pm_idle_timeid == NULL) { 10011 /* 300 ms. */ 10012 un->un_pm_idle_timeid = 10013 timeout(sd_pm_idletimeout_handler, un, 10014 (drv_usectohz((clock_t)300000))); 10015 /* 10016 * Include an extra call to busy which keeps the 10017 * device busy with-respect-to the PM layer 10018 * until the timer fires, at which time it'll 10019 * get the extra idle call. 10020 */ 10021 (void) pm_busy_component(SD_DEVINFO(un), 0); 10022 } 10023 } 10024 } 10025 un->un_pm_busy = FALSE; 10026 /* Next... */ 10027 cv_signal(&un->un_pm_busy_cv); 10028 10029 un->un_pm_count++; 10030 10031 SD_TRACE(SD_LOG_IO_PM, un, 10032 "sd_pm_entry: exiting, un_pm_count = %d\n", un->un_pm_count); 10033 10034 mutex_exit(&un->un_pm_mutex); 10035 10036 return (return_status); 10037 } 10038 10039 10040 /* 10041 * Function: sd_pm_exit 10042 * 10043 * Description: Called at the completion of a command to manage busy 10044 * status for the device. If the device becomes idle the 10045 * PM framework is notified. 10046 * 10047 * Context: Kernel thread context 10048 */ 10049 10050 static void 10051 sd_pm_exit(struct sd_lun *un) 10052 { 10053 ASSERT(!mutex_owned(SD_MUTEX(un))); 10054 ASSERT(!mutex_owned(&un->un_pm_mutex)); 10055 10056 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_exit: entry\n"); 10057 10058 /* 10059 * After attach the following flag is only read, so don't 10060 * take the penalty of acquiring a mutex for it. 10061 */ 10062 if (un->un_f_pm_is_enabled == TRUE) { 10063 10064 mutex_enter(&un->un_pm_mutex); 10065 un->un_pm_count--; 10066 10067 SD_TRACE(SD_LOG_IO_PM, un, 10068 "sd_pm_exit: un_pm_count = %d\n", un->un_pm_count); 10069 10070 ASSERT(un->un_pm_count >= 0); 10071 if (un->un_pm_count == 0) { 10072 mutex_exit(&un->un_pm_mutex); 10073 10074 SD_TRACE(SD_LOG_IO_PM, un, 10075 "sd_pm_exit: idle component\n"); 10076 10077 (void) pm_idle_component(SD_DEVINFO(un), 0); 10078 10079 } else { 10080 mutex_exit(&un->un_pm_mutex); 10081 } 10082 } 10083 10084 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_exit: exiting\n"); 10085 } 10086 10087 10088 /* 10089 * Function: sdopen 10090 * 10091 * Description: Driver's open(9e) entry point function. 10092 * 10093 * Arguments: dev_i - pointer to device number 10094 * flag - how to open file (FEXCL, FNDELAY, FREAD, FWRITE) 10095 * otyp - open type (OTYP_BLK, OTYP_CHR, OTYP_LYR) 10096 * cred_p - user credential pointer 10097 * 10098 * Return Code: EINVAL 10099 * ENXIO 10100 * EIO 10101 * EROFS 10102 * EBUSY 10103 * 10104 * Context: Kernel thread context 10105 */ 10106 /* ARGSUSED */ 10107 static int 10108 sdopen(dev_t *dev_p, int flag, int otyp, cred_t *cred_p) 10109 { 10110 struct sd_lun *un; 10111 int nodelay; 10112 int part; 10113 uint64_t partmask; 10114 int instance; 10115 dev_t dev; 10116 int rval = EIO; 10117 diskaddr_t nblks = 0; 10118 diskaddr_t label_cap; 10119 10120 /* Validate the open type */ 10121 if (otyp >= OTYPCNT) { 10122 return (EINVAL); 10123 } 10124 10125 dev = *dev_p; 10126 instance = SDUNIT(dev); 10127 mutex_enter(&sd_detach_mutex); 10128 10129 /* 10130 * Fail the open if there is no softstate for the instance, or 10131 * if another thread somewhere is trying to detach the instance. 10132 */ 10133 if (((un = ddi_get_soft_state(sd_state, instance)) == NULL) || 10134 (un->un_detach_count != 0)) { 10135 mutex_exit(&sd_detach_mutex); 10136 /* 10137 * The probe cache only needs to be cleared when open (9e) fails 10138 * with ENXIO (4238046). 10139 */ 10140 /* 10141 * un-conditionally clearing probe cache is ok with 10142 * separate sd/ssd binaries 10143 * x86 platform can be an issue with both parallel 10144 * and fibre in 1 binary 10145 */ 10146 sd_scsi_clear_probe_cache(); 10147 return (ENXIO); 10148 } 10149 10150 /* 10151 * The un_layer_count is to prevent another thread in specfs from 10152 * trying to detach the instance, which can happen when we are 10153 * called from a higher-layer driver instead of thru specfs. 10154 * This will not be needed when DDI provides a layered driver 10155 * interface that allows specfs to know that an instance is in 10156 * use by a layered driver & should not be detached. 10157 * 10158 * Note: the semantics for layered driver opens are exactly one 10159 * close for every open. 10160 */ 10161 if (otyp == OTYP_LYR) { 10162 un->un_layer_count++; 10163 } 10164 10165 /* 10166 * Keep a count of the current # of opens in progress. This is because 10167 * some layered drivers try to call us as a regular open. This can 10168 * cause problems that we cannot prevent, however by keeping this count 10169 * we can at least keep our open and detach routines from racing against 10170 * each other under such conditions. 10171 */ 10172 un->un_opens_in_progress++; 10173 mutex_exit(&sd_detach_mutex); 10174 10175 nodelay = (flag & (FNDELAY | FNONBLOCK)); 10176 part = SDPART(dev); 10177 partmask = 1 << part; 10178 10179 /* 10180 * We use a semaphore here in order to serialize 10181 * open and close requests on the device. 10182 */ 10183 sema_p(&un->un_semoclose); 10184 10185 mutex_enter(SD_MUTEX(un)); 10186 10187 /* 10188 * All device accesses go thru sdstrategy() where we check 10189 * on suspend status but there could be a scsi_poll command, 10190 * which bypasses sdstrategy(), so we need to check pm 10191 * status. 10192 */ 10193 10194 if (!nodelay) { 10195 while ((un->un_state == SD_STATE_SUSPENDED) || 10196 (un->un_state == SD_STATE_PM_CHANGING)) { 10197 cv_wait(&un->un_suspend_cv, SD_MUTEX(un)); 10198 } 10199 10200 mutex_exit(SD_MUTEX(un)); 10201 if (sd_pm_entry(un) != DDI_SUCCESS) { 10202 rval = EIO; 10203 SD_ERROR(SD_LOG_OPEN_CLOSE, un, 10204 "sdopen: sd_pm_entry failed\n"); 10205 goto open_failed_with_pm; 10206 } 10207 mutex_enter(SD_MUTEX(un)); 10208 } 10209 10210 /* check for previous exclusive open */ 10211 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdopen: un=%p\n", (void *)un); 10212 SD_TRACE(SD_LOG_OPEN_CLOSE, un, 10213 "sdopen: exclopen=%x, flag=%x, regopen=%x\n", 10214 un->un_exclopen, flag, un->un_ocmap.regopen[otyp]); 10215 10216 if (un->un_exclopen & (partmask)) { 10217 goto excl_open_fail; 10218 } 10219 10220 if (flag & FEXCL) { 10221 int i; 10222 if (un->un_ocmap.lyropen[part]) { 10223 goto excl_open_fail; 10224 } 10225 for (i = 0; i < (OTYPCNT - 1); i++) { 10226 if (un->un_ocmap.regopen[i] & (partmask)) { 10227 goto excl_open_fail; 10228 } 10229 } 10230 } 10231 10232 /* 10233 * Check the write permission if this is a removable media device, 10234 * NDELAY has not been set, and writable permission is requested. 10235 * 10236 * Note: If NDELAY was set and this is write-protected media the WRITE 10237 * attempt will fail with EIO as part of the I/O processing. This is a 10238 * more permissive implementation that allows the open to succeed and 10239 * WRITE attempts to fail when appropriate. 10240 */ 10241 if (un->un_f_chk_wp_open) { 10242 if ((flag & FWRITE) && (!nodelay)) { 10243 mutex_exit(SD_MUTEX(un)); 10244 /* 10245 * Defer the check for write permission on writable 10246 * DVD drive till sdstrategy and will not fail open even 10247 * if FWRITE is set as the device can be writable 10248 * depending upon the media and the media can change 10249 * after the call to open(). 10250 */ 10251 if (un->un_f_dvdram_writable_device == FALSE) { 10252 if (ISCD(un) || sr_check_wp(dev)) { 10253 rval = EROFS; 10254 mutex_enter(SD_MUTEX(un)); 10255 SD_ERROR(SD_LOG_OPEN_CLOSE, un, "sdopen: " 10256 "write to cd or write protected media\n"); 10257 goto open_fail; 10258 } 10259 } 10260 mutex_enter(SD_MUTEX(un)); 10261 } 10262 } 10263 10264 /* 10265 * If opening in NDELAY/NONBLOCK mode, just return. 10266 * Check if disk is ready and has a valid geometry later. 10267 */ 10268 if (!nodelay) { 10269 sd_ssc_t *ssc; 10270 10271 mutex_exit(SD_MUTEX(un)); 10272 ssc = sd_ssc_init(un); 10273 rval = sd_ready_and_valid(ssc, part); 10274 sd_ssc_fini(ssc); 10275 mutex_enter(SD_MUTEX(un)); 10276 /* 10277 * Fail if device is not ready or if the number of disk 10278 * blocks is zero or negative for non CD devices. 10279 */ 10280 10281 nblks = 0; 10282 10283 if (rval == SD_READY_VALID && (!ISCD(un))) { 10284 /* if cmlb_partinfo fails, nblks remains 0 */ 10285 mutex_exit(SD_MUTEX(un)); 10286 (void) cmlb_partinfo(un->un_cmlbhandle, part, &nblks, 10287 NULL, NULL, NULL, (void *)SD_PATH_DIRECT); 10288 mutex_enter(SD_MUTEX(un)); 10289 } 10290 10291 if ((rval != SD_READY_VALID) || 10292 (!ISCD(un) && nblks <= 0)) { 10293 rval = un->un_f_has_removable_media ? ENXIO : EIO; 10294 SD_ERROR(SD_LOG_OPEN_CLOSE, un, "sdopen: " 10295 "device not ready or invalid disk block value\n"); 10296 goto open_fail; 10297 } 10298 #if defined(__i386) || defined(__amd64) 10299 } else { 10300 uchar_t *cp; 10301 /* 10302 * x86 requires special nodelay handling, so that p0 is 10303 * always defined and accessible. 10304 * Invalidate geometry only if device is not already open. 10305 */ 10306 cp = &un->un_ocmap.chkd[0]; 10307 while (cp < &un->un_ocmap.chkd[OCSIZE]) { 10308 if (*cp != (uchar_t)0) { 10309 break; 10310 } 10311 cp++; 10312 } 10313 if (cp == &un->un_ocmap.chkd[OCSIZE]) { 10314 mutex_exit(SD_MUTEX(un)); 10315 cmlb_invalidate(un->un_cmlbhandle, 10316 (void *)SD_PATH_DIRECT); 10317 mutex_enter(SD_MUTEX(un)); 10318 } 10319 10320 #endif 10321 } 10322 10323 if (otyp == OTYP_LYR) { 10324 un->un_ocmap.lyropen[part]++; 10325 } else { 10326 un->un_ocmap.regopen[otyp] |= partmask; 10327 } 10328 10329 /* Set up open and exclusive open flags */ 10330 if (flag & FEXCL) { 10331 un->un_exclopen |= (partmask); 10332 } 10333 10334 /* 10335 * If the lun is EFI labeled and lun capacity is greater than the 10336 * capacity contained in the label, log a sys-event to notify the 10337 * interested module. 10338 * To avoid an infinite loop of logging sys-event, we only log the 10339 * event when the lun is not opened in NDELAY mode. The event handler 10340 * should open the lun in NDELAY mode. 10341 */ 10342 if (!nodelay) { 10343 mutex_exit(SD_MUTEX(un)); 10344 if (cmlb_efi_label_capacity(un->un_cmlbhandle, &label_cap, 10345 (void*)SD_PATH_DIRECT) == 0) { 10346 mutex_enter(SD_MUTEX(un)); 10347 if (un->un_f_blockcount_is_valid && 10348 un->un_blockcount > label_cap && 10349 un->un_f_expnevent == B_FALSE) { 10350 un->un_f_expnevent = B_TRUE; 10351 mutex_exit(SD_MUTEX(un)); 10352 sd_log_lun_expansion_event(un, 10353 (nodelay ? KM_NOSLEEP : KM_SLEEP)); 10354 mutex_enter(SD_MUTEX(un)); 10355 } 10356 } else { 10357 mutex_enter(SD_MUTEX(un)); 10358 } 10359 } 10360 10361 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdopen: " 10362 "open of part %d type %d\n", part, otyp); 10363 10364 mutex_exit(SD_MUTEX(un)); 10365 if (!nodelay) { 10366 sd_pm_exit(un); 10367 } 10368 10369 sema_v(&un->un_semoclose); 10370 10371 mutex_enter(&sd_detach_mutex); 10372 un->un_opens_in_progress--; 10373 mutex_exit(&sd_detach_mutex); 10374 10375 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdopen: exit success\n"); 10376 return (DDI_SUCCESS); 10377 10378 excl_open_fail: 10379 SD_ERROR(SD_LOG_OPEN_CLOSE, un, "sdopen: fail exclusive open\n"); 10380 rval = EBUSY; 10381 10382 open_fail: 10383 mutex_exit(SD_MUTEX(un)); 10384 10385 /* 10386 * On a failed open we must exit the pm management. 10387 */ 10388 if (!nodelay) { 10389 sd_pm_exit(un); 10390 } 10391 open_failed_with_pm: 10392 sema_v(&un->un_semoclose); 10393 10394 mutex_enter(&sd_detach_mutex); 10395 un->un_opens_in_progress--; 10396 if (otyp == OTYP_LYR) { 10397 un->un_layer_count--; 10398 } 10399 mutex_exit(&sd_detach_mutex); 10400 10401 return (rval); 10402 } 10403 10404 10405 /* 10406 * Function: sdclose 10407 * 10408 * Description: Driver's close(9e) entry point function. 10409 * 10410 * Arguments: dev - device number 10411 * flag - file status flag, informational only 10412 * otyp - close type (OTYP_BLK, OTYP_CHR, OTYP_LYR) 10413 * cred_p - user credential pointer 10414 * 10415 * Return Code: ENXIO 10416 * 10417 * Context: Kernel thread context 10418 */ 10419 /* ARGSUSED */ 10420 static int 10421 sdclose(dev_t dev, int flag, int otyp, cred_t *cred_p) 10422 { 10423 struct sd_lun *un; 10424 uchar_t *cp; 10425 int part; 10426 int nodelay; 10427 int rval = 0; 10428 10429 /* Validate the open type */ 10430 if (otyp >= OTYPCNT) { 10431 return (ENXIO); 10432 } 10433 10434 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) { 10435 return (ENXIO); 10436 } 10437 10438 part = SDPART(dev); 10439 nodelay = flag & (FNDELAY | FNONBLOCK); 10440 10441 SD_TRACE(SD_LOG_OPEN_CLOSE, un, 10442 "sdclose: close of part %d type %d\n", part, otyp); 10443 10444 /* 10445 * We use a semaphore here in order to serialize 10446 * open and close requests on the device. 10447 */ 10448 sema_p(&un->un_semoclose); 10449 10450 mutex_enter(SD_MUTEX(un)); 10451 10452 /* Don't proceed if power is being changed. */ 10453 while (un->un_state == SD_STATE_PM_CHANGING) { 10454 cv_wait(&un->un_suspend_cv, SD_MUTEX(un)); 10455 } 10456 10457 if (un->un_exclopen & (1 << part)) { 10458 un->un_exclopen &= ~(1 << part); 10459 } 10460 10461 /* Update the open partition map */ 10462 if (otyp == OTYP_LYR) { 10463 un->un_ocmap.lyropen[part] -= 1; 10464 } else { 10465 un->un_ocmap.regopen[otyp] &= ~(1 << part); 10466 } 10467 10468 cp = &un->un_ocmap.chkd[0]; 10469 while (cp < &un->un_ocmap.chkd[OCSIZE]) { 10470 if (*cp != NULL) { 10471 break; 10472 } 10473 cp++; 10474 } 10475 10476 if (cp == &un->un_ocmap.chkd[OCSIZE]) { 10477 SD_TRACE(SD_LOG_OPEN_CLOSE, un, "sdclose: last close\n"); 10478 10479 /* 10480 * We avoid persistance upon the last close, and set 10481 * the throttle back to the maximum. 10482 */ 10483 un->un_throttle = un->un_saved_throttle; 10484 10485 if (un->un_state == SD_STATE_OFFLINE) { 10486 if (un->un_f_is_fibre == FALSE) { 10487 scsi_log(SD_DEVINFO(un), sd_label, 10488 CE_WARN, "offline\n"); 10489 } 10490 mutex_exit(SD_MUTEX(un)); 10491 cmlb_invalidate(un->un_cmlbhandle, 10492 (void *)SD_PATH_DIRECT); 10493 mutex_enter(SD_MUTEX(un)); 10494 10495 } else { 10496 /* 10497 * Flush any outstanding writes in NVRAM cache. 10498 * Note: SYNCHRONIZE CACHE is an optional SCSI-2 10499 * cmd, it may not work for non-Pluto devices. 10500 * SYNCHRONIZE CACHE is not required for removables, 10501 * except DVD-RAM drives. 10502 * 10503 * Also note: because SYNCHRONIZE CACHE is currently 10504 * the only command issued here that requires the 10505 * drive be powered up, only do the power up before 10506 * sending the Sync Cache command. If additional 10507 * commands are added which require a powered up 10508 * drive, the following sequence may have to change. 10509 * 10510 * And finally, note that parallel SCSI on SPARC 10511 * only issues a Sync Cache to DVD-RAM, a newly 10512 * supported device. 10513 */ 10514 #if defined(__i386) || defined(__amd64) 10515 if ((un->un_f_sync_cache_supported && 10516 un->un_f_sync_cache_required) || 10517 un->un_f_dvdram_writable_device == TRUE) { 10518 #else 10519 if (un->un_f_dvdram_writable_device == TRUE) { 10520 #endif 10521 mutex_exit(SD_MUTEX(un)); 10522 if (sd_pm_entry(un) == DDI_SUCCESS) { 10523 rval = 10524 sd_send_scsi_SYNCHRONIZE_CACHE(un, 10525 NULL); 10526 /* ignore error if not supported */ 10527 if (rval == ENOTSUP) { 10528 rval = 0; 10529 } else if (rval != 0) { 10530 rval = EIO; 10531 } 10532 sd_pm_exit(un); 10533 } else { 10534 rval = EIO; 10535 } 10536 mutex_enter(SD_MUTEX(un)); 10537 } 10538 10539 /* 10540 * For devices which supports DOOR_LOCK, send an ALLOW 10541 * MEDIA REMOVAL command, but don't get upset if it 10542 * fails. We need to raise the power of the drive before 10543 * we can call sd_send_scsi_DOORLOCK() 10544 */ 10545 if (un->un_f_doorlock_supported) { 10546 mutex_exit(SD_MUTEX(un)); 10547 if (sd_pm_entry(un) == DDI_SUCCESS) { 10548 sd_ssc_t *ssc; 10549 10550 ssc = sd_ssc_init(un); 10551 rval = sd_send_scsi_DOORLOCK(ssc, 10552 SD_REMOVAL_ALLOW, SD_PATH_DIRECT); 10553 if (rval != 0) 10554 sd_ssc_assessment(ssc, 10555 SD_FMT_IGNORE); 10556 sd_ssc_fini(ssc); 10557 10558 sd_pm_exit(un); 10559 if (ISCD(un) && (rval != 0) && 10560 (nodelay != 0)) { 10561 rval = ENXIO; 10562 } 10563 } else { 10564 rval = EIO; 10565 } 10566 mutex_enter(SD_MUTEX(un)); 10567 } 10568 10569 /* 10570 * If a device has removable media, invalidate all 10571 * parameters related to media, such as geometry, 10572 * blocksize, and blockcount. 10573 */ 10574 if (un->un_f_has_removable_media) { 10575 sr_ejected(un); 10576 } 10577 10578 /* 10579 * Destroy the cache (if it exists) which was 10580 * allocated for the write maps since this is 10581 * the last close for this media. 10582 */ 10583 if (un->un_wm_cache) { 10584 /* 10585 * Check if there are pending commands. 10586 * and if there are give a warning and 10587 * do not destroy the cache. 10588 */ 10589 if (un->un_ncmds_in_driver > 0) { 10590 scsi_log(SD_DEVINFO(un), 10591 sd_label, CE_WARN, 10592 "Unable to clean up memory " 10593 "because of pending I/O\n"); 10594 } else { 10595 kmem_cache_destroy( 10596 un->un_wm_cache); 10597 un->un_wm_cache = NULL; 10598 } 10599 } 10600 } 10601 } 10602 10603 mutex_exit(SD_MUTEX(un)); 10604 sema_v(&un->un_semoclose); 10605 10606 if (otyp == OTYP_LYR) { 10607 mutex_enter(&sd_detach_mutex); 10608 /* 10609 * The detach routine may run when the layer count 10610 * drops to zero. 10611 */ 10612 un->un_layer_count--; 10613 mutex_exit(&sd_detach_mutex); 10614 } 10615 10616 return (rval); 10617 } 10618 10619 10620 /* 10621 * Function: sd_ready_and_valid 10622 * 10623 * Description: Test if device is ready and has a valid geometry. 10624 * 10625 * Arguments: ssc - sd_ssc_t will contain un 10626 * un - driver soft state (unit) structure 10627 * 10628 * Return Code: SD_READY_VALID ready and valid label 10629 * SD_NOT_READY_VALID not ready, no label 10630 * SD_RESERVED_BY_OTHERS reservation conflict 10631 * 10632 * Context: Never called at interrupt context. 10633 */ 10634 10635 static int 10636 sd_ready_and_valid(sd_ssc_t *ssc, int part) 10637 { 10638 struct sd_errstats *stp; 10639 uint64_t capacity; 10640 uint_t lbasize; 10641 int rval = SD_READY_VALID; 10642 char name_str[48]; 10643 boolean_t is_valid; 10644 struct sd_lun *un; 10645 int status; 10646 10647 ASSERT(ssc != NULL); 10648 un = ssc->ssc_un; 10649 ASSERT(un != NULL); 10650 ASSERT(!mutex_owned(SD_MUTEX(un))); 10651 10652 mutex_enter(SD_MUTEX(un)); 10653 /* 10654 * If a device has removable media, we must check if media is 10655 * ready when checking if this device is ready and valid. 10656 */ 10657 if (un->un_f_has_removable_media) { 10658 mutex_exit(SD_MUTEX(un)); 10659 status = sd_send_scsi_TEST_UNIT_READY(ssc, 0); 10660 10661 if (status != 0) { 10662 rval = SD_NOT_READY_VALID; 10663 mutex_enter(SD_MUTEX(un)); 10664 10665 /* Ignore all failed status for removalbe media */ 10666 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 10667 10668 goto done; 10669 } 10670 10671 is_valid = SD_IS_VALID_LABEL(un); 10672 mutex_enter(SD_MUTEX(un)); 10673 if (!is_valid || 10674 (un->un_f_blockcount_is_valid == FALSE) || 10675 (un->un_f_tgt_blocksize_is_valid == FALSE)) { 10676 10677 /* capacity has to be read every open. */ 10678 mutex_exit(SD_MUTEX(un)); 10679 status = sd_send_scsi_READ_CAPACITY(ssc, &capacity, 10680 &lbasize, SD_PATH_DIRECT); 10681 10682 if (status != 0) { 10683 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 10684 10685 cmlb_invalidate(un->un_cmlbhandle, 10686 (void *)SD_PATH_DIRECT); 10687 mutex_enter(SD_MUTEX(un)); 10688 rval = SD_NOT_READY_VALID; 10689 10690 goto done; 10691 } else { 10692 mutex_enter(SD_MUTEX(un)); 10693 sd_update_block_info(un, lbasize, capacity); 10694 } 10695 } 10696 10697 /* 10698 * Check if the media in the device is writable or not. 10699 */ 10700 if (!is_valid && ISCD(un)) { 10701 sd_check_for_writable_cd(ssc, SD_PATH_DIRECT); 10702 } 10703 10704 } else { 10705 /* 10706 * Do a test unit ready to clear any unit attention from non-cd 10707 * devices. 10708 */ 10709 mutex_exit(SD_MUTEX(un)); 10710 10711 status = sd_send_scsi_TEST_UNIT_READY(ssc, 0); 10712 if (status != 0) { 10713 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 10714 } 10715 10716 mutex_enter(SD_MUTEX(un)); 10717 } 10718 10719 10720 /* 10721 * If this is a non 512 block device, allocate space for 10722 * the wmap cache. This is being done here since every time 10723 * a media is changed this routine will be called and the 10724 * block size is a function of media rather than device. 10725 */ 10726 if (((un->un_f_rmw_type != SD_RMW_TYPE_RETURN_ERROR || 10727 un->un_f_non_devbsize_supported) && 10728 un->un_tgt_blocksize != DEV_BSIZE) || 10729 un->un_f_enable_rmw) { 10730 if (!(un->un_wm_cache)) { 10731 (void) snprintf(name_str, sizeof (name_str), 10732 "%s%d_cache", 10733 ddi_driver_name(SD_DEVINFO(un)), 10734 ddi_get_instance(SD_DEVINFO(un))); 10735 un->un_wm_cache = kmem_cache_create( 10736 name_str, sizeof (struct sd_w_map), 10737 8, sd_wm_cache_constructor, 10738 sd_wm_cache_destructor, NULL, 10739 (void *)un, NULL, 0); 10740 if (!(un->un_wm_cache)) { 10741 rval = ENOMEM; 10742 goto done; 10743 } 10744 } 10745 } 10746 10747 if (un->un_state == SD_STATE_NORMAL) { 10748 /* 10749 * If the target is not yet ready here (defined by a TUR 10750 * failure), invalidate the geometry and print an 'offline' 10751 * message. This is a legacy message, as the state of the 10752 * target is not actually changed to SD_STATE_OFFLINE. 10753 * 10754 * If the TUR fails for EACCES (Reservation Conflict), 10755 * SD_RESERVED_BY_OTHERS will be returned to indicate 10756 * reservation conflict. If the TUR fails for other 10757 * reasons, SD_NOT_READY_VALID will be returned. 10758 */ 10759 int err; 10760 10761 mutex_exit(SD_MUTEX(un)); 10762 err = sd_send_scsi_TEST_UNIT_READY(ssc, 0); 10763 mutex_enter(SD_MUTEX(un)); 10764 10765 if (err != 0) { 10766 mutex_exit(SD_MUTEX(un)); 10767 cmlb_invalidate(un->un_cmlbhandle, 10768 (void *)SD_PATH_DIRECT); 10769 mutex_enter(SD_MUTEX(un)); 10770 if (err == EACCES) { 10771 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 10772 "reservation conflict\n"); 10773 rval = SD_RESERVED_BY_OTHERS; 10774 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 10775 } else { 10776 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 10777 "drive offline\n"); 10778 rval = SD_NOT_READY_VALID; 10779 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK); 10780 } 10781 goto done; 10782 } 10783 } 10784 10785 if (un->un_f_format_in_progress == FALSE) { 10786 mutex_exit(SD_MUTEX(un)); 10787 10788 (void) cmlb_validate(un->un_cmlbhandle, 0, 10789 (void *)SD_PATH_DIRECT); 10790 if (cmlb_partinfo(un->un_cmlbhandle, part, NULL, NULL, NULL, 10791 NULL, (void *) SD_PATH_DIRECT) != 0) { 10792 rval = SD_NOT_READY_VALID; 10793 mutex_enter(SD_MUTEX(un)); 10794 10795 goto done; 10796 } 10797 if (un->un_f_pkstats_enabled) { 10798 sd_set_pstats(un); 10799 SD_TRACE(SD_LOG_IO_PARTITION, un, 10800 "sd_ready_and_valid: un:0x%p pstats created and " 10801 "set\n", un); 10802 } 10803 mutex_enter(SD_MUTEX(un)); 10804 } 10805 10806 /* 10807 * If this device supports DOOR_LOCK command, try and send 10808 * this command to PREVENT MEDIA REMOVAL, but don't get upset 10809 * if it fails. For a CD, however, it is an error 10810 */ 10811 if (un->un_f_doorlock_supported) { 10812 mutex_exit(SD_MUTEX(un)); 10813 status = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_PREVENT, 10814 SD_PATH_DIRECT); 10815 10816 if ((status != 0) && ISCD(un)) { 10817 rval = SD_NOT_READY_VALID; 10818 mutex_enter(SD_MUTEX(un)); 10819 10820 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 10821 10822 goto done; 10823 } else if (status != 0) 10824 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 10825 mutex_enter(SD_MUTEX(un)); 10826 } 10827 10828 /* The state has changed, inform the media watch routines */ 10829 un->un_mediastate = DKIO_INSERTED; 10830 cv_broadcast(&un->un_state_cv); 10831 rval = SD_READY_VALID; 10832 10833 done: 10834 10835 /* 10836 * Initialize the capacity kstat value, if no media previously 10837 * (capacity kstat is 0) and a media has been inserted 10838 * (un_blockcount > 0). 10839 */ 10840 if (un->un_errstats != NULL) { 10841 stp = (struct sd_errstats *)un->un_errstats->ks_data; 10842 if ((stp->sd_capacity.value.ui64 == 0) && 10843 (un->un_f_blockcount_is_valid == TRUE)) { 10844 stp->sd_capacity.value.ui64 = 10845 (uint64_t)((uint64_t)un->un_blockcount * 10846 un->un_sys_blocksize); 10847 } 10848 } 10849 10850 mutex_exit(SD_MUTEX(un)); 10851 return (rval); 10852 } 10853 10854 10855 /* 10856 * Function: sdmin 10857 * 10858 * Description: Routine to limit the size of a data transfer. Used in 10859 * conjunction with physio(9F). 10860 * 10861 * Arguments: bp - pointer to the indicated buf(9S) struct. 10862 * 10863 * Context: Kernel thread context. 10864 */ 10865 10866 static void 10867 sdmin(struct buf *bp) 10868 { 10869 struct sd_lun *un; 10870 int instance; 10871 10872 instance = SDUNIT(bp->b_edev); 10873 10874 un = ddi_get_soft_state(sd_state, instance); 10875 ASSERT(un != NULL); 10876 10877 /* 10878 * We depend on buf breakup to restrict 10879 * IO size if it is enabled. 10880 */ 10881 if (un->un_buf_breakup_supported) { 10882 return; 10883 } 10884 10885 if (bp->b_bcount > un->un_max_xfer_size) { 10886 bp->b_bcount = un->un_max_xfer_size; 10887 } 10888 } 10889 10890 10891 /* 10892 * Function: sdread 10893 * 10894 * Description: Driver's read(9e) entry point function. 10895 * 10896 * Arguments: dev - device number 10897 * uio - structure pointer describing where data is to be stored 10898 * in user's space 10899 * cred_p - user credential pointer 10900 * 10901 * Return Code: ENXIO 10902 * EIO 10903 * EINVAL 10904 * value returned by physio 10905 * 10906 * Context: Kernel thread context. 10907 */ 10908 /* ARGSUSED */ 10909 static int 10910 sdread(dev_t dev, struct uio *uio, cred_t *cred_p) 10911 { 10912 struct sd_lun *un = NULL; 10913 int secmask; 10914 int err = 0; 10915 sd_ssc_t *ssc; 10916 10917 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) { 10918 return (ENXIO); 10919 } 10920 10921 ASSERT(!mutex_owned(SD_MUTEX(un))); 10922 10923 10924 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) { 10925 mutex_enter(SD_MUTEX(un)); 10926 /* 10927 * Because the call to sd_ready_and_valid will issue I/O we 10928 * must wait here if either the device is suspended or 10929 * if it's power level is changing. 10930 */ 10931 while ((un->un_state == SD_STATE_SUSPENDED) || 10932 (un->un_state == SD_STATE_PM_CHANGING)) { 10933 cv_wait(&un->un_suspend_cv, SD_MUTEX(un)); 10934 } 10935 un->un_ncmds_in_driver++; 10936 mutex_exit(SD_MUTEX(un)); 10937 10938 /* Initialize sd_ssc_t for internal uscsi commands */ 10939 ssc = sd_ssc_init(un); 10940 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) { 10941 err = EIO; 10942 } else { 10943 err = 0; 10944 } 10945 sd_ssc_fini(ssc); 10946 10947 mutex_enter(SD_MUTEX(un)); 10948 un->un_ncmds_in_driver--; 10949 ASSERT(un->un_ncmds_in_driver >= 0); 10950 mutex_exit(SD_MUTEX(un)); 10951 if (err != 0) 10952 return (err); 10953 } 10954 10955 /* 10956 * Read requests are restricted to multiples of the system block size. 10957 */ 10958 if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR && 10959 !un->un_f_enable_rmw) 10960 secmask = un->un_tgt_blocksize - 1; 10961 else 10962 secmask = DEV_BSIZE - 1; 10963 10964 if (uio->uio_loffset & ((offset_t)(secmask))) { 10965 SD_ERROR(SD_LOG_READ_WRITE, un, 10966 "sdread: file offset not modulo %d\n", 10967 secmask + 1); 10968 err = EINVAL; 10969 } else if (uio->uio_iov->iov_len & (secmask)) { 10970 SD_ERROR(SD_LOG_READ_WRITE, un, 10971 "sdread: transfer length not modulo %d\n", 10972 secmask + 1); 10973 err = EINVAL; 10974 } else { 10975 err = physio(sdstrategy, NULL, dev, B_READ, sdmin, uio); 10976 } 10977 10978 return (err); 10979 } 10980 10981 10982 /* 10983 * Function: sdwrite 10984 * 10985 * Description: Driver's write(9e) entry point function. 10986 * 10987 * Arguments: dev - device number 10988 * uio - structure pointer describing where data is stored in 10989 * user's space 10990 * cred_p - user credential pointer 10991 * 10992 * Return Code: ENXIO 10993 * EIO 10994 * EINVAL 10995 * value returned by physio 10996 * 10997 * Context: Kernel thread context. 10998 */ 10999 /* ARGSUSED */ 11000 static int 11001 sdwrite(dev_t dev, struct uio *uio, cred_t *cred_p) 11002 { 11003 struct sd_lun *un = NULL; 11004 int secmask; 11005 int err = 0; 11006 sd_ssc_t *ssc; 11007 11008 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) { 11009 return (ENXIO); 11010 } 11011 11012 ASSERT(!mutex_owned(SD_MUTEX(un))); 11013 11014 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) { 11015 mutex_enter(SD_MUTEX(un)); 11016 /* 11017 * Because the call to sd_ready_and_valid will issue I/O we 11018 * must wait here if either the device is suspended or 11019 * if it's power level is changing. 11020 */ 11021 while ((un->un_state == SD_STATE_SUSPENDED) || 11022 (un->un_state == SD_STATE_PM_CHANGING)) { 11023 cv_wait(&un->un_suspend_cv, SD_MUTEX(un)); 11024 } 11025 un->un_ncmds_in_driver++; 11026 mutex_exit(SD_MUTEX(un)); 11027 11028 /* Initialize sd_ssc_t for internal uscsi commands */ 11029 ssc = sd_ssc_init(un); 11030 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) { 11031 err = EIO; 11032 } else { 11033 err = 0; 11034 } 11035 sd_ssc_fini(ssc); 11036 11037 mutex_enter(SD_MUTEX(un)); 11038 un->un_ncmds_in_driver--; 11039 ASSERT(un->un_ncmds_in_driver >= 0); 11040 mutex_exit(SD_MUTEX(un)); 11041 if (err != 0) 11042 return (err); 11043 } 11044 11045 /* 11046 * Write requests are restricted to multiples of the system block size. 11047 */ 11048 if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR && 11049 !un->un_f_enable_rmw) 11050 secmask = un->un_tgt_blocksize - 1; 11051 else 11052 secmask = DEV_BSIZE - 1; 11053 11054 if (uio->uio_loffset & ((offset_t)(secmask))) { 11055 SD_ERROR(SD_LOG_READ_WRITE, un, 11056 "sdwrite: file offset not modulo %d\n", 11057 secmask + 1); 11058 err = EINVAL; 11059 } else if (uio->uio_iov->iov_len & (secmask)) { 11060 SD_ERROR(SD_LOG_READ_WRITE, un, 11061 "sdwrite: transfer length not modulo %d\n", 11062 secmask + 1); 11063 err = EINVAL; 11064 } else { 11065 err = physio(sdstrategy, NULL, dev, B_WRITE, sdmin, uio); 11066 } 11067 11068 return (err); 11069 } 11070 11071 11072 /* 11073 * Function: sdaread 11074 * 11075 * Description: Driver's aread(9e) entry point function. 11076 * 11077 * Arguments: dev - device number 11078 * aio - structure pointer describing where data is to be stored 11079 * cred_p - user credential pointer 11080 * 11081 * Return Code: ENXIO 11082 * EIO 11083 * EINVAL 11084 * value returned by aphysio 11085 * 11086 * Context: Kernel thread context. 11087 */ 11088 /* ARGSUSED */ 11089 static int 11090 sdaread(dev_t dev, struct aio_req *aio, cred_t *cred_p) 11091 { 11092 struct sd_lun *un = NULL; 11093 struct uio *uio = aio->aio_uio; 11094 int secmask; 11095 int err = 0; 11096 sd_ssc_t *ssc; 11097 11098 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) { 11099 return (ENXIO); 11100 } 11101 11102 ASSERT(!mutex_owned(SD_MUTEX(un))); 11103 11104 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) { 11105 mutex_enter(SD_MUTEX(un)); 11106 /* 11107 * Because the call to sd_ready_and_valid will issue I/O we 11108 * must wait here if either the device is suspended or 11109 * if it's power level is changing. 11110 */ 11111 while ((un->un_state == SD_STATE_SUSPENDED) || 11112 (un->un_state == SD_STATE_PM_CHANGING)) { 11113 cv_wait(&un->un_suspend_cv, SD_MUTEX(un)); 11114 } 11115 un->un_ncmds_in_driver++; 11116 mutex_exit(SD_MUTEX(un)); 11117 11118 /* Initialize sd_ssc_t for internal uscsi commands */ 11119 ssc = sd_ssc_init(un); 11120 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) { 11121 err = EIO; 11122 } else { 11123 err = 0; 11124 } 11125 sd_ssc_fini(ssc); 11126 11127 mutex_enter(SD_MUTEX(un)); 11128 un->un_ncmds_in_driver--; 11129 ASSERT(un->un_ncmds_in_driver >= 0); 11130 mutex_exit(SD_MUTEX(un)); 11131 if (err != 0) 11132 return (err); 11133 } 11134 11135 /* 11136 * Read requests are restricted to multiples of the system block size. 11137 */ 11138 if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR && 11139 !un->un_f_enable_rmw) 11140 secmask = un->un_tgt_blocksize - 1; 11141 else 11142 secmask = DEV_BSIZE - 1; 11143 11144 if (uio->uio_loffset & ((offset_t)(secmask))) { 11145 SD_ERROR(SD_LOG_READ_WRITE, un, 11146 "sdaread: file offset not modulo %d\n", 11147 secmask + 1); 11148 err = EINVAL; 11149 } else if (uio->uio_iov->iov_len & (secmask)) { 11150 SD_ERROR(SD_LOG_READ_WRITE, un, 11151 "sdaread: transfer length not modulo %d\n", 11152 secmask + 1); 11153 err = EINVAL; 11154 } else { 11155 err = aphysio(sdstrategy, anocancel, dev, B_READ, sdmin, aio); 11156 } 11157 11158 return (err); 11159 } 11160 11161 11162 /* 11163 * Function: sdawrite 11164 * 11165 * Description: Driver's awrite(9e) entry point function. 11166 * 11167 * Arguments: dev - device number 11168 * aio - structure pointer describing where data is stored 11169 * cred_p - user credential pointer 11170 * 11171 * Return Code: ENXIO 11172 * EIO 11173 * EINVAL 11174 * value returned by aphysio 11175 * 11176 * Context: Kernel thread context. 11177 */ 11178 /* ARGSUSED */ 11179 static int 11180 sdawrite(dev_t dev, struct aio_req *aio, cred_t *cred_p) 11181 { 11182 struct sd_lun *un = NULL; 11183 struct uio *uio = aio->aio_uio; 11184 int secmask; 11185 int err = 0; 11186 sd_ssc_t *ssc; 11187 11188 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) { 11189 return (ENXIO); 11190 } 11191 11192 ASSERT(!mutex_owned(SD_MUTEX(un))); 11193 11194 if (!SD_IS_VALID_LABEL(un) && !ISCD(un)) { 11195 mutex_enter(SD_MUTEX(un)); 11196 /* 11197 * Because the call to sd_ready_and_valid will issue I/O we 11198 * must wait here if either the device is suspended or 11199 * if it's power level is changing. 11200 */ 11201 while ((un->un_state == SD_STATE_SUSPENDED) || 11202 (un->un_state == SD_STATE_PM_CHANGING)) { 11203 cv_wait(&un->un_suspend_cv, SD_MUTEX(un)); 11204 } 11205 un->un_ncmds_in_driver++; 11206 mutex_exit(SD_MUTEX(un)); 11207 11208 /* Initialize sd_ssc_t for internal uscsi commands */ 11209 ssc = sd_ssc_init(un); 11210 if ((sd_ready_and_valid(ssc, SDPART(dev))) != SD_READY_VALID) { 11211 err = EIO; 11212 } else { 11213 err = 0; 11214 } 11215 sd_ssc_fini(ssc); 11216 11217 mutex_enter(SD_MUTEX(un)); 11218 un->un_ncmds_in_driver--; 11219 ASSERT(un->un_ncmds_in_driver >= 0); 11220 mutex_exit(SD_MUTEX(un)); 11221 if (err != 0) 11222 return (err); 11223 } 11224 11225 /* 11226 * Write requests are restricted to multiples of the system block size. 11227 */ 11228 if (un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR && 11229 !un->un_f_enable_rmw) 11230 secmask = un->un_tgt_blocksize - 1; 11231 else 11232 secmask = DEV_BSIZE - 1; 11233 11234 if (uio->uio_loffset & ((offset_t)(secmask))) { 11235 SD_ERROR(SD_LOG_READ_WRITE, un, 11236 "sdawrite: file offset not modulo %d\n", 11237 secmask + 1); 11238 err = EINVAL; 11239 } else if (uio->uio_iov->iov_len & (secmask)) { 11240 SD_ERROR(SD_LOG_READ_WRITE, un, 11241 "sdawrite: transfer length not modulo %d\n", 11242 secmask + 1); 11243 err = EINVAL; 11244 } else { 11245 err = aphysio(sdstrategy, anocancel, dev, B_WRITE, sdmin, aio); 11246 } 11247 11248 return (err); 11249 } 11250 11251 11252 11253 11254 11255 /* 11256 * Driver IO processing follows the following sequence: 11257 * 11258 * sdioctl(9E) sdstrategy(9E) biodone(9F) 11259 * | | ^ 11260 * v v | 11261 * sd_send_scsi_cmd() ddi_xbuf_qstrategy() +-------------------+ 11262 * | | | | 11263 * v | | | 11264 * sd_uscsi_strategy() sd_xbuf_strategy() sd_buf_iodone() sd_uscsi_iodone() 11265 * | | ^ ^ 11266 * v v | | 11267 * SD_BEGIN_IOSTART() SD_BEGIN_IOSTART() | | 11268 * | | | | 11269 * +---+ | +------------+ +-------+ 11270 * | | | | 11271 * | SD_NEXT_IOSTART()| SD_NEXT_IODONE()| | 11272 * | v | | 11273 * | sd_mapblockaddr_iostart() sd_mapblockaddr_iodone() | 11274 * | | ^ | 11275 * | SD_NEXT_IOSTART()| SD_NEXT_IODONE()| | 11276 * | v | | 11277 * | sd_mapblocksize_iostart() sd_mapblocksize_iodone() | 11278 * | | ^ | 11279 * | SD_NEXT_IOSTART()| SD_NEXT_IODONE()| | 11280 * | v | | 11281 * | sd_checksum_iostart() sd_checksum_iodone() | 11282 * | | ^ | 11283 * +-> SD_NEXT_IOSTART()| SD_NEXT_IODONE()+------------->+ 11284 * | v | | 11285 * | sd_pm_iostart() sd_pm_iodone() | 11286 * | | ^ | 11287 * | | | | 11288 * +-> SD_NEXT_IOSTART()| SD_BEGIN_IODONE()--+--------------+ 11289 * | ^ 11290 * v | 11291 * sd_core_iostart() | 11292 * | | 11293 * | +------>(*destroypkt)() 11294 * +-> sd_start_cmds() <-+ | | 11295 * | | | v 11296 * | | | scsi_destroy_pkt(9F) 11297 * | | | 11298 * +->(*initpkt)() +- sdintr() 11299 * | | | | 11300 * | +-> scsi_init_pkt(9F) | +-> sd_handle_xxx() 11301 * | +-> scsi_setup_cdb(9F) | 11302 * | | 11303 * +--> scsi_transport(9F) | 11304 * | | 11305 * +----> SCSA ---->+ 11306 * 11307 * 11308 * This code is based upon the following presumptions: 11309 * 11310 * - iostart and iodone functions operate on buf(9S) structures. These 11311 * functions perform the necessary operations on the buf(9S) and pass 11312 * them along to the next function in the chain by using the macros 11313 * SD_NEXT_IOSTART() (for iostart side functions) and SD_NEXT_IODONE() 11314 * (for iodone side functions). 11315 * 11316 * - The iostart side functions may sleep. The iodone side functions 11317 * are called under interrupt context and may NOT sleep. Therefore 11318 * iodone side functions also may not call iostart side functions. 11319 * (NOTE: iostart side functions should NOT sleep for memory, as 11320 * this could result in deadlock.) 11321 * 11322 * - An iostart side function may call its corresponding iodone side 11323 * function directly (if necessary). 11324 * 11325 * - In the event of an error, an iostart side function can return a buf(9S) 11326 * to its caller by calling SD_BEGIN_IODONE() (after setting B_ERROR and 11327 * b_error in the usual way of course). 11328 * 11329 * - The taskq mechanism may be used by the iodone side functions to dispatch 11330 * requests to the iostart side functions. The iostart side functions in 11331 * this case would be called under the context of a taskq thread, so it's 11332 * OK for them to block/sleep/spin in this case. 11333 * 11334 * - iostart side functions may allocate "shadow" buf(9S) structs and 11335 * pass them along to the next function in the chain. The corresponding 11336 * iodone side functions must coalesce the "shadow" bufs and return 11337 * the "original" buf to the next higher layer. 11338 * 11339 * - The b_private field of the buf(9S) struct holds a pointer to 11340 * an sd_xbuf struct, which contains information needed to 11341 * construct the scsi_pkt for the command. 11342 * 11343 * - The SD_MUTEX(un) is NOT held across calls to the next layer. Each 11344 * layer must acquire & release the SD_MUTEX(un) as needed. 11345 */ 11346 11347 11348 /* 11349 * Create taskq for all targets in the system. This is created at 11350 * _init(9E) and destroyed at _fini(9E). 11351 * 11352 * Note: here we set the minalloc to a reasonably high number to ensure that 11353 * we will have an adequate supply of task entries available at interrupt time. 11354 * This is used in conjunction with the TASKQ_PREPOPULATE flag in 11355 * sd_create_taskq(). Since we do not want to sleep for allocations at 11356 * interrupt time, set maxalloc equal to minalloc. That way we will just fail 11357 * the command if we ever try to dispatch more than SD_TASKQ_MAXALLOC taskq 11358 * requests any one instant in time. 11359 */ 11360 #define SD_TASKQ_NUMTHREADS 8 11361 #define SD_TASKQ_MINALLOC 256 11362 #define SD_TASKQ_MAXALLOC 256 11363 11364 static taskq_t *sd_tq = NULL; 11365 _NOTE(SCHEME_PROTECTS_DATA("stable data", sd_tq)) 11366 11367 static int sd_taskq_minalloc = SD_TASKQ_MINALLOC; 11368 static int sd_taskq_maxalloc = SD_TASKQ_MAXALLOC; 11369 11370 /* 11371 * The following task queue is being created for the write part of 11372 * read-modify-write of non-512 block size devices. 11373 * Limit the number of threads to 1 for now. This number has been chosen 11374 * considering the fact that it applies only to dvd ram drives/MO drives 11375 * currently. Performance for which is not main criteria at this stage. 11376 * Note: It needs to be explored if we can use a single taskq in future 11377 */ 11378 #define SD_WMR_TASKQ_NUMTHREADS 1 11379 static taskq_t *sd_wmr_tq = NULL; 11380 _NOTE(SCHEME_PROTECTS_DATA("stable data", sd_wmr_tq)) 11381 11382 /* 11383 * Function: sd_taskq_create 11384 * 11385 * Description: Create taskq thread(s) and preallocate task entries 11386 * 11387 * Return Code: Returns a pointer to the allocated taskq_t. 11388 * 11389 * Context: Can sleep. Requires blockable context. 11390 * 11391 * Notes: - The taskq() facility currently is NOT part of the DDI. 11392 * (definitely NOT recommeded for 3rd-party drivers!) :-) 11393 * - taskq_create() will block for memory, also it will panic 11394 * if it cannot create the requested number of threads. 11395 * - Currently taskq_create() creates threads that cannot be 11396 * swapped. 11397 * - We use TASKQ_PREPOPULATE to ensure we have an adequate 11398 * supply of taskq entries at interrupt time (ie, so that we 11399 * do not have to sleep for memory) 11400 */ 11401 11402 static void 11403 sd_taskq_create(void) 11404 { 11405 char taskq_name[TASKQ_NAMELEN]; 11406 11407 ASSERT(sd_tq == NULL); 11408 ASSERT(sd_wmr_tq == NULL); 11409 11410 (void) snprintf(taskq_name, sizeof (taskq_name), 11411 "%s_drv_taskq", sd_label); 11412 sd_tq = (taskq_create(taskq_name, SD_TASKQ_NUMTHREADS, 11413 (v.v_maxsyspri - 2), sd_taskq_minalloc, sd_taskq_maxalloc, 11414 TASKQ_PREPOPULATE)); 11415 11416 (void) snprintf(taskq_name, sizeof (taskq_name), 11417 "%s_rmw_taskq", sd_label); 11418 sd_wmr_tq = (taskq_create(taskq_name, SD_WMR_TASKQ_NUMTHREADS, 11419 (v.v_maxsyspri - 2), sd_taskq_minalloc, sd_taskq_maxalloc, 11420 TASKQ_PREPOPULATE)); 11421 } 11422 11423 11424 /* 11425 * Function: sd_taskq_delete 11426 * 11427 * Description: Complementary cleanup routine for sd_taskq_create(). 11428 * 11429 * Context: Kernel thread context. 11430 */ 11431 11432 static void 11433 sd_taskq_delete(void) 11434 { 11435 ASSERT(sd_tq != NULL); 11436 ASSERT(sd_wmr_tq != NULL); 11437 taskq_destroy(sd_tq); 11438 taskq_destroy(sd_wmr_tq); 11439 sd_tq = NULL; 11440 sd_wmr_tq = NULL; 11441 } 11442 11443 11444 /* 11445 * Function: sdstrategy 11446 * 11447 * Description: Driver's strategy (9E) entry point function. 11448 * 11449 * Arguments: bp - pointer to buf(9S) 11450 * 11451 * Return Code: Always returns zero 11452 * 11453 * Context: Kernel thread context. 11454 */ 11455 11456 static int 11457 sdstrategy(struct buf *bp) 11458 { 11459 struct sd_lun *un; 11460 11461 un = ddi_get_soft_state(sd_state, SD_GET_INSTANCE_FROM_BUF(bp)); 11462 if (un == NULL) { 11463 bioerror(bp, EIO); 11464 bp->b_resid = bp->b_bcount; 11465 biodone(bp); 11466 return (0); 11467 } 11468 11469 /* As was done in the past, fail new cmds. if state is dumping. */ 11470 if (un->un_state == SD_STATE_DUMPING) { 11471 bioerror(bp, ENXIO); 11472 bp->b_resid = bp->b_bcount; 11473 biodone(bp); 11474 return (0); 11475 } 11476 11477 ASSERT(!mutex_owned(SD_MUTEX(un))); 11478 11479 /* 11480 * Commands may sneak in while we released the mutex in 11481 * DDI_SUSPEND, we should block new commands. However, old 11482 * commands that are still in the driver at this point should 11483 * still be allowed to drain. 11484 */ 11485 mutex_enter(SD_MUTEX(un)); 11486 /* 11487 * Must wait here if either the device is suspended or 11488 * if it's power level is changing. 11489 */ 11490 while ((un->un_state == SD_STATE_SUSPENDED) || 11491 (un->un_state == SD_STATE_PM_CHANGING)) { 11492 cv_wait(&un->un_suspend_cv, SD_MUTEX(un)); 11493 } 11494 11495 un->un_ncmds_in_driver++; 11496 11497 /* 11498 * atapi: Since we are running the CD for now in PIO mode we need to 11499 * call bp_mapin here to avoid bp_mapin called interrupt context under 11500 * the HBA's init_pkt routine. 11501 */ 11502 if (un->un_f_cfg_is_atapi == TRUE) { 11503 mutex_exit(SD_MUTEX(un)); 11504 bp_mapin(bp); 11505 mutex_enter(SD_MUTEX(un)); 11506 } 11507 SD_INFO(SD_LOG_IO, un, "sdstrategy: un_ncmds_in_driver = %ld\n", 11508 un->un_ncmds_in_driver); 11509 11510 if (bp->b_flags & B_WRITE) 11511 un->un_f_sync_cache_required = TRUE; 11512 11513 mutex_exit(SD_MUTEX(un)); 11514 11515 /* 11516 * This will (eventually) allocate the sd_xbuf area and 11517 * call sd_xbuf_strategy(). We just want to return the 11518 * result of ddi_xbuf_qstrategy so that we have an opt- 11519 * imized tail call which saves us a stack frame. 11520 */ 11521 return (ddi_xbuf_qstrategy(bp, un->un_xbuf_attr)); 11522 } 11523 11524 11525 /* 11526 * Function: sd_xbuf_strategy 11527 * 11528 * Description: Function for initiating IO operations via the 11529 * ddi_xbuf_qstrategy() mechanism. 11530 * 11531 * Context: Kernel thread context. 11532 */ 11533 11534 static void 11535 sd_xbuf_strategy(struct buf *bp, ddi_xbuf_t xp, void *arg) 11536 { 11537 struct sd_lun *un = arg; 11538 11539 ASSERT(bp != NULL); 11540 ASSERT(xp != NULL); 11541 ASSERT(un != NULL); 11542 ASSERT(!mutex_owned(SD_MUTEX(un))); 11543 11544 /* 11545 * Initialize the fields in the xbuf and save a pointer to the 11546 * xbuf in bp->b_private. 11547 */ 11548 sd_xbuf_init(un, bp, xp, SD_CHAIN_BUFIO, NULL); 11549 11550 /* Send the buf down the iostart chain */ 11551 SD_BEGIN_IOSTART(((struct sd_xbuf *)xp)->xb_chain_iostart, un, bp); 11552 } 11553 11554 11555 /* 11556 * Function: sd_xbuf_init 11557 * 11558 * Description: Prepare the given sd_xbuf struct for use. 11559 * 11560 * Arguments: un - ptr to softstate 11561 * bp - ptr to associated buf(9S) 11562 * xp - ptr to associated sd_xbuf 11563 * chain_type - IO chain type to use: 11564 * SD_CHAIN_NULL 11565 * SD_CHAIN_BUFIO 11566 * SD_CHAIN_USCSI 11567 * SD_CHAIN_DIRECT 11568 * SD_CHAIN_DIRECT_PRIORITY 11569 * pktinfop - ptr to private data struct for scsi_pkt(9S) 11570 * initialization; may be NULL if none. 11571 * 11572 * Context: Kernel thread context 11573 */ 11574 11575 static void 11576 sd_xbuf_init(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp, 11577 uchar_t chain_type, void *pktinfop) 11578 { 11579 int index; 11580 11581 ASSERT(un != NULL); 11582 ASSERT(bp != NULL); 11583 ASSERT(xp != NULL); 11584 11585 SD_INFO(SD_LOG_IO, un, "sd_xbuf_init: buf:0x%p chain type:0x%x\n", 11586 bp, chain_type); 11587 11588 xp->xb_un = un; 11589 xp->xb_pktp = NULL; 11590 xp->xb_pktinfo = pktinfop; 11591 xp->xb_private = bp->b_private; 11592 xp->xb_blkno = (daddr_t)bp->b_blkno; 11593 11594 /* 11595 * Set up the iostart and iodone chain indexes in the xbuf, based 11596 * upon the specified chain type to use. 11597 */ 11598 switch (chain_type) { 11599 case SD_CHAIN_NULL: 11600 /* 11601 * Fall thru to just use the values for the buf type, even 11602 * tho for the NULL chain these values will never be used. 11603 */ 11604 /* FALLTHRU */ 11605 case SD_CHAIN_BUFIO: 11606 index = un->un_buf_chain_type; 11607 if ((!un->un_f_has_removable_media) && 11608 (un->un_tgt_blocksize != 0) && 11609 (un->un_tgt_blocksize != DEV_BSIZE || 11610 un->un_f_enable_rmw)) { 11611 int secmask = 0, blknomask = 0; 11612 if (un->un_f_enable_rmw) { 11613 blknomask = 11614 (un->un_phy_blocksize / DEV_BSIZE) - 1; 11615 secmask = un->un_phy_blocksize - 1; 11616 } else { 11617 blknomask = 11618 (un->un_tgt_blocksize / DEV_BSIZE) - 1; 11619 secmask = un->un_tgt_blocksize - 1; 11620 } 11621 11622 if ((bp->b_lblkno & (blknomask)) || 11623 (bp->b_bcount & (secmask))) { 11624 if ((un->un_f_rmw_type != 11625 SD_RMW_TYPE_RETURN_ERROR) || 11626 un->un_f_enable_rmw) { 11627 if (un->un_f_pm_is_enabled == FALSE) 11628 index = 11629 SD_CHAIN_INFO_MSS_DSK_NO_PM; 11630 else 11631 index = 11632 SD_CHAIN_INFO_MSS_DISK; 11633 } 11634 } 11635 } 11636 break; 11637 case SD_CHAIN_USCSI: 11638 index = un->un_uscsi_chain_type; 11639 break; 11640 case SD_CHAIN_DIRECT: 11641 index = un->un_direct_chain_type; 11642 break; 11643 case SD_CHAIN_DIRECT_PRIORITY: 11644 index = un->un_priority_chain_type; 11645 break; 11646 default: 11647 /* We're really broken if we ever get here... */ 11648 panic("sd_xbuf_init: illegal chain type!"); 11649 /*NOTREACHED*/ 11650 } 11651 11652 xp->xb_chain_iostart = sd_chain_index_map[index].sci_iostart_index; 11653 xp->xb_chain_iodone = sd_chain_index_map[index].sci_iodone_index; 11654 11655 /* 11656 * It might be a bit easier to simply bzero the entire xbuf above, 11657 * but it turns out that since we init a fair number of members anyway, 11658 * we save a fair number cycles by doing explicit assignment of zero. 11659 */ 11660 xp->xb_pkt_flags = 0; 11661 xp->xb_dma_resid = 0; 11662 xp->xb_retry_count = 0; 11663 xp->xb_victim_retry_count = 0; 11664 xp->xb_ua_retry_count = 0; 11665 xp->xb_nr_retry_count = 0; 11666 xp->xb_sense_bp = NULL; 11667 xp->xb_sense_status = 0; 11668 xp->xb_sense_state = 0; 11669 xp->xb_sense_resid = 0; 11670 xp->xb_ena = 0; 11671 11672 bp->b_private = xp; 11673 bp->b_flags &= ~(B_DONE | B_ERROR); 11674 bp->b_resid = 0; 11675 bp->av_forw = NULL; 11676 bp->av_back = NULL; 11677 bioerror(bp, 0); 11678 11679 SD_INFO(SD_LOG_IO, un, "sd_xbuf_init: done.\n"); 11680 } 11681 11682 11683 /* 11684 * Function: sd_uscsi_strategy 11685 * 11686 * Description: Wrapper for calling into the USCSI chain via physio(9F) 11687 * 11688 * Arguments: bp - buf struct ptr 11689 * 11690 * Return Code: Always returns 0 11691 * 11692 * Context: Kernel thread context 11693 */ 11694 11695 static int 11696 sd_uscsi_strategy(struct buf *bp) 11697 { 11698 struct sd_lun *un; 11699 struct sd_uscsi_info *uip; 11700 struct sd_xbuf *xp; 11701 uchar_t chain_type; 11702 uchar_t cmd; 11703 11704 ASSERT(bp != NULL); 11705 11706 un = ddi_get_soft_state(sd_state, SD_GET_INSTANCE_FROM_BUF(bp)); 11707 if (un == NULL) { 11708 bioerror(bp, EIO); 11709 bp->b_resid = bp->b_bcount; 11710 biodone(bp); 11711 return (0); 11712 } 11713 11714 ASSERT(!mutex_owned(SD_MUTEX(un))); 11715 11716 SD_TRACE(SD_LOG_IO, un, "sd_uscsi_strategy: entry: buf:0x%p\n", bp); 11717 11718 /* 11719 * A pointer to a struct sd_uscsi_info is expected in bp->b_private 11720 */ 11721 ASSERT(bp->b_private != NULL); 11722 uip = (struct sd_uscsi_info *)bp->b_private; 11723 cmd = ((struct uscsi_cmd *)(uip->ui_cmdp))->uscsi_cdb[0]; 11724 11725 mutex_enter(SD_MUTEX(un)); 11726 /* 11727 * atapi: Since we are running the CD for now in PIO mode we need to 11728 * call bp_mapin here to avoid bp_mapin called interrupt context under 11729 * the HBA's init_pkt routine. 11730 */ 11731 if (un->un_f_cfg_is_atapi == TRUE) { 11732 mutex_exit(SD_MUTEX(un)); 11733 bp_mapin(bp); 11734 mutex_enter(SD_MUTEX(un)); 11735 } 11736 un->un_ncmds_in_driver++; 11737 SD_INFO(SD_LOG_IO, un, "sd_uscsi_strategy: un_ncmds_in_driver = %ld\n", 11738 un->un_ncmds_in_driver); 11739 11740 if ((bp->b_flags & B_WRITE) && (bp->b_bcount != 0) && 11741 (cmd != SCMD_MODE_SELECT) && (cmd != SCMD_MODE_SELECT_G1)) 11742 un->un_f_sync_cache_required = TRUE; 11743 11744 mutex_exit(SD_MUTEX(un)); 11745 11746 switch (uip->ui_flags) { 11747 case SD_PATH_DIRECT: 11748 chain_type = SD_CHAIN_DIRECT; 11749 break; 11750 case SD_PATH_DIRECT_PRIORITY: 11751 chain_type = SD_CHAIN_DIRECT_PRIORITY; 11752 break; 11753 default: 11754 chain_type = SD_CHAIN_USCSI; 11755 break; 11756 } 11757 11758 /* 11759 * We may allocate extra buf for external USCSI commands. If the 11760 * application asks for bigger than 20-byte sense data via USCSI, 11761 * SCSA layer will allocate 252 bytes sense buf for that command. 11762 */ 11763 if (((struct uscsi_cmd *)(uip->ui_cmdp))->uscsi_rqlen > 11764 SENSE_LENGTH) { 11765 xp = kmem_zalloc(sizeof (struct sd_xbuf) - SENSE_LENGTH + 11766 MAX_SENSE_LENGTH, KM_SLEEP); 11767 } else { 11768 xp = kmem_zalloc(sizeof (struct sd_xbuf), KM_SLEEP); 11769 } 11770 11771 sd_xbuf_init(un, bp, xp, chain_type, uip->ui_cmdp); 11772 11773 /* Use the index obtained within xbuf_init */ 11774 SD_BEGIN_IOSTART(xp->xb_chain_iostart, un, bp); 11775 11776 SD_TRACE(SD_LOG_IO, un, "sd_uscsi_strategy: exit: buf:0x%p\n", bp); 11777 11778 return (0); 11779 } 11780 11781 /* 11782 * Function: sd_send_scsi_cmd 11783 * 11784 * Description: Runs a USCSI command for user (when called thru sdioctl), 11785 * or for the driver 11786 * 11787 * Arguments: dev - the dev_t for the device 11788 * incmd - ptr to a valid uscsi_cmd struct 11789 * flag - bit flag, indicating open settings, 32/64 bit type 11790 * dataspace - UIO_USERSPACE or UIO_SYSSPACE 11791 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and 11792 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY 11793 * to use the USCSI "direct" chain and bypass the normal 11794 * command waitq. 11795 * 11796 * Return Code: 0 - successful completion of the given command 11797 * EIO - scsi_uscsi_handle_command() failed 11798 * ENXIO - soft state not found for specified dev 11799 * EINVAL 11800 * EFAULT - copyin/copyout error 11801 * return code of scsi_uscsi_handle_command(): 11802 * EIO 11803 * ENXIO 11804 * EACCES 11805 * 11806 * Context: Waits for command to complete. Can sleep. 11807 */ 11808 11809 static int 11810 sd_send_scsi_cmd(dev_t dev, struct uscsi_cmd *incmd, int flag, 11811 enum uio_seg dataspace, int path_flag) 11812 { 11813 struct sd_lun *un; 11814 sd_ssc_t *ssc; 11815 int rval; 11816 11817 un = ddi_get_soft_state(sd_state, SDUNIT(dev)); 11818 if (un == NULL) { 11819 return (ENXIO); 11820 } 11821 11822 /* 11823 * Using sd_ssc_send to handle uscsi cmd 11824 */ 11825 ssc = sd_ssc_init(un); 11826 rval = sd_ssc_send(ssc, incmd, flag, dataspace, path_flag); 11827 sd_ssc_fini(ssc); 11828 11829 return (rval); 11830 } 11831 11832 /* 11833 * Function: sd_ssc_init 11834 * 11835 * Description: Uscsi end-user call this function to initialize necessary 11836 * fields, such as uscsi_cmd and sd_uscsi_info struct. 11837 * 11838 * The return value of sd_send_scsi_cmd will be treated as a 11839 * fault in various conditions. Even it is not Zero, some 11840 * callers may ignore the return value. That is to say, we can 11841 * not make an accurate assessment in sdintr, since if a 11842 * command is failed in sdintr it does not mean the caller of 11843 * sd_send_scsi_cmd will treat it as a real failure. 11844 * 11845 * To avoid printing too many error logs for a failed uscsi 11846 * packet that the caller may not treat it as a failure, the 11847 * sd will keep silent for handling all uscsi commands. 11848 * 11849 * During detach->attach and attach-open, for some types of 11850 * problems, the driver should be providing information about 11851 * the problem encountered. Device use USCSI_SILENT, which 11852 * suppresses all driver information. The result is that no 11853 * information about the problem is available. Being 11854 * completely silent during this time is inappropriate. The 11855 * driver needs a more selective filter than USCSI_SILENT, so 11856 * that information related to faults is provided. 11857 * 11858 * To make the accurate accessment, the caller of 11859 * sd_send_scsi_USCSI_CMD should take the ownership and 11860 * get necessary information to print error messages. 11861 * 11862 * If we want to print necessary info of uscsi command, we need to 11863 * keep the uscsi_cmd and sd_uscsi_info till we can make the 11864 * assessment. We use sd_ssc_init to alloc necessary 11865 * structs for sending an uscsi command and we are also 11866 * responsible for free the memory by calling 11867 * sd_ssc_fini. 11868 * 11869 * The calling secquences will look like: 11870 * sd_ssc_init-> 11871 * 11872 * ... 11873 * 11874 * sd_send_scsi_USCSI_CMD-> 11875 * sd_ssc_send-> - - - sdintr 11876 * ... 11877 * 11878 * if we think the return value should be treated as a 11879 * failure, we make the accessment here and print out 11880 * necessary by retrieving uscsi_cmd and sd_uscsi_info' 11881 * 11882 * ... 11883 * 11884 * sd_ssc_fini 11885 * 11886 * 11887 * Arguments: un - pointer to driver soft state (unit) structure for this 11888 * target. 11889 * 11890 * Return code: sd_ssc_t - pointer to allocated sd_ssc_t struct, it contains 11891 * uscsi_cmd and sd_uscsi_info. 11892 * NULL - if can not alloc memory for sd_ssc_t struct 11893 * 11894 * Context: Kernel Thread. 11895 */ 11896 static sd_ssc_t * 11897 sd_ssc_init(struct sd_lun *un) 11898 { 11899 sd_ssc_t *ssc; 11900 struct uscsi_cmd *ucmdp; 11901 struct sd_uscsi_info *uip; 11902 11903 ASSERT(un != NULL); 11904 ASSERT(!mutex_owned(SD_MUTEX(un))); 11905 11906 /* 11907 * Allocate sd_ssc_t structure 11908 */ 11909 ssc = kmem_zalloc(sizeof (sd_ssc_t), KM_SLEEP); 11910 11911 /* 11912 * Allocate uscsi_cmd by calling scsi_uscsi_alloc common routine 11913 */ 11914 ucmdp = scsi_uscsi_alloc(); 11915 11916 /* 11917 * Allocate sd_uscsi_info structure 11918 */ 11919 uip = kmem_zalloc(sizeof (struct sd_uscsi_info), KM_SLEEP); 11920 11921 ssc->ssc_uscsi_cmd = ucmdp; 11922 ssc->ssc_uscsi_info = uip; 11923 ssc->ssc_un = un; 11924 11925 return (ssc); 11926 } 11927 11928 /* 11929 * Function: sd_ssc_fini 11930 * 11931 * Description: To free sd_ssc_t and it's hanging off 11932 * 11933 * Arguments: ssc - struct pointer of sd_ssc_t. 11934 */ 11935 static void 11936 sd_ssc_fini(sd_ssc_t *ssc) 11937 { 11938 scsi_uscsi_free(ssc->ssc_uscsi_cmd); 11939 11940 if (ssc->ssc_uscsi_info != NULL) { 11941 kmem_free(ssc->ssc_uscsi_info, sizeof (struct sd_uscsi_info)); 11942 ssc->ssc_uscsi_info = NULL; 11943 } 11944 11945 kmem_free(ssc, sizeof (sd_ssc_t)); 11946 ssc = NULL; 11947 } 11948 11949 /* 11950 * Function: sd_ssc_send 11951 * 11952 * Description: Runs a USCSI command for user when called through sdioctl, 11953 * or for the driver. 11954 * 11955 * Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and 11956 * sd_uscsi_info in. 11957 * incmd - ptr to a valid uscsi_cmd struct 11958 * flag - bit flag, indicating open settings, 32/64 bit type 11959 * dataspace - UIO_USERSPACE or UIO_SYSSPACE 11960 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and 11961 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY 11962 * to use the USCSI "direct" chain and bypass the normal 11963 * command waitq. 11964 * 11965 * Return Code: 0 - successful completion of the given command 11966 * EIO - scsi_uscsi_handle_command() failed 11967 * ENXIO - soft state not found for specified dev 11968 * ECANCELED - command cancelled due to low power 11969 * EINVAL 11970 * EFAULT - copyin/copyout error 11971 * return code of scsi_uscsi_handle_command(): 11972 * EIO 11973 * ENXIO 11974 * EACCES 11975 * 11976 * Context: Kernel Thread; 11977 * Waits for command to complete. Can sleep. 11978 */ 11979 static int 11980 sd_ssc_send(sd_ssc_t *ssc, struct uscsi_cmd *incmd, int flag, 11981 enum uio_seg dataspace, int path_flag) 11982 { 11983 struct sd_uscsi_info *uip; 11984 struct uscsi_cmd *uscmd; 11985 struct sd_lun *un; 11986 dev_t dev; 11987 11988 int format = 0; 11989 int rval; 11990 11991 ASSERT(ssc != NULL); 11992 un = ssc->ssc_un; 11993 ASSERT(un != NULL); 11994 uscmd = ssc->ssc_uscsi_cmd; 11995 ASSERT(uscmd != NULL); 11996 ASSERT(!mutex_owned(SD_MUTEX(un))); 11997 if (ssc->ssc_flags & SSC_FLAGS_NEED_ASSESSMENT) { 11998 /* 11999 * If enter here, it indicates that the previous uscsi 12000 * command has not been processed by sd_ssc_assessment. 12001 * This is violating our rules of FMA telemetry processing. 12002 * We should print out this message and the last undisposed 12003 * uscsi command. 12004 */ 12005 if (uscmd->uscsi_cdb != NULL) { 12006 SD_INFO(SD_LOG_SDTEST, un, 12007 "sd_ssc_send is missing the alternative " 12008 "sd_ssc_assessment when running command 0x%x.\n", 12009 uscmd->uscsi_cdb[0]); 12010 } 12011 /* 12012 * Set the ssc_flags to SSC_FLAGS_UNKNOWN, which should be 12013 * the initial status. 12014 */ 12015 ssc->ssc_flags = SSC_FLAGS_UNKNOWN; 12016 } 12017 12018 /* 12019 * We need to make sure sd_ssc_send will have sd_ssc_assessment 12020 * followed to avoid missing FMA telemetries. 12021 */ 12022 ssc->ssc_flags |= SSC_FLAGS_NEED_ASSESSMENT; 12023 12024 /* 12025 * if USCSI_PMFAILFAST is set and un is in low power, fail the 12026 * command immediately. 12027 */ 12028 mutex_enter(SD_MUTEX(un)); 12029 mutex_enter(&un->un_pm_mutex); 12030 if ((uscmd->uscsi_flags & USCSI_PMFAILFAST) && 12031 SD_DEVICE_IS_IN_LOW_POWER(un)) { 12032 SD_TRACE(SD_LOG_IO, un, "sd_ssc_send:" 12033 "un:0x%p is in low power\n", un); 12034 mutex_exit(&un->un_pm_mutex); 12035 mutex_exit(SD_MUTEX(un)); 12036 return (ECANCELED); 12037 } 12038 mutex_exit(&un->un_pm_mutex); 12039 mutex_exit(SD_MUTEX(un)); 12040 12041 #ifdef SDDEBUG 12042 switch (dataspace) { 12043 case UIO_USERSPACE: 12044 SD_TRACE(SD_LOG_IO, un, 12045 "sd_ssc_send: entry: un:0x%p UIO_USERSPACE\n", un); 12046 break; 12047 case UIO_SYSSPACE: 12048 SD_TRACE(SD_LOG_IO, un, 12049 "sd_ssc_send: entry: un:0x%p UIO_SYSSPACE\n", un); 12050 break; 12051 default: 12052 SD_TRACE(SD_LOG_IO, un, 12053 "sd_ssc_send: entry: un:0x%p UNEXPECTED SPACE\n", un); 12054 break; 12055 } 12056 #endif 12057 12058 rval = scsi_uscsi_copyin((intptr_t)incmd, flag, 12059 SD_ADDRESS(un), &uscmd); 12060 if (rval != 0) { 12061 SD_TRACE(SD_LOG_IO, un, "sd_sense_scsi_cmd: " 12062 "scsi_uscsi_alloc_and_copyin failed\n", un); 12063 return (rval); 12064 } 12065 12066 if ((uscmd->uscsi_cdb != NULL) && 12067 (uscmd->uscsi_cdb[0] == SCMD_FORMAT)) { 12068 mutex_enter(SD_MUTEX(un)); 12069 un->un_f_format_in_progress = TRUE; 12070 mutex_exit(SD_MUTEX(un)); 12071 format = 1; 12072 } 12073 12074 /* 12075 * Allocate an sd_uscsi_info struct and fill it with the info 12076 * needed by sd_initpkt_for_uscsi(). Then put the pointer into 12077 * b_private in the buf for sd_initpkt_for_uscsi(). Note that 12078 * since we allocate the buf here in this function, we do not 12079 * need to preserve the prior contents of b_private. 12080 * The sd_uscsi_info struct is also used by sd_uscsi_strategy() 12081 */ 12082 uip = ssc->ssc_uscsi_info; 12083 uip->ui_flags = path_flag; 12084 uip->ui_cmdp = uscmd; 12085 12086 /* 12087 * Commands sent with priority are intended for error recovery 12088 * situations, and do not have retries performed. 12089 */ 12090 if (path_flag == SD_PATH_DIRECT_PRIORITY) { 12091 uscmd->uscsi_flags |= USCSI_DIAGNOSE; 12092 } 12093 uscmd->uscsi_flags &= ~USCSI_NOINTR; 12094 12095 dev = SD_GET_DEV(un); 12096 rval = scsi_uscsi_handle_cmd(dev, dataspace, uscmd, 12097 sd_uscsi_strategy, NULL, uip); 12098 12099 /* 12100 * mark ssc_flags right after handle_cmd to make sure 12101 * the uscsi has been sent 12102 */ 12103 ssc->ssc_flags |= SSC_FLAGS_CMD_ISSUED; 12104 12105 #ifdef SDDEBUG 12106 SD_INFO(SD_LOG_IO, un, "sd_ssc_send: " 12107 "uscsi_status: 0x%02x uscsi_resid:0x%x\n", 12108 uscmd->uscsi_status, uscmd->uscsi_resid); 12109 if (uscmd->uscsi_bufaddr != NULL) { 12110 SD_INFO(SD_LOG_IO, un, "sd_ssc_send: " 12111 "uscmd->uscsi_bufaddr: 0x%p uscmd->uscsi_buflen:%d\n", 12112 uscmd->uscsi_bufaddr, uscmd->uscsi_buflen); 12113 if (dataspace == UIO_SYSSPACE) { 12114 SD_DUMP_MEMORY(un, SD_LOG_IO, 12115 "data", (uchar_t *)uscmd->uscsi_bufaddr, 12116 uscmd->uscsi_buflen, SD_LOG_HEX); 12117 } 12118 } 12119 #endif 12120 12121 if (format == 1) { 12122 mutex_enter(SD_MUTEX(un)); 12123 un->un_f_format_in_progress = FALSE; 12124 mutex_exit(SD_MUTEX(un)); 12125 } 12126 12127 (void) scsi_uscsi_copyout((intptr_t)incmd, uscmd); 12128 12129 return (rval); 12130 } 12131 12132 /* 12133 * Function: sd_ssc_print 12134 * 12135 * Description: Print information available to the console. 12136 * 12137 * Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and 12138 * sd_uscsi_info in. 12139 * sd_severity - log level. 12140 * Context: Kernel thread or interrupt context. 12141 */ 12142 static void 12143 sd_ssc_print(sd_ssc_t *ssc, int sd_severity) 12144 { 12145 struct uscsi_cmd *ucmdp; 12146 struct scsi_device *devp; 12147 dev_info_t *devinfo; 12148 uchar_t *sensep; 12149 int senlen; 12150 union scsi_cdb *cdbp; 12151 uchar_t com; 12152 extern struct scsi_key_strings scsi_cmds[]; 12153 12154 ASSERT(ssc != NULL); 12155 ASSERT(ssc->ssc_un != NULL); 12156 12157 if (SD_FM_LOG(ssc->ssc_un) != SD_FM_LOG_EREPORT) 12158 return; 12159 ucmdp = ssc->ssc_uscsi_cmd; 12160 devp = SD_SCSI_DEVP(ssc->ssc_un); 12161 devinfo = SD_DEVINFO(ssc->ssc_un); 12162 ASSERT(ucmdp != NULL); 12163 ASSERT(devp != NULL); 12164 ASSERT(devinfo != NULL); 12165 sensep = (uint8_t *)ucmdp->uscsi_rqbuf; 12166 senlen = ucmdp->uscsi_rqlen - ucmdp->uscsi_rqresid; 12167 cdbp = (union scsi_cdb *)ucmdp->uscsi_cdb; 12168 12169 /* In certain case (like DOORLOCK), the cdb could be NULL. */ 12170 if (cdbp == NULL) 12171 return; 12172 /* We don't print log if no sense data available. */ 12173 if (senlen == 0) 12174 sensep = NULL; 12175 com = cdbp->scc_cmd; 12176 scsi_generic_errmsg(devp, sd_label, sd_severity, 0, 0, com, 12177 scsi_cmds, sensep, ssc->ssc_un->un_additional_codes, NULL); 12178 } 12179 12180 /* 12181 * Function: sd_ssc_assessment 12182 * 12183 * Description: We use this function to make an assessment at the point 12184 * where SD driver may encounter a potential error. 12185 * 12186 * Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and 12187 * sd_uscsi_info in. 12188 * tp_assess - a hint of strategy for ereport posting. 12189 * Possible values of tp_assess include: 12190 * SD_FMT_IGNORE - we don't post any ereport because we're 12191 * sure that it is ok to ignore the underlying problems. 12192 * SD_FMT_IGNORE_COMPROMISE - we don't post any ereport for now 12193 * but it might be not correct to ignore the underlying hardware 12194 * error. 12195 * SD_FMT_STATUS_CHECK - we will post an ereport with the 12196 * payload driver-assessment of value "fail" or 12197 * "fatal"(depending on what information we have here). This 12198 * assessment value is usually set when SD driver think there 12199 * is a potential error occurred(Typically, when return value 12200 * of the SCSI command is EIO). 12201 * SD_FMT_STANDARD - we will post an ereport with the payload 12202 * driver-assessment of value "info". This assessment value is 12203 * set when the SCSI command returned successfully and with 12204 * sense data sent back. 12205 * 12206 * Context: Kernel thread. 12207 */ 12208 static void 12209 sd_ssc_assessment(sd_ssc_t *ssc, enum sd_type_assessment tp_assess) 12210 { 12211 int senlen = 0; 12212 struct uscsi_cmd *ucmdp = NULL; 12213 struct sd_lun *un; 12214 12215 ASSERT(ssc != NULL); 12216 un = ssc->ssc_un; 12217 ASSERT(un != NULL); 12218 ucmdp = ssc->ssc_uscsi_cmd; 12219 ASSERT(ucmdp != NULL); 12220 12221 if (ssc->ssc_flags & SSC_FLAGS_NEED_ASSESSMENT) { 12222 ssc->ssc_flags &= ~SSC_FLAGS_NEED_ASSESSMENT; 12223 } else { 12224 /* 12225 * If enter here, it indicates that we have a wrong 12226 * calling sequence of sd_ssc_send and sd_ssc_assessment, 12227 * both of which should be called in a pair in case of 12228 * loss of FMA telemetries. 12229 */ 12230 if (ucmdp->uscsi_cdb != NULL) { 12231 SD_INFO(SD_LOG_SDTEST, un, 12232 "sd_ssc_assessment is missing the " 12233 "alternative sd_ssc_send when running 0x%x, " 12234 "or there are superfluous sd_ssc_assessment for " 12235 "the same sd_ssc_send.\n", 12236 ucmdp->uscsi_cdb[0]); 12237 } 12238 /* 12239 * Set the ssc_flags to the initial value to avoid passing 12240 * down dirty flags to the following sd_ssc_send function. 12241 */ 12242 ssc->ssc_flags = SSC_FLAGS_UNKNOWN; 12243 return; 12244 } 12245 12246 /* 12247 * Only handle an issued command which is waiting for assessment. 12248 * A command which is not issued will not have 12249 * SSC_FLAGS_INVALID_DATA set, so it'ok we just return here. 12250 */ 12251 if (!(ssc->ssc_flags & SSC_FLAGS_CMD_ISSUED)) { 12252 sd_ssc_print(ssc, SCSI_ERR_INFO); 12253 return; 12254 } else { 12255 /* 12256 * For an issued command, we should clear this flag in 12257 * order to make the sd_ssc_t structure be used off 12258 * multiple uscsi commands. 12259 */ 12260 ssc->ssc_flags &= ~SSC_FLAGS_CMD_ISSUED; 12261 } 12262 12263 /* 12264 * We will not deal with non-retryable(flag USCSI_DIAGNOSE set) 12265 * commands here. And we should clear the ssc_flags before return. 12266 */ 12267 if (ucmdp->uscsi_flags & USCSI_DIAGNOSE) { 12268 ssc->ssc_flags = SSC_FLAGS_UNKNOWN; 12269 return; 12270 } 12271 12272 switch (tp_assess) { 12273 case SD_FMT_IGNORE: 12274 case SD_FMT_IGNORE_COMPROMISE: 12275 break; 12276 case SD_FMT_STATUS_CHECK: 12277 /* 12278 * For a failed command(including the succeeded command 12279 * with invalid data sent back). 12280 */ 12281 sd_ssc_post(ssc, SD_FM_DRV_FATAL); 12282 break; 12283 case SD_FMT_STANDARD: 12284 /* 12285 * Always for the succeeded commands probably with sense 12286 * data sent back. 12287 * Limitation: 12288 * We can only handle a succeeded command with sense 12289 * data sent back when auto-request-sense is enabled. 12290 */ 12291 senlen = ssc->ssc_uscsi_cmd->uscsi_rqlen - 12292 ssc->ssc_uscsi_cmd->uscsi_rqresid; 12293 if ((ssc->ssc_uscsi_info->ui_pkt_state & STATE_ARQ_DONE) && 12294 (un->un_f_arq_enabled == TRUE) && 12295 senlen > 0 && 12296 ssc->ssc_uscsi_cmd->uscsi_rqbuf != NULL) { 12297 sd_ssc_post(ssc, SD_FM_DRV_NOTICE); 12298 } 12299 break; 12300 default: 12301 /* 12302 * Should not have other type of assessment. 12303 */ 12304 scsi_log(SD_DEVINFO(un), sd_label, CE_CONT, 12305 "sd_ssc_assessment got wrong " 12306 "sd_type_assessment %d.\n", tp_assess); 12307 break; 12308 } 12309 /* 12310 * Clear up the ssc_flags before return. 12311 */ 12312 ssc->ssc_flags = SSC_FLAGS_UNKNOWN; 12313 } 12314 12315 /* 12316 * Function: sd_ssc_post 12317 * 12318 * Description: 1. read the driver property to get fm-scsi-log flag. 12319 * 2. print log if fm_log_capable is non-zero. 12320 * 3. call sd_ssc_ereport_post to post ereport if possible. 12321 * 12322 * Context: May be called from kernel thread or interrupt context. 12323 */ 12324 static void 12325 sd_ssc_post(sd_ssc_t *ssc, enum sd_driver_assessment sd_assess) 12326 { 12327 struct sd_lun *un; 12328 int sd_severity; 12329 12330 ASSERT(ssc != NULL); 12331 un = ssc->ssc_un; 12332 ASSERT(un != NULL); 12333 12334 /* 12335 * We may enter here from sd_ssc_assessment(for USCSI command) or 12336 * by directly called from sdintr context. 12337 * We don't handle a non-disk drive(CD-ROM, removable media). 12338 * Clear the ssc_flags before return in case we've set 12339 * SSC_FLAGS_INVALID_XXX which should be skipped for a non-disk 12340 * driver. 12341 */ 12342 if (ISCD(un) || un->un_f_has_removable_media) { 12343 ssc->ssc_flags = SSC_FLAGS_UNKNOWN; 12344 return; 12345 } 12346 12347 switch (sd_assess) { 12348 case SD_FM_DRV_FATAL: 12349 sd_severity = SCSI_ERR_FATAL; 12350 break; 12351 case SD_FM_DRV_RECOVERY: 12352 sd_severity = SCSI_ERR_RECOVERED; 12353 break; 12354 case SD_FM_DRV_RETRY: 12355 sd_severity = SCSI_ERR_RETRYABLE; 12356 break; 12357 case SD_FM_DRV_NOTICE: 12358 sd_severity = SCSI_ERR_INFO; 12359 break; 12360 default: 12361 sd_severity = SCSI_ERR_UNKNOWN; 12362 } 12363 /* print log */ 12364 sd_ssc_print(ssc, sd_severity); 12365 12366 /* always post ereport */ 12367 sd_ssc_ereport_post(ssc, sd_assess); 12368 } 12369 12370 /* 12371 * Function: sd_ssc_set_info 12372 * 12373 * Description: Mark ssc_flags and set ssc_info which would be the 12374 * payload of uderr ereport. This function will cause 12375 * sd_ssc_ereport_post to post uderr ereport only. 12376 * Besides, when ssc_flags == SSC_FLAGS_INVALID_DATA(USCSI), 12377 * the function will also call SD_ERROR or scsi_log for a 12378 * CDROM/removable-media/DDI_FM_NOT_CAPABLE device. 12379 * 12380 * Arguments: ssc - the struct of sd_ssc_t will bring uscsi_cmd and 12381 * sd_uscsi_info in. 12382 * ssc_flags - indicate the sub-category of a uderr. 12383 * comp - this argument is meaningful only when 12384 * ssc_flags == SSC_FLAGS_INVALID_DATA, and its possible 12385 * values include: 12386 * > 0, SD_ERROR is used with comp as the driver logging 12387 * component; 12388 * = 0, scsi-log is used to log error telemetries; 12389 * < 0, no log available for this telemetry. 12390 * 12391 * Context: Kernel thread or interrupt context 12392 */ 12393 static void 12394 sd_ssc_set_info(sd_ssc_t *ssc, int ssc_flags, uint_t comp, const char *fmt, ...) 12395 { 12396 va_list ap; 12397 12398 ASSERT(ssc != NULL); 12399 ASSERT(ssc->ssc_un != NULL); 12400 12401 ssc->ssc_flags |= ssc_flags; 12402 va_start(ap, fmt); 12403 (void) vsnprintf(ssc->ssc_info, sizeof (ssc->ssc_info), fmt, ap); 12404 va_end(ap); 12405 12406 /* 12407 * If SSC_FLAGS_INVALID_DATA is set, it should be a uscsi command 12408 * with invalid data sent back. For non-uscsi command, the 12409 * following code will be bypassed. 12410 */ 12411 if (ssc_flags & SSC_FLAGS_INVALID_DATA) { 12412 if (SD_FM_LOG(ssc->ssc_un) == SD_FM_LOG_NSUP) { 12413 /* 12414 * If the error belong to certain component and we 12415 * do not want it to show up on the console, we 12416 * will use SD_ERROR, otherwise scsi_log is 12417 * preferred. 12418 */ 12419 if (comp > 0) { 12420 SD_ERROR(comp, ssc->ssc_un, ssc->ssc_info); 12421 } else if (comp == 0) { 12422 scsi_log(SD_DEVINFO(ssc->ssc_un), sd_label, 12423 CE_WARN, ssc->ssc_info); 12424 } 12425 } 12426 } 12427 } 12428 12429 /* 12430 * Function: sd_buf_iodone 12431 * 12432 * Description: Frees the sd_xbuf & returns the buf to its originator. 12433 * 12434 * Context: May be called from interrupt context. 12435 */ 12436 /* ARGSUSED */ 12437 static void 12438 sd_buf_iodone(int index, struct sd_lun *un, struct buf *bp) 12439 { 12440 struct sd_xbuf *xp; 12441 12442 ASSERT(un != NULL); 12443 ASSERT(bp != NULL); 12444 ASSERT(!mutex_owned(SD_MUTEX(un))); 12445 12446 SD_TRACE(SD_LOG_IO_CORE, un, "sd_buf_iodone: entry.\n"); 12447 12448 xp = SD_GET_XBUF(bp); 12449 ASSERT(xp != NULL); 12450 12451 /* xbuf is gone after this */ 12452 if (ddi_xbuf_done(bp, un->un_xbuf_attr)) { 12453 mutex_enter(SD_MUTEX(un)); 12454 12455 /* 12456 * Grab time when the cmd completed. 12457 * This is used for determining if the system has been 12458 * idle long enough to make it idle to the PM framework. 12459 * This is for lowering the overhead, and therefore improving 12460 * performance per I/O operation. 12461 */ 12462 un->un_pm_idle_time = gethrtime(); 12463 12464 un->un_ncmds_in_driver--; 12465 ASSERT(un->un_ncmds_in_driver >= 0); 12466 SD_INFO(SD_LOG_IO, un, 12467 "sd_buf_iodone: un_ncmds_in_driver = %ld\n", 12468 un->un_ncmds_in_driver); 12469 12470 mutex_exit(SD_MUTEX(un)); 12471 } 12472 12473 biodone(bp); /* bp is gone after this */ 12474 12475 SD_TRACE(SD_LOG_IO_CORE, un, "sd_buf_iodone: exit.\n"); 12476 } 12477 12478 12479 /* 12480 * Function: sd_uscsi_iodone 12481 * 12482 * Description: Frees the sd_xbuf & returns the buf to its originator. 12483 * 12484 * Context: May be called from interrupt context. 12485 */ 12486 /* ARGSUSED */ 12487 static void 12488 sd_uscsi_iodone(int index, struct sd_lun *un, struct buf *bp) 12489 { 12490 struct sd_xbuf *xp; 12491 12492 ASSERT(un != NULL); 12493 ASSERT(bp != NULL); 12494 12495 xp = SD_GET_XBUF(bp); 12496 ASSERT(xp != NULL); 12497 ASSERT(!mutex_owned(SD_MUTEX(un))); 12498 12499 SD_INFO(SD_LOG_IO, un, "sd_uscsi_iodone: entry.\n"); 12500 12501 bp->b_private = xp->xb_private; 12502 12503 mutex_enter(SD_MUTEX(un)); 12504 12505 /* 12506 * Grab time when the cmd completed. 12507 * This is used for determining if the system has been 12508 * idle long enough to make it idle to the PM framework. 12509 * This is for lowering the overhead, and therefore improving 12510 * performance per I/O operation. 12511 */ 12512 un->un_pm_idle_time = gethrtime(); 12513 12514 un->un_ncmds_in_driver--; 12515 ASSERT(un->un_ncmds_in_driver >= 0); 12516 SD_INFO(SD_LOG_IO, un, "sd_uscsi_iodone: un_ncmds_in_driver = %ld\n", 12517 un->un_ncmds_in_driver); 12518 12519 mutex_exit(SD_MUTEX(un)); 12520 12521 if (((struct uscsi_cmd *)(xp->xb_pktinfo))->uscsi_rqlen > 12522 SENSE_LENGTH) { 12523 kmem_free(xp, sizeof (struct sd_xbuf) - SENSE_LENGTH + 12524 MAX_SENSE_LENGTH); 12525 } else { 12526 kmem_free(xp, sizeof (struct sd_xbuf)); 12527 } 12528 12529 biodone(bp); 12530 12531 SD_INFO(SD_LOG_IO, un, "sd_uscsi_iodone: exit.\n"); 12532 } 12533 12534 12535 /* 12536 * Function: sd_mapblockaddr_iostart 12537 * 12538 * Description: Verify request lies within the partition limits for 12539 * the indicated minor device. Issue "overrun" buf if 12540 * request would exceed partition range. Converts 12541 * partition-relative block address to absolute. 12542 * 12543 * Upon exit of this function: 12544 * 1.I/O is aligned 12545 * xp->xb_blkno represents the absolute sector address 12546 * 2.I/O is misaligned 12547 * xp->xb_blkno represents the absolute logical block address 12548 * based on DEV_BSIZE. The logical block address will be 12549 * converted to physical sector address in sd_mapblocksize_\ 12550 * iostart. 12551 * 3.I/O is misaligned but is aligned in "overrun" buf 12552 * xp->xb_blkno represents the absolute logical block address 12553 * based on DEV_BSIZE. The logical block address will be 12554 * converted to physical sector address in sd_mapblocksize_\ 12555 * iostart. But no RMW will be issued in this case. 12556 * 12557 * Context: Can sleep 12558 * 12559 * Issues: This follows what the old code did, in terms of accessing 12560 * some of the partition info in the unit struct without holding 12561 * the mutext. This is a general issue, if the partition info 12562 * can be altered while IO is in progress... as soon as we send 12563 * a buf, its partitioning can be invalid before it gets to the 12564 * device. Probably the right fix is to move partitioning out 12565 * of the driver entirely. 12566 */ 12567 12568 static void 12569 sd_mapblockaddr_iostart(int index, struct sd_lun *un, struct buf *bp) 12570 { 12571 diskaddr_t nblocks; /* #blocks in the given partition */ 12572 daddr_t blocknum; /* Block number specified by the buf */ 12573 size_t requested_nblocks; 12574 size_t available_nblocks; 12575 int partition; 12576 diskaddr_t partition_offset; 12577 struct sd_xbuf *xp; 12578 int secmask = 0, blknomask = 0; 12579 ushort_t is_aligned = TRUE; 12580 12581 ASSERT(un != NULL); 12582 ASSERT(bp != NULL); 12583 ASSERT(!mutex_owned(SD_MUTEX(un))); 12584 12585 SD_TRACE(SD_LOG_IO_PARTITION, un, 12586 "sd_mapblockaddr_iostart: entry: buf:0x%p\n", bp); 12587 12588 xp = SD_GET_XBUF(bp); 12589 ASSERT(xp != NULL); 12590 12591 /* 12592 * If the geometry is not indicated as valid, attempt to access 12593 * the unit & verify the geometry/label. This can be the case for 12594 * removable-media devices, of if the device was opened in 12595 * NDELAY/NONBLOCK mode. 12596 */ 12597 partition = SDPART(bp->b_edev); 12598 12599 if (!SD_IS_VALID_LABEL(un)) { 12600 sd_ssc_t *ssc; 12601 /* 12602 * Initialize sd_ssc_t for internal uscsi commands 12603 * In case of potential porformance issue, we need 12604 * to alloc memory only if there is invalid label 12605 */ 12606 ssc = sd_ssc_init(un); 12607 12608 if (sd_ready_and_valid(ssc, partition) != SD_READY_VALID) { 12609 /* 12610 * For removable devices it is possible to start an 12611 * I/O without a media by opening the device in nodelay 12612 * mode. Also for writable CDs there can be many 12613 * scenarios where there is no geometry yet but volume 12614 * manager is trying to issue a read() just because 12615 * it can see TOC on the CD. So do not print a message 12616 * for removables. 12617 */ 12618 if (!un->un_f_has_removable_media) { 12619 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 12620 "i/o to invalid geometry\n"); 12621 } 12622 bioerror(bp, EIO); 12623 bp->b_resid = bp->b_bcount; 12624 SD_BEGIN_IODONE(index, un, bp); 12625 12626 sd_ssc_fini(ssc); 12627 return; 12628 } 12629 sd_ssc_fini(ssc); 12630 } 12631 12632 nblocks = 0; 12633 (void) cmlb_partinfo(un->un_cmlbhandle, partition, 12634 &nblocks, &partition_offset, NULL, NULL, (void *)SD_PATH_DIRECT); 12635 12636 if (un->un_f_enable_rmw) { 12637 blknomask = (un->un_phy_blocksize / DEV_BSIZE) - 1; 12638 secmask = un->un_phy_blocksize - 1; 12639 } else { 12640 blknomask = (un->un_tgt_blocksize / DEV_BSIZE) - 1; 12641 secmask = un->un_tgt_blocksize - 1; 12642 } 12643 12644 if ((bp->b_lblkno & (blknomask)) || (bp->b_bcount & (secmask))) { 12645 is_aligned = FALSE; 12646 } 12647 12648 if (!(NOT_DEVBSIZE(un)) || un->un_f_enable_rmw) { 12649 /* 12650 * If I/O is aligned, no need to involve RMW(Read Modify Write) 12651 * Convert the logical block number to target's physical sector 12652 * number. 12653 */ 12654 if (is_aligned) { 12655 xp->xb_blkno = SD_SYS2TGTBLOCK(un, xp->xb_blkno); 12656 } else { 12657 /* 12658 * There is no RMW if we're just reading, so don't 12659 * warn or error out because of it. 12660 */ 12661 if (bp->b_flags & B_READ) { 12662 /*EMPTY*/ 12663 } else if (!un->un_f_enable_rmw && 12664 un->un_f_rmw_type == SD_RMW_TYPE_RETURN_ERROR) { 12665 bp->b_flags |= B_ERROR; 12666 goto error_exit; 12667 } else if (un->un_f_rmw_type == SD_RMW_TYPE_DEFAULT) { 12668 mutex_enter(SD_MUTEX(un)); 12669 if (!un->un_f_enable_rmw && 12670 un->un_rmw_msg_timeid == NULL) { 12671 scsi_log(SD_DEVINFO(un), sd_label, 12672 CE_WARN, "I/O request is not " 12673 "aligned with %d disk sector size. " 12674 "It is handled through Read Modify " 12675 "Write but the performance is " 12676 "very low.\n", 12677 un->un_tgt_blocksize); 12678 un->un_rmw_msg_timeid = 12679 timeout(sd_rmw_msg_print_handler, 12680 un, SD_RMW_MSG_PRINT_TIMEOUT); 12681 } else { 12682 un->un_rmw_incre_count ++; 12683 } 12684 mutex_exit(SD_MUTEX(un)); 12685 } 12686 12687 nblocks = SD_TGT2SYSBLOCK(un, nblocks); 12688 partition_offset = SD_TGT2SYSBLOCK(un, 12689 partition_offset); 12690 } 12691 } 12692 12693 /* 12694 * blocknum is the starting block number of the request. At this 12695 * point it is still relative to the start of the minor device. 12696 */ 12697 blocknum = xp->xb_blkno; 12698 12699 /* 12700 * Legacy: If the starting block number is one past the last block 12701 * in the partition, do not set B_ERROR in the buf. 12702 */ 12703 if (blocknum == nblocks) { 12704 goto error_exit; 12705 } 12706 12707 /* 12708 * Confirm that the first block of the request lies within the 12709 * partition limits. Also the requested number of bytes must be 12710 * a multiple of the system block size. 12711 */ 12712 if ((blocknum < 0) || (blocknum >= nblocks) || 12713 ((bp->b_bcount & (DEV_BSIZE - 1)) != 0)) { 12714 bp->b_flags |= B_ERROR; 12715 goto error_exit; 12716 } 12717 12718 /* 12719 * If the requsted # blocks exceeds the available # blocks, that 12720 * is an overrun of the partition. 12721 */ 12722 if ((!NOT_DEVBSIZE(un)) && is_aligned) { 12723 requested_nblocks = SD_BYTES2TGTBLOCKS(un, bp->b_bcount); 12724 } else { 12725 requested_nblocks = SD_BYTES2SYSBLOCKS(bp->b_bcount); 12726 } 12727 12728 available_nblocks = (size_t)(nblocks - blocknum); 12729 ASSERT(nblocks >= blocknum); 12730 12731 if (requested_nblocks > available_nblocks) { 12732 size_t resid; 12733 12734 /* 12735 * Allocate an "overrun" buf to allow the request to proceed 12736 * for the amount of space available in the partition. The 12737 * amount not transferred will be added into the b_resid 12738 * when the operation is complete. The overrun buf 12739 * replaces the original buf here, and the original buf 12740 * is saved inside the overrun buf, for later use. 12741 */ 12742 if ((!NOT_DEVBSIZE(un)) && is_aligned) { 12743 resid = SD_TGTBLOCKS2BYTES(un, 12744 (offset_t)(requested_nblocks - available_nblocks)); 12745 } else { 12746 resid = SD_SYSBLOCKS2BYTES( 12747 (offset_t)(requested_nblocks - available_nblocks)); 12748 } 12749 12750 size_t count = bp->b_bcount - resid; 12751 /* 12752 * Note: count is an unsigned entity thus it'll NEVER 12753 * be less than 0 so ASSERT the original values are 12754 * correct. 12755 */ 12756 ASSERT(bp->b_bcount >= resid); 12757 12758 bp = sd_bioclone_alloc(bp, count, blocknum, 12759 (int (*)(struct buf *)) sd_mapblockaddr_iodone); 12760 xp = SD_GET_XBUF(bp); /* Update for 'new' bp! */ 12761 ASSERT(xp != NULL); 12762 } 12763 12764 /* At this point there should be no residual for this buf. */ 12765 ASSERT(bp->b_resid == 0); 12766 12767 /* Convert the block number to an absolute address. */ 12768 xp->xb_blkno += partition_offset; 12769 12770 SD_NEXT_IOSTART(index, un, bp); 12771 12772 SD_TRACE(SD_LOG_IO_PARTITION, un, 12773 "sd_mapblockaddr_iostart: exit 0: buf:0x%p\n", bp); 12774 12775 return; 12776 12777 error_exit: 12778 bp->b_resid = bp->b_bcount; 12779 SD_BEGIN_IODONE(index, un, bp); 12780 SD_TRACE(SD_LOG_IO_PARTITION, un, 12781 "sd_mapblockaddr_iostart: exit 1: buf:0x%p\n", bp); 12782 } 12783 12784 12785 /* 12786 * Function: sd_mapblockaddr_iodone 12787 * 12788 * Description: Completion-side processing for partition management. 12789 * 12790 * Context: May be called under interrupt context 12791 */ 12792 12793 static void 12794 sd_mapblockaddr_iodone(int index, struct sd_lun *un, struct buf *bp) 12795 { 12796 /* int partition; */ /* Not used, see below. */ 12797 ASSERT(un != NULL); 12798 ASSERT(bp != NULL); 12799 ASSERT(!mutex_owned(SD_MUTEX(un))); 12800 12801 SD_TRACE(SD_LOG_IO_PARTITION, un, 12802 "sd_mapblockaddr_iodone: entry: buf:0x%p\n", bp); 12803 12804 if (bp->b_iodone == (int (*)(struct buf *)) sd_mapblockaddr_iodone) { 12805 /* 12806 * We have an "overrun" buf to deal with... 12807 */ 12808 struct sd_xbuf *xp; 12809 struct buf *obp; /* ptr to the original buf */ 12810 12811 xp = SD_GET_XBUF(bp); 12812 ASSERT(xp != NULL); 12813 12814 /* Retrieve the pointer to the original buf */ 12815 obp = (struct buf *)xp->xb_private; 12816 ASSERT(obp != NULL); 12817 12818 obp->b_resid = obp->b_bcount - (bp->b_bcount - bp->b_resid); 12819 bioerror(obp, bp->b_error); 12820 12821 sd_bioclone_free(bp); 12822 12823 /* 12824 * Get back the original buf. 12825 * Note that since the restoration of xb_blkno below 12826 * was removed, the sd_xbuf is not needed. 12827 */ 12828 bp = obp; 12829 /* 12830 * xp = SD_GET_XBUF(bp); 12831 * ASSERT(xp != NULL); 12832 */ 12833 } 12834 12835 /* 12836 * Convert sd->xb_blkno back to a minor-device relative value. 12837 * Note: this has been commented out, as it is not needed in the 12838 * current implementation of the driver (ie, since this function 12839 * is at the top of the layering chains, so the info will be 12840 * discarded) and it is in the "hot" IO path. 12841 * 12842 * partition = getminor(bp->b_edev) & SDPART_MASK; 12843 * xp->xb_blkno -= un->un_offset[partition]; 12844 */ 12845 12846 SD_NEXT_IODONE(index, un, bp); 12847 12848 SD_TRACE(SD_LOG_IO_PARTITION, un, 12849 "sd_mapblockaddr_iodone: exit: buf:0x%p\n", bp); 12850 } 12851 12852 12853 /* 12854 * Function: sd_mapblocksize_iostart 12855 * 12856 * Description: Convert between system block size (un->un_sys_blocksize) 12857 * and target block size (un->un_tgt_blocksize). 12858 * 12859 * Context: Can sleep to allocate resources. 12860 * 12861 * Assumptions: A higher layer has already performed any partition validation, 12862 * and converted the xp->xb_blkno to an absolute value relative 12863 * to the start of the device. 12864 * 12865 * It is also assumed that the higher layer has implemented 12866 * an "overrun" mechanism for the case where the request would 12867 * read/write beyond the end of a partition. In this case we 12868 * assume (and ASSERT) that bp->b_resid == 0. 12869 * 12870 * Note: The implementation for this routine assumes the target 12871 * block size remains constant between allocation and transport. 12872 */ 12873 12874 static void 12875 sd_mapblocksize_iostart(int index, struct sd_lun *un, struct buf *bp) 12876 { 12877 struct sd_mapblocksize_info *bsp; 12878 struct sd_xbuf *xp; 12879 offset_t first_byte; 12880 daddr_t start_block, end_block; 12881 daddr_t request_bytes; 12882 ushort_t is_aligned = FALSE; 12883 12884 ASSERT(un != NULL); 12885 ASSERT(bp != NULL); 12886 ASSERT(!mutex_owned(SD_MUTEX(un))); 12887 ASSERT(bp->b_resid == 0); 12888 12889 SD_TRACE(SD_LOG_IO_RMMEDIA, un, 12890 "sd_mapblocksize_iostart: entry: buf:0x%p\n", bp); 12891 12892 /* 12893 * For a non-writable CD, a write request is an error 12894 */ 12895 if (ISCD(un) && ((bp->b_flags & B_READ) == 0) && 12896 (un->un_f_mmc_writable_media == FALSE)) { 12897 bioerror(bp, EIO); 12898 bp->b_resid = bp->b_bcount; 12899 SD_BEGIN_IODONE(index, un, bp); 12900 return; 12901 } 12902 12903 /* 12904 * We do not need a shadow buf if the device is using 12905 * un->un_sys_blocksize as its block size or if bcount == 0. 12906 * In this case there is no layer-private data block allocated. 12907 */ 12908 if ((un->un_tgt_blocksize == DEV_BSIZE && !un->un_f_enable_rmw) || 12909 (bp->b_bcount == 0)) { 12910 goto done; 12911 } 12912 12913 #if defined(__i386) || defined(__amd64) 12914 /* We do not support non-block-aligned transfers for ROD devices */ 12915 ASSERT(!ISROD(un)); 12916 #endif 12917 12918 xp = SD_GET_XBUF(bp); 12919 ASSERT(xp != NULL); 12920 12921 SD_INFO(SD_LOG_IO_RMMEDIA, un, "sd_mapblocksize_iostart: " 12922 "tgt_blocksize:0x%x sys_blocksize: 0x%x\n", 12923 un->un_tgt_blocksize, DEV_BSIZE); 12924 SD_INFO(SD_LOG_IO_RMMEDIA, un, "sd_mapblocksize_iostart: " 12925 "request start block:0x%x\n", xp->xb_blkno); 12926 SD_INFO(SD_LOG_IO_RMMEDIA, un, "sd_mapblocksize_iostart: " 12927 "request len:0x%x\n", bp->b_bcount); 12928 12929 /* 12930 * Allocate the layer-private data area for the mapblocksize layer. 12931 * Layers are allowed to use the xp_private member of the sd_xbuf 12932 * struct to store the pointer to their layer-private data block, but 12933 * each layer also has the responsibility of restoring the prior 12934 * contents of xb_private before returning the buf/xbuf to the 12935 * higher layer that sent it. 12936 * 12937 * Here we save the prior contents of xp->xb_private into the 12938 * bsp->mbs_oprivate field of our layer-private data area. This value 12939 * is restored by sd_mapblocksize_iodone() just prior to freeing up 12940 * the layer-private area and returning the buf/xbuf to the layer 12941 * that sent it. 12942 * 12943 * Note that here we use kmem_zalloc for the allocation as there are 12944 * parts of the mapblocksize code that expect certain fields to be 12945 * zero unless explicitly set to a required value. 12946 */ 12947 bsp = kmem_zalloc(sizeof (struct sd_mapblocksize_info), KM_SLEEP); 12948 bsp->mbs_oprivate = xp->xb_private; 12949 xp->xb_private = bsp; 12950 12951 /* 12952 * This treats the data on the disk (target) as an array of bytes. 12953 * first_byte is the byte offset, from the beginning of the device, 12954 * to the location of the request. This is converted from a 12955 * un->un_sys_blocksize block address to a byte offset, and then back 12956 * to a block address based upon a un->un_tgt_blocksize block size. 12957 * 12958 * xp->xb_blkno should be absolute upon entry into this function, 12959 * but, but it is based upon partitions that use the "system" 12960 * block size. It must be adjusted to reflect the block size of 12961 * the target. 12962 * 12963 * Note that end_block is actually the block that follows the last 12964 * block of the request, but that's what is needed for the computation. 12965 */ 12966 first_byte = SD_SYSBLOCKS2BYTES((offset_t)xp->xb_blkno); 12967 if (un->un_f_enable_rmw) { 12968 start_block = xp->xb_blkno = 12969 (first_byte / un->un_phy_blocksize) * 12970 (un->un_phy_blocksize / DEV_BSIZE); 12971 end_block = ((first_byte + bp->b_bcount + 12972 un->un_phy_blocksize - 1) / un->un_phy_blocksize) * 12973 (un->un_phy_blocksize / DEV_BSIZE); 12974 } else { 12975 start_block = xp->xb_blkno = first_byte / un->un_tgt_blocksize; 12976 end_block = (first_byte + bp->b_bcount + 12977 un->un_tgt_blocksize - 1) / un->un_tgt_blocksize; 12978 } 12979 12980 /* request_bytes is rounded up to a multiple of the target block size */ 12981 request_bytes = (end_block - start_block) * un->un_tgt_blocksize; 12982 12983 /* 12984 * See if the starting address of the request and the request 12985 * length are aligned on a un->un_tgt_blocksize boundary. If aligned 12986 * then we do not need to allocate a shadow buf to handle the request. 12987 */ 12988 if (un->un_f_enable_rmw) { 12989 if (((first_byte % un->un_phy_blocksize) == 0) && 12990 ((bp->b_bcount % un->un_phy_blocksize) == 0)) { 12991 is_aligned = TRUE; 12992 } 12993 } else { 12994 if (((first_byte % un->un_tgt_blocksize) == 0) && 12995 ((bp->b_bcount % un->un_tgt_blocksize) == 0)) { 12996 is_aligned = TRUE; 12997 } 12998 } 12999 13000 if ((bp->b_flags & B_READ) == 0) { 13001 /* 13002 * Lock the range for a write operation. An aligned request is 13003 * considered a simple write; otherwise the request must be a 13004 * read-modify-write. 13005 */ 13006 bsp->mbs_wmp = sd_range_lock(un, start_block, end_block - 1, 13007 (is_aligned == TRUE) ? SD_WTYPE_SIMPLE : SD_WTYPE_RMW); 13008 } 13009 13010 /* 13011 * Alloc a shadow buf if the request is not aligned. Also, this is 13012 * where the READ command is generated for a read-modify-write. (The 13013 * write phase is deferred until after the read completes.) 13014 */ 13015 if (is_aligned == FALSE) { 13016 13017 struct sd_mapblocksize_info *shadow_bsp; 13018 struct sd_xbuf *shadow_xp; 13019 struct buf *shadow_bp; 13020 13021 /* 13022 * Allocate the shadow buf and it associated xbuf. Note that 13023 * after this call the xb_blkno value in both the original 13024 * buf's sd_xbuf _and_ the shadow buf's sd_xbuf will be the 13025 * same: absolute relative to the start of the device, and 13026 * adjusted for the target block size. The b_blkno in the 13027 * shadow buf will also be set to this value. We should never 13028 * change b_blkno in the original bp however. 13029 * 13030 * Note also that the shadow buf will always need to be a 13031 * READ command, regardless of whether the incoming command 13032 * is a READ or a WRITE. 13033 */ 13034 shadow_bp = sd_shadow_buf_alloc(bp, request_bytes, B_READ, 13035 xp->xb_blkno, 13036 (int (*)(struct buf *)) sd_mapblocksize_iodone); 13037 13038 shadow_xp = SD_GET_XBUF(shadow_bp); 13039 13040 /* 13041 * Allocate the layer-private data for the shadow buf. 13042 * (No need to preserve xb_private in the shadow xbuf.) 13043 */ 13044 shadow_xp->xb_private = shadow_bsp = 13045 kmem_zalloc(sizeof (struct sd_mapblocksize_info), KM_SLEEP); 13046 13047 /* 13048 * bsp->mbs_copy_offset is used later by sd_mapblocksize_iodone 13049 * to figure out where the start of the user data is (based upon 13050 * the system block size) in the data returned by the READ 13051 * command (which will be based upon the target blocksize). Note 13052 * that this is only really used if the request is unaligned. 13053 */ 13054 if (un->un_f_enable_rmw) { 13055 bsp->mbs_copy_offset = (ssize_t)(first_byte - 13056 ((offset_t)xp->xb_blkno * un->un_sys_blocksize)); 13057 ASSERT((bsp->mbs_copy_offset >= 0) && 13058 (bsp->mbs_copy_offset < un->un_phy_blocksize)); 13059 } else { 13060 bsp->mbs_copy_offset = (ssize_t)(first_byte - 13061 ((offset_t)xp->xb_blkno * un->un_tgt_blocksize)); 13062 ASSERT((bsp->mbs_copy_offset >= 0) && 13063 (bsp->mbs_copy_offset < un->un_tgt_blocksize)); 13064 } 13065 13066 shadow_bsp->mbs_copy_offset = bsp->mbs_copy_offset; 13067 13068 shadow_bsp->mbs_layer_index = bsp->mbs_layer_index = index; 13069 13070 /* Transfer the wmap (if any) to the shadow buf */ 13071 shadow_bsp->mbs_wmp = bsp->mbs_wmp; 13072 bsp->mbs_wmp = NULL; 13073 13074 /* 13075 * The shadow buf goes on from here in place of the 13076 * original buf. 13077 */ 13078 shadow_bsp->mbs_orig_bp = bp; 13079 bp = shadow_bp; 13080 } 13081 13082 SD_INFO(SD_LOG_IO_RMMEDIA, un, 13083 "sd_mapblocksize_iostart: tgt start block:0x%x\n", xp->xb_blkno); 13084 SD_INFO(SD_LOG_IO_RMMEDIA, un, 13085 "sd_mapblocksize_iostart: tgt request len:0x%x\n", 13086 request_bytes); 13087 SD_INFO(SD_LOG_IO_RMMEDIA, un, 13088 "sd_mapblocksize_iostart: shadow buf:0x%x\n", bp); 13089 13090 done: 13091 SD_NEXT_IOSTART(index, un, bp); 13092 13093 SD_TRACE(SD_LOG_IO_RMMEDIA, un, 13094 "sd_mapblocksize_iostart: exit: buf:0x%p\n", bp); 13095 } 13096 13097 13098 /* 13099 * Function: sd_mapblocksize_iodone 13100 * 13101 * Description: Completion side processing for block-size mapping. 13102 * 13103 * Context: May be called under interrupt context 13104 */ 13105 13106 static void 13107 sd_mapblocksize_iodone(int index, struct sd_lun *un, struct buf *bp) 13108 { 13109 struct sd_mapblocksize_info *bsp; 13110 struct sd_xbuf *xp; 13111 struct sd_xbuf *orig_xp; /* sd_xbuf for the original buf */ 13112 struct buf *orig_bp; /* ptr to the original buf */ 13113 offset_t shadow_end; 13114 offset_t request_end; 13115 offset_t shadow_start; 13116 ssize_t copy_offset; 13117 size_t copy_length; 13118 size_t shortfall; 13119 uint_t is_write; /* TRUE if this bp is a WRITE */ 13120 uint_t has_wmap; /* TRUE is this bp has a wmap */ 13121 13122 ASSERT(un != NULL); 13123 ASSERT(bp != NULL); 13124 13125 SD_TRACE(SD_LOG_IO_RMMEDIA, un, 13126 "sd_mapblocksize_iodone: entry: buf:0x%p\n", bp); 13127 13128 /* 13129 * There is no shadow buf or layer-private data if the target is 13130 * using un->un_sys_blocksize as its block size or if bcount == 0. 13131 */ 13132 if ((un->un_tgt_blocksize == DEV_BSIZE && !un->un_f_enable_rmw) || 13133 (bp->b_bcount == 0)) { 13134 goto exit; 13135 } 13136 13137 xp = SD_GET_XBUF(bp); 13138 ASSERT(xp != NULL); 13139 13140 /* Retrieve the pointer to the layer-private data area from the xbuf. */ 13141 bsp = xp->xb_private; 13142 13143 is_write = ((bp->b_flags & B_READ) == 0) ? TRUE : FALSE; 13144 has_wmap = (bsp->mbs_wmp != NULL) ? TRUE : FALSE; 13145 13146 if (is_write) { 13147 /* 13148 * For a WRITE request we must free up the block range that 13149 * we have locked up. This holds regardless of whether this is 13150 * an aligned write request or a read-modify-write request. 13151 */ 13152 sd_range_unlock(un, bsp->mbs_wmp); 13153 bsp->mbs_wmp = NULL; 13154 } 13155 13156 if ((bp->b_iodone != (int(*)(struct buf *))sd_mapblocksize_iodone)) { 13157 /* 13158 * An aligned read or write command will have no shadow buf; 13159 * there is not much else to do with it. 13160 */ 13161 goto done; 13162 } 13163 13164 orig_bp = bsp->mbs_orig_bp; 13165 ASSERT(orig_bp != NULL); 13166 orig_xp = SD_GET_XBUF(orig_bp); 13167 ASSERT(orig_xp != NULL); 13168 ASSERT(!mutex_owned(SD_MUTEX(un))); 13169 13170 if (!is_write && has_wmap) { 13171 /* 13172 * A READ with a wmap means this is the READ phase of a 13173 * read-modify-write. If an error occurred on the READ then 13174 * we do not proceed with the WRITE phase or copy any data. 13175 * Just release the write maps and return with an error. 13176 */ 13177 if ((bp->b_resid != 0) || (bp->b_error != 0)) { 13178 orig_bp->b_resid = orig_bp->b_bcount; 13179 bioerror(orig_bp, bp->b_error); 13180 sd_range_unlock(un, bsp->mbs_wmp); 13181 goto freebuf_done; 13182 } 13183 } 13184 13185 /* 13186 * Here is where we set up to copy the data from the shadow buf 13187 * into the space associated with the original buf. 13188 * 13189 * To deal with the conversion between block sizes, these 13190 * computations treat the data as an array of bytes, with the 13191 * first byte (byte 0) corresponding to the first byte in the 13192 * first block on the disk. 13193 */ 13194 13195 /* 13196 * shadow_start and shadow_len indicate the location and size of 13197 * the data returned with the shadow IO request. 13198 */ 13199 if (un->un_f_enable_rmw) { 13200 shadow_start = SD_SYSBLOCKS2BYTES((offset_t)xp->xb_blkno); 13201 } else { 13202 shadow_start = SD_TGTBLOCKS2BYTES(un, (offset_t)xp->xb_blkno); 13203 } 13204 shadow_end = shadow_start + bp->b_bcount - bp->b_resid; 13205 13206 /* 13207 * copy_offset gives the offset (in bytes) from the start of the first 13208 * block of the READ request to the beginning of the data. We retrieve 13209 * this value from xb_pktp in the ORIGINAL xbuf, as it has been saved 13210 * there by sd_mapblockize_iostart(). copy_length gives the amount of 13211 * data to be copied (in bytes). 13212 */ 13213 copy_offset = bsp->mbs_copy_offset; 13214 if (un->un_f_enable_rmw) { 13215 ASSERT((copy_offset >= 0) && 13216 (copy_offset < un->un_phy_blocksize)); 13217 } else { 13218 ASSERT((copy_offset >= 0) && 13219 (copy_offset < un->un_tgt_blocksize)); 13220 } 13221 13222 copy_length = orig_bp->b_bcount; 13223 request_end = shadow_start + copy_offset + orig_bp->b_bcount; 13224 13225 /* 13226 * Set up the resid and error fields of orig_bp as appropriate. 13227 */ 13228 if (shadow_end >= request_end) { 13229 /* We got all the requested data; set resid to zero */ 13230 orig_bp->b_resid = 0; 13231 } else { 13232 /* 13233 * We failed to get enough data to fully satisfy the original 13234 * request. Just copy back whatever data we got and set 13235 * up the residual and error code as required. 13236 * 13237 * 'shortfall' is the amount by which the data received with the 13238 * shadow buf has "fallen short" of the requested amount. 13239 */ 13240 shortfall = (size_t)(request_end - shadow_end); 13241 13242 if (shortfall > orig_bp->b_bcount) { 13243 /* 13244 * We did not get enough data to even partially 13245 * fulfill the original request. The residual is 13246 * equal to the amount requested. 13247 */ 13248 orig_bp->b_resid = orig_bp->b_bcount; 13249 } else { 13250 /* 13251 * We did not get all the data that we requested 13252 * from the device, but we will try to return what 13253 * portion we did get. 13254 */ 13255 orig_bp->b_resid = shortfall; 13256 } 13257 ASSERT(copy_length >= orig_bp->b_resid); 13258 copy_length -= orig_bp->b_resid; 13259 } 13260 13261 /* Propagate the error code from the shadow buf to the original buf */ 13262 bioerror(orig_bp, bp->b_error); 13263 13264 if (is_write) { 13265 goto freebuf_done; /* No data copying for a WRITE */ 13266 } 13267 13268 if (has_wmap) { 13269 /* 13270 * This is a READ command from the READ phase of a 13271 * read-modify-write request. We have to copy the data given 13272 * by the user OVER the data returned by the READ command, 13273 * then convert the command from a READ to a WRITE and send 13274 * it back to the target. 13275 */ 13276 bcopy(orig_bp->b_un.b_addr, bp->b_un.b_addr + copy_offset, 13277 copy_length); 13278 13279 bp->b_flags &= ~((int)B_READ); /* Convert to a WRITE */ 13280 13281 /* 13282 * Dispatch the WRITE command to the taskq thread, which 13283 * will in turn send the command to the target. When the 13284 * WRITE command completes, we (sd_mapblocksize_iodone()) 13285 * will get called again as part of the iodone chain 13286 * processing for it. Note that we will still be dealing 13287 * with the shadow buf at that point. 13288 */ 13289 if (taskq_dispatch(sd_wmr_tq, sd_read_modify_write_task, bp, 13290 KM_NOSLEEP) != 0) { 13291 /* 13292 * Dispatch was successful so we are done. Return 13293 * without going any higher up the iodone chain. Do 13294 * not free up any layer-private data until after the 13295 * WRITE completes. 13296 */ 13297 return; 13298 } 13299 13300 /* 13301 * Dispatch of the WRITE command failed; set up the error 13302 * condition and send this IO back up the iodone chain. 13303 */ 13304 bioerror(orig_bp, EIO); 13305 orig_bp->b_resid = orig_bp->b_bcount; 13306 13307 } else { 13308 /* 13309 * This is a regular READ request (ie, not a RMW). Copy the 13310 * data from the shadow buf into the original buf. The 13311 * copy_offset compensates for any "misalignment" between the 13312 * shadow buf (with its un->un_tgt_blocksize blocks) and the 13313 * original buf (with its un->un_sys_blocksize blocks). 13314 */ 13315 bcopy(bp->b_un.b_addr + copy_offset, orig_bp->b_un.b_addr, 13316 copy_length); 13317 } 13318 13319 freebuf_done: 13320 13321 /* 13322 * At this point we still have both the shadow buf AND the original 13323 * buf to deal with, as well as the layer-private data area in each. 13324 * Local variables are as follows: 13325 * 13326 * bp -- points to shadow buf 13327 * xp -- points to xbuf of shadow buf 13328 * bsp -- points to layer-private data area of shadow buf 13329 * orig_bp -- points to original buf 13330 * 13331 * First free the shadow buf and its associated xbuf, then free the 13332 * layer-private data area from the shadow buf. There is no need to 13333 * restore xb_private in the shadow xbuf. 13334 */ 13335 sd_shadow_buf_free(bp); 13336 kmem_free(bsp, sizeof (struct sd_mapblocksize_info)); 13337 13338 /* 13339 * Now update the local variables to point to the original buf, xbuf, 13340 * and layer-private area. 13341 */ 13342 bp = orig_bp; 13343 xp = SD_GET_XBUF(bp); 13344 ASSERT(xp != NULL); 13345 ASSERT(xp == orig_xp); 13346 bsp = xp->xb_private; 13347 ASSERT(bsp != NULL); 13348 13349 done: 13350 /* 13351 * Restore xb_private to whatever it was set to by the next higher 13352 * layer in the chain, then free the layer-private data area. 13353 */ 13354 xp->xb_private = bsp->mbs_oprivate; 13355 kmem_free(bsp, sizeof (struct sd_mapblocksize_info)); 13356 13357 exit: 13358 SD_TRACE(SD_LOG_IO_RMMEDIA, SD_GET_UN(bp), 13359 "sd_mapblocksize_iodone: calling SD_NEXT_IODONE: buf:0x%p\n", bp); 13360 13361 SD_NEXT_IODONE(index, un, bp); 13362 } 13363 13364 13365 /* 13366 * Function: sd_checksum_iostart 13367 * 13368 * Description: A stub function for a layer that's currently not used. 13369 * For now just a placeholder. 13370 * 13371 * Context: Kernel thread context 13372 */ 13373 13374 static void 13375 sd_checksum_iostart(int index, struct sd_lun *un, struct buf *bp) 13376 { 13377 ASSERT(un != NULL); 13378 ASSERT(bp != NULL); 13379 ASSERT(!mutex_owned(SD_MUTEX(un))); 13380 SD_NEXT_IOSTART(index, un, bp); 13381 } 13382 13383 13384 /* 13385 * Function: sd_checksum_iodone 13386 * 13387 * Description: A stub function for a layer that's currently not used. 13388 * For now just a placeholder. 13389 * 13390 * Context: May be called under interrupt context 13391 */ 13392 13393 static void 13394 sd_checksum_iodone(int index, struct sd_lun *un, struct buf *bp) 13395 { 13396 ASSERT(un != NULL); 13397 ASSERT(bp != NULL); 13398 ASSERT(!mutex_owned(SD_MUTEX(un))); 13399 SD_NEXT_IODONE(index, un, bp); 13400 } 13401 13402 13403 /* 13404 * Function: sd_checksum_uscsi_iostart 13405 * 13406 * Description: A stub function for a layer that's currently not used. 13407 * For now just a placeholder. 13408 * 13409 * Context: Kernel thread context 13410 */ 13411 13412 static void 13413 sd_checksum_uscsi_iostart(int index, struct sd_lun *un, struct buf *bp) 13414 { 13415 ASSERT(un != NULL); 13416 ASSERT(bp != NULL); 13417 ASSERT(!mutex_owned(SD_MUTEX(un))); 13418 SD_NEXT_IOSTART(index, un, bp); 13419 } 13420 13421 13422 /* 13423 * Function: sd_checksum_uscsi_iodone 13424 * 13425 * Description: A stub function for a layer that's currently not used. 13426 * For now just a placeholder. 13427 * 13428 * Context: May be called under interrupt context 13429 */ 13430 13431 static void 13432 sd_checksum_uscsi_iodone(int index, struct sd_lun *un, struct buf *bp) 13433 { 13434 ASSERT(un != NULL); 13435 ASSERT(bp != NULL); 13436 ASSERT(!mutex_owned(SD_MUTEX(un))); 13437 SD_NEXT_IODONE(index, un, bp); 13438 } 13439 13440 13441 /* 13442 * Function: sd_pm_iostart 13443 * 13444 * Description: iostart-side routine for Power mangement. 13445 * 13446 * Context: Kernel thread context 13447 */ 13448 13449 static void 13450 sd_pm_iostart(int index, struct sd_lun *un, struct buf *bp) 13451 { 13452 ASSERT(un != NULL); 13453 ASSERT(bp != NULL); 13454 ASSERT(!mutex_owned(SD_MUTEX(un))); 13455 ASSERT(!mutex_owned(&un->un_pm_mutex)); 13456 13457 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iostart: entry\n"); 13458 13459 if (sd_pm_entry(un) != DDI_SUCCESS) { 13460 /* 13461 * Set up to return the failed buf back up the 'iodone' 13462 * side of the calling chain. 13463 */ 13464 bioerror(bp, EIO); 13465 bp->b_resid = bp->b_bcount; 13466 13467 SD_BEGIN_IODONE(index, un, bp); 13468 13469 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iostart: exit\n"); 13470 return; 13471 } 13472 13473 SD_NEXT_IOSTART(index, un, bp); 13474 13475 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iostart: exit\n"); 13476 } 13477 13478 13479 /* 13480 * Function: sd_pm_iodone 13481 * 13482 * Description: iodone-side routine for power mangement. 13483 * 13484 * Context: may be called from interrupt context 13485 */ 13486 13487 static void 13488 sd_pm_iodone(int index, struct sd_lun *un, struct buf *bp) 13489 { 13490 ASSERT(un != NULL); 13491 ASSERT(bp != NULL); 13492 ASSERT(!mutex_owned(&un->un_pm_mutex)); 13493 13494 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iodone: entry\n"); 13495 13496 /* 13497 * After attach the following flag is only read, so don't 13498 * take the penalty of acquiring a mutex for it. 13499 */ 13500 if (un->un_f_pm_is_enabled == TRUE) { 13501 sd_pm_exit(un); 13502 } 13503 13504 SD_NEXT_IODONE(index, un, bp); 13505 13506 SD_TRACE(SD_LOG_IO_PM, un, "sd_pm_iodone: exit\n"); 13507 } 13508 13509 13510 /* 13511 * Function: sd_core_iostart 13512 * 13513 * Description: Primary driver function for enqueuing buf(9S) structs from 13514 * the system and initiating IO to the target device 13515 * 13516 * Context: Kernel thread context. Can sleep. 13517 * 13518 * Assumptions: - The given xp->xb_blkno is absolute 13519 * (ie, relative to the start of the device). 13520 * - The IO is to be done using the native blocksize of 13521 * the device, as specified in un->un_tgt_blocksize. 13522 */ 13523 /* ARGSUSED */ 13524 static void 13525 sd_core_iostart(int index, struct sd_lun *un, struct buf *bp) 13526 { 13527 struct sd_xbuf *xp; 13528 13529 ASSERT(un != NULL); 13530 ASSERT(bp != NULL); 13531 ASSERT(!mutex_owned(SD_MUTEX(un))); 13532 ASSERT(bp->b_resid == 0); 13533 13534 SD_TRACE(SD_LOG_IO_CORE, un, "sd_core_iostart: entry: bp:0x%p\n", bp); 13535 13536 xp = SD_GET_XBUF(bp); 13537 ASSERT(xp != NULL); 13538 13539 mutex_enter(SD_MUTEX(un)); 13540 13541 /* 13542 * If we are currently in the failfast state, fail any new IO 13543 * that has B_FAILFAST set, then return. 13544 */ 13545 if ((bp->b_flags & B_FAILFAST) && 13546 (un->un_failfast_state == SD_FAILFAST_ACTIVE)) { 13547 mutex_exit(SD_MUTEX(un)); 13548 bioerror(bp, EIO); 13549 bp->b_resid = bp->b_bcount; 13550 SD_BEGIN_IODONE(index, un, bp); 13551 return; 13552 } 13553 13554 if (SD_IS_DIRECT_PRIORITY(xp)) { 13555 /* 13556 * Priority command -- transport it immediately. 13557 * 13558 * Note: We may want to assert that USCSI_DIAGNOSE is set, 13559 * because all direct priority commands should be associated 13560 * with error recovery actions which we don't want to retry. 13561 */ 13562 sd_start_cmds(un, bp); 13563 } else { 13564 /* 13565 * Normal command -- add it to the wait queue, then start 13566 * transporting commands from the wait queue. 13567 */ 13568 sd_add_buf_to_waitq(un, bp); 13569 SD_UPDATE_KSTATS(un, kstat_waitq_enter, bp); 13570 sd_start_cmds(un, NULL); 13571 } 13572 13573 mutex_exit(SD_MUTEX(un)); 13574 13575 SD_TRACE(SD_LOG_IO_CORE, un, "sd_core_iostart: exit: bp:0x%p\n", bp); 13576 } 13577 13578 13579 /* 13580 * Function: sd_init_cdb_limits 13581 * 13582 * Description: This is to handle scsi_pkt initialization differences 13583 * between the driver platforms. 13584 * 13585 * Legacy behaviors: 13586 * 13587 * If the block number or the sector count exceeds the 13588 * capabilities of a Group 0 command, shift over to a 13589 * Group 1 command. We don't blindly use Group 1 13590 * commands because a) some drives (CDC Wren IVs) get a 13591 * bit confused, and b) there is probably a fair amount 13592 * of speed difference for a target to receive and decode 13593 * a 10 byte command instead of a 6 byte command. 13594 * 13595 * The xfer time difference of 6 vs 10 byte CDBs is 13596 * still significant so this code is still worthwhile. 13597 * 10 byte CDBs are very inefficient with the fas HBA driver 13598 * and older disks. Each CDB byte took 1 usec with some 13599 * popular disks. 13600 * 13601 * Context: Must be called at attach time 13602 */ 13603 13604 static void 13605 sd_init_cdb_limits(struct sd_lun *un) 13606 { 13607 int hba_cdb_limit; 13608 13609 /* 13610 * Use CDB_GROUP1 commands for most devices except for 13611 * parallel SCSI fixed drives in which case we get better 13612 * performance using CDB_GROUP0 commands (where applicable). 13613 */ 13614 un->un_mincdb = SD_CDB_GROUP1; 13615 #if !defined(__fibre) 13616 if (!un->un_f_is_fibre && !un->un_f_cfg_is_atapi && !ISROD(un) && 13617 !un->un_f_has_removable_media) { 13618 un->un_mincdb = SD_CDB_GROUP0; 13619 } 13620 #endif 13621 13622 /* 13623 * Try to read the max-cdb-length supported by HBA. 13624 */ 13625 un->un_max_hba_cdb = scsi_ifgetcap(SD_ADDRESS(un), "max-cdb-length", 1); 13626 if (0 >= un->un_max_hba_cdb) { 13627 un->un_max_hba_cdb = CDB_GROUP4; 13628 hba_cdb_limit = SD_CDB_GROUP4; 13629 } else if (0 < un->un_max_hba_cdb && 13630 un->un_max_hba_cdb < CDB_GROUP1) { 13631 hba_cdb_limit = SD_CDB_GROUP0; 13632 } else if (CDB_GROUP1 <= un->un_max_hba_cdb && 13633 un->un_max_hba_cdb < CDB_GROUP5) { 13634 hba_cdb_limit = SD_CDB_GROUP1; 13635 } else if (CDB_GROUP5 <= un->un_max_hba_cdb && 13636 un->un_max_hba_cdb < CDB_GROUP4) { 13637 hba_cdb_limit = SD_CDB_GROUP5; 13638 } else { 13639 hba_cdb_limit = SD_CDB_GROUP4; 13640 } 13641 13642 /* 13643 * Use CDB_GROUP5 commands for removable devices. Use CDB_GROUP4 13644 * commands for fixed disks unless we are building for a 32 bit 13645 * kernel. 13646 */ 13647 #ifdef _LP64 13648 un->un_maxcdb = (un->un_f_has_removable_media) ? SD_CDB_GROUP5 : 13649 min(hba_cdb_limit, SD_CDB_GROUP4); 13650 #else 13651 un->un_maxcdb = (un->un_f_has_removable_media) ? SD_CDB_GROUP5 : 13652 min(hba_cdb_limit, SD_CDB_GROUP1); 13653 #endif 13654 13655 un->un_status_len = (int)((un->un_f_arq_enabled == TRUE) 13656 ? sizeof (struct scsi_arq_status) : 1); 13657 if (!ISCD(un)) 13658 un->un_cmd_timeout = (ushort_t)sd_io_time; 13659 un->un_uscsi_timeout = ((ISCD(un)) ? 2 : 1) * un->un_cmd_timeout; 13660 } 13661 13662 13663 /* 13664 * Function: sd_initpkt_for_buf 13665 * 13666 * Description: Allocate and initialize for transport a scsi_pkt struct, 13667 * based upon the info specified in the given buf struct. 13668 * 13669 * Assumes the xb_blkno in the request is absolute (ie, 13670 * relative to the start of the device (NOT partition!). 13671 * Also assumes that the request is using the native block 13672 * size of the device (as returned by the READ CAPACITY 13673 * command). 13674 * 13675 * Return Code: SD_PKT_ALLOC_SUCCESS 13676 * SD_PKT_ALLOC_FAILURE 13677 * SD_PKT_ALLOC_FAILURE_NO_DMA 13678 * SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL 13679 * 13680 * Context: Kernel thread and may be called from software interrupt context 13681 * as part of a sdrunout callback. This function may not block or 13682 * call routines that block 13683 */ 13684 13685 static int 13686 sd_initpkt_for_buf(struct buf *bp, struct scsi_pkt **pktpp) 13687 { 13688 struct sd_xbuf *xp; 13689 struct scsi_pkt *pktp = NULL; 13690 struct sd_lun *un; 13691 size_t blockcount; 13692 daddr_t startblock; 13693 int rval; 13694 int cmd_flags; 13695 13696 ASSERT(bp != NULL); 13697 ASSERT(pktpp != NULL); 13698 xp = SD_GET_XBUF(bp); 13699 ASSERT(xp != NULL); 13700 un = SD_GET_UN(bp); 13701 ASSERT(un != NULL); 13702 ASSERT(mutex_owned(SD_MUTEX(un))); 13703 ASSERT(bp->b_resid == 0); 13704 13705 SD_TRACE(SD_LOG_IO_CORE, un, 13706 "sd_initpkt_for_buf: entry: buf:0x%p\n", bp); 13707 13708 mutex_exit(SD_MUTEX(un)); 13709 13710 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */ 13711 if (xp->xb_pkt_flags & SD_XB_DMA_FREED) { 13712 /* 13713 * Already have a scsi_pkt -- just need DMA resources. 13714 * We must recompute the CDB in case the mapping returns 13715 * a nonzero pkt_resid. 13716 * Note: if this is a portion of a PKT_DMA_PARTIAL transfer 13717 * that is being retried, the unmap/remap of the DMA resouces 13718 * will result in the entire transfer starting over again 13719 * from the very first block. 13720 */ 13721 ASSERT(xp->xb_pktp != NULL); 13722 pktp = xp->xb_pktp; 13723 } else { 13724 pktp = NULL; 13725 } 13726 #endif /* __i386 || __amd64 */ 13727 13728 startblock = xp->xb_blkno; /* Absolute block num. */ 13729 blockcount = SD_BYTES2TGTBLOCKS(un, bp->b_bcount); 13730 13731 cmd_flags = un->un_pkt_flags | (xp->xb_pkt_flags & SD_XB_INITPKT_MASK); 13732 13733 /* 13734 * sd_setup_rw_pkt will determine the appropriate CDB group to use, 13735 * call scsi_init_pkt, and build the CDB. 13736 */ 13737 rval = sd_setup_rw_pkt(un, &pktp, bp, 13738 cmd_flags, sdrunout, (caddr_t)un, 13739 startblock, blockcount); 13740 13741 if (rval == 0) { 13742 /* 13743 * Success. 13744 * 13745 * If partial DMA is being used and required for this transfer. 13746 * set it up here. 13747 */ 13748 if ((un->un_pkt_flags & PKT_DMA_PARTIAL) != 0 && 13749 (pktp->pkt_resid != 0)) { 13750 13751 /* 13752 * Save the CDB length and pkt_resid for the 13753 * next xfer 13754 */ 13755 xp->xb_dma_resid = pktp->pkt_resid; 13756 13757 /* rezero resid */ 13758 pktp->pkt_resid = 0; 13759 13760 } else { 13761 xp->xb_dma_resid = 0; 13762 } 13763 13764 pktp->pkt_flags = un->un_tagflags; 13765 pktp->pkt_time = un->un_cmd_timeout; 13766 pktp->pkt_comp = sdintr; 13767 13768 pktp->pkt_private = bp; 13769 *pktpp = pktp; 13770 13771 SD_TRACE(SD_LOG_IO_CORE, un, 13772 "sd_initpkt_for_buf: exit: buf:0x%p\n", bp); 13773 13774 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */ 13775 xp->xb_pkt_flags &= ~SD_XB_DMA_FREED; 13776 #endif 13777 13778 mutex_enter(SD_MUTEX(un)); 13779 return (SD_PKT_ALLOC_SUCCESS); 13780 13781 } 13782 13783 /* 13784 * SD_PKT_ALLOC_FAILURE is the only expected failure code 13785 * from sd_setup_rw_pkt. 13786 */ 13787 ASSERT(rval == SD_PKT_ALLOC_FAILURE); 13788 13789 if (rval == SD_PKT_ALLOC_FAILURE) { 13790 *pktpp = NULL; 13791 /* 13792 * Set the driver state to RWAIT to indicate the driver 13793 * is waiting on resource allocations. The driver will not 13794 * suspend, pm_suspend, or detatch while the state is RWAIT. 13795 */ 13796 mutex_enter(SD_MUTEX(un)); 13797 New_state(un, SD_STATE_RWAIT); 13798 13799 SD_ERROR(SD_LOG_IO_CORE, un, 13800 "sd_initpkt_for_buf: No pktp. exit bp:0x%p\n", bp); 13801 13802 if ((bp->b_flags & B_ERROR) != 0) { 13803 return (SD_PKT_ALLOC_FAILURE_NO_DMA); 13804 } 13805 return (SD_PKT_ALLOC_FAILURE); 13806 } else { 13807 /* 13808 * PKT_ALLOC_FAILURE_CDB_TOO_SMALL 13809 * 13810 * This should never happen. Maybe someone messed with the 13811 * kernel's minphys? 13812 */ 13813 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 13814 "Request rejected: too large for CDB: " 13815 "lba:0x%08lx len:0x%08lx\n", startblock, blockcount); 13816 SD_ERROR(SD_LOG_IO_CORE, un, 13817 "sd_initpkt_for_buf: No cp. exit bp:0x%p\n", bp); 13818 mutex_enter(SD_MUTEX(un)); 13819 return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL); 13820 13821 } 13822 } 13823 13824 13825 /* 13826 * Function: sd_destroypkt_for_buf 13827 * 13828 * Description: Free the scsi_pkt(9S) for the given bp (buf IO processing). 13829 * 13830 * Context: Kernel thread or interrupt context 13831 */ 13832 13833 static void 13834 sd_destroypkt_for_buf(struct buf *bp) 13835 { 13836 ASSERT(bp != NULL); 13837 ASSERT(SD_GET_UN(bp) != NULL); 13838 13839 SD_TRACE(SD_LOG_IO_CORE, SD_GET_UN(bp), 13840 "sd_destroypkt_for_buf: entry: buf:0x%p\n", bp); 13841 13842 ASSERT(SD_GET_PKTP(bp) != NULL); 13843 scsi_destroy_pkt(SD_GET_PKTP(bp)); 13844 13845 SD_TRACE(SD_LOG_IO_CORE, SD_GET_UN(bp), 13846 "sd_destroypkt_for_buf: exit: buf:0x%p\n", bp); 13847 } 13848 13849 /* 13850 * Function: sd_setup_rw_pkt 13851 * 13852 * Description: Determines appropriate CDB group for the requested LBA 13853 * and transfer length, calls scsi_init_pkt, and builds 13854 * the CDB. Do not use for partial DMA transfers except 13855 * for the initial transfer since the CDB size must 13856 * remain constant. 13857 * 13858 * Context: Kernel thread and may be called from software interrupt 13859 * context as part of a sdrunout callback. This function may not 13860 * block or call routines that block 13861 */ 13862 13863 13864 int 13865 sd_setup_rw_pkt(struct sd_lun *un, 13866 struct scsi_pkt **pktpp, struct buf *bp, int flags, 13867 int (*callback)(caddr_t), caddr_t callback_arg, 13868 diskaddr_t lba, uint32_t blockcount) 13869 { 13870 struct scsi_pkt *return_pktp; 13871 union scsi_cdb *cdbp; 13872 struct sd_cdbinfo *cp = NULL; 13873 int i; 13874 13875 /* 13876 * See which size CDB to use, based upon the request. 13877 */ 13878 for (i = un->un_mincdb; i <= un->un_maxcdb; i++) { 13879 13880 /* 13881 * Check lba and block count against sd_cdbtab limits. 13882 * In the partial DMA case, we have to use the same size 13883 * CDB for all the transfers. Check lba + blockcount 13884 * against the max LBA so we know that segment of the 13885 * transfer can use the CDB we select. 13886 */ 13887 if ((lba + blockcount - 1 <= sd_cdbtab[i].sc_maxlba) && 13888 (blockcount <= sd_cdbtab[i].sc_maxlen)) { 13889 13890 /* 13891 * The command will fit into the CDB type 13892 * specified by sd_cdbtab[i]. 13893 */ 13894 cp = sd_cdbtab + i; 13895 13896 /* 13897 * Call scsi_init_pkt so we can fill in the 13898 * CDB. 13899 */ 13900 return_pktp = scsi_init_pkt(SD_ADDRESS(un), *pktpp, 13901 bp, cp->sc_grpcode, un->un_status_len, 0, 13902 flags, callback, callback_arg); 13903 13904 if (return_pktp != NULL) { 13905 13906 /* 13907 * Return new value of pkt 13908 */ 13909 *pktpp = return_pktp; 13910 13911 /* 13912 * To be safe, zero the CDB insuring there is 13913 * no leftover data from a previous command. 13914 */ 13915 bzero(return_pktp->pkt_cdbp, cp->sc_grpcode); 13916 13917 /* 13918 * Handle partial DMA mapping 13919 */ 13920 if (return_pktp->pkt_resid != 0) { 13921 13922 /* 13923 * Not going to xfer as many blocks as 13924 * originally expected 13925 */ 13926 blockcount -= 13927 SD_BYTES2TGTBLOCKS(un, 13928 return_pktp->pkt_resid); 13929 } 13930 13931 cdbp = (union scsi_cdb *)return_pktp->pkt_cdbp; 13932 13933 /* 13934 * Set command byte based on the CDB 13935 * type we matched. 13936 */ 13937 cdbp->scc_cmd = cp->sc_grpmask | 13938 ((bp->b_flags & B_READ) ? 13939 SCMD_READ : SCMD_WRITE); 13940 13941 SD_FILL_SCSI1_LUN(un, return_pktp); 13942 13943 /* 13944 * Fill in LBA and length 13945 */ 13946 ASSERT((cp->sc_grpcode == CDB_GROUP1) || 13947 (cp->sc_grpcode == CDB_GROUP4) || 13948 (cp->sc_grpcode == CDB_GROUP0) || 13949 (cp->sc_grpcode == CDB_GROUP5)); 13950 13951 if (cp->sc_grpcode == CDB_GROUP1) { 13952 FORMG1ADDR(cdbp, lba); 13953 FORMG1COUNT(cdbp, blockcount); 13954 return (0); 13955 } else if (cp->sc_grpcode == CDB_GROUP4) { 13956 FORMG4LONGADDR(cdbp, lba); 13957 FORMG4COUNT(cdbp, blockcount); 13958 return (0); 13959 } else if (cp->sc_grpcode == CDB_GROUP0) { 13960 FORMG0ADDR(cdbp, lba); 13961 FORMG0COUNT(cdbp, blockcount); 13962 return (0); 13963 } else if (cp->sc_grpcode == CDB_GROUP5) { 13964 FORMG5ADDR(cdbp, lba); 13965 FORMG5COUNT(cdbp, blockcount); 13966 return (0); 13967 } 13968 13969 /* 13970 * It should be impossible to not match one 13971 * of the CDB types above, so we should never 13972 * reach this point. Set the CDB command byte 13973 * to test-unit-ready to avoid writing 13974 * to somewhere we don't intend. 13975 */ 13976 cdbp->scc_cmd = SCMD_TEST_UNIT_READY; 13977 return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL); 13978 } else { 13979 /* 13980 * Couldn't get scsi_pkt 13981 */ 13982 return (SD_PKT_ALLOC_FAILURE); 13983 } 13984 } 13985 } 13986 13987 /* 13988 * None of the available CDB types were suitable. This really 13989 * should never happen: on a 64 bit system we support 13990 * READ16/WRITE16 which will hold an entire 64 bit disk address 13991 * and on a 32 bit system we will refuse to bind to a device 13992 * larger than 2TB so addresses will never be larger than 32 bits. 13993 */ 13994 return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL); 13995 } 13996 13997 /* 13998 * Function: sd_setup_next_rw_pkt 13999 * 14000 * Description: Setup packet for partial DMA transfers, except for the 14001 * initial transfer. sd_setup_rw_pkt should be used for 14002 * the initial transfer. 14003 * 14004 * Context: Kernel thread and may be called from interrupt context. 14005 */ 14006 14007 int 14008 sd_setup_next_rw_pkt(struct sd_lun *un, 14009 struct scsi_pkt *pktp, struct buf *bp, 14010 diskaddr_t lba, uint32_t blockcount) 14011 { 14012 uchar_t com; 14013 union scsi_cdb *cdbp; 14014 uchar_t cdb_group_id; 14015 14016 ASSERT(pktp != NULL); 14017 ASSERT(pktp->pkt_cdbp != NULL); 14018 14019 cdbp = (union scsi_cdb *)pktp->pkt_cdbp; 14020 com = cdbp->scc_cmd; 14021 cdb_group_id = CDB_GROUPID(com); 14022 14023 ASSERT((cdb_group_id == CDB_GROUPID_0) || 14024 (cdb_group_id == CDB_GROUPID_1) || 14025 (cdb_group_id == CDB_GROUPID_4) || 14026 (cdb_group_id == CDB_GROUPID_5)); 14027 14028 /* 14029 * Move pkt to the next portion of the xfer. 14030 * func is NULL_FUNC so we do not have to release 14031 * the disk mutex here. 14032 */ 14033 if (scsi_init_pkt(SD_ADDRESS(un), pktp, bp, 0, 0, 0, 0, 14034 NULL_FUNC, NULL) == pktp) { 14035 /* Success. Handle partial DMA */ 14036 if (pktp->pkt_resid != 0) { 14037 blockcount -= 14038 SD_BYTES2TGTBLOCKS(un, pktp->pkt_resid); 14039 } 14040 14041 cdbp->scc_cmd = com; 14042 SD_FILL_SCSI1_LUN(un, pktp); 14043 if (cdb_group_id == CDB_GROUPID_1) { 14044 FORMG1ADDR(cdbp, lba); 14045 FORMG1COUNT(cdbp, blockcount); 14046 return (0); 14047 } else if (cdb_group_id == CDB_GROUPID_4) { 14048 FORMG4LONGADDR(cdbp, lba); 14049 FORMG4COUNT(cdbp, blockcount); 14050 return (0); 14051 } else if (cdb_group_id == CDB_GROUPID_0) { 14052 FORMG0ADDR(cdbp, lba); 14053 FORMG0COUNT(cdbp, blockcount); 14054 return (0); 14055 } else if (cdb_group_id == CDB_GROUPID_5) { 14056 FORMG5ADDR(cdbp, lba); 14057 FORMG5COUNT(cdbp, blockcount); 14058 return (0); 14059 } 14060 14061 /* Unreachable */ 14062 return (SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL); 14063 } 14064 14065 /* 14066 * Error setting up next portion of cmd transfer. 14067 * Something is definitely very wrong and this 14068 * should not happen. 14069 */ 14070 return (SD_PKT_ALLOC_FAILURE); 14071 } 14072 14073 /* 14074 * Function: sd_initpkt_for_uscsi 14075 * 14076 * Description: Allocate and initialize for transport a scsi_pkt struct, 14077 * based upon the info specified in the given uscsi_cmd struct. 14078 * 14079 * Return Code: SD_PKT_ALLOC_SUCCESS 14080 * SD_PKT_ALLOC_FAILURE 14081 * SD_PKT_ALLOC_FAILURE_NO_DMA 14082 * SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL 14083 * 14084 * Context: Kernel thread and may be called from software interrupt context 14085 * as part of a sdrunout callback. This function may not block or 14086 * call routines that block 14087 */ 14088 14089 static int 14090 sd_initpkt_for_uscsi(struct buf *bp, struct scsi_pkt **pktpp) 14091 { 14092 struct uscsi_cmd *uscmd; 14093 struct sd_xbuf *xp; 14094 struct scsi_pkt *pktp; 14095 struct sd_lun *un; 14096 uint32_t flags = 0; 14097 14098 ASSERT(bp != NULL); 14099 ASSERT(pktpp != NULL); 14100 xp = SD_GET_XBUF(bp); 14101 ASSERT(xp != NULL); 14102 un = SD_GET_UN(bp); 14103 ASSERT(un != NULL); 14104 ASSERT(mutex_owned(SD_MUTEX(un))); 14105 14106 /* The pointer to the uscsi_cmd struct is expected in xb_pktinfo */ 14107 uscmd = (struct uscsi_cmd *)xp->xb_pktinfo; 14108 ASSERT(uscmd != NULL); 14109 14110 SD_TRACE(SD_LOG_IO_CORE, un, 14111 "sd_initpkt_for_uscsi: entry: buf:0x%p\n", bp); 14112 14113 /* 14114 * Allocate the scsi_pkt for the command. 14115 * Note: If PKT_DMA_PARTIAL flag is set, scsi_vhci binds a path 14116 * during scsi_init_pkt time and will continue to use the 14117 * same path as long as the same scsi_pkt is used without 14118 * intervening scsi_dma_free(). Since uscsi command does 14119 * not call scsi_dmafree() before retry failed command, it 14120 * is necessary to make sure PKT_DMA_PARTIAL flag is NOT 14121 * set such that scsi_vhci can use other available path for 14122 * retry. Besides, ucsci command does not allow DMA breakup, 14123 * so there is no need to set PKT_DMA_PARTIAL flag. 14124 */ 14125 if (uscmd->uscsi_rqlen > SENSE_LENGTH) { 14126 pktp = scsi_init_pkt(SD_ADDRESS(un), NULL, 14127 ((bp->b_bcount != 0) ? bp : NULL), uscmd->uscsi_cdblen, 14128 ((int)(uscmd->uscsi_rqlen) + sizeof (struct scsi_arq_status) 14129 - sizeof (struct scsi_extended_sense)), 0, 14130 (un->un_pkt_flags & ~PKT_DMA_PARTIAL) | PKT_XARQ, 14131 sdrunout, (caddr_t)un); 14132 } else { 14133 pktp = scsi_init_pkt(SD_ADDRESS(un), NULL, 14134 ((bp->b_bcount != 0) ? bp : NULL), uscmd->uscsi_cdblen, 14135 sizeof (struct scsi_arq_status), 0, 14136 (un->un_pkt_flags & ~PKT_DMA_PARTIAL), 14137 sdrunout, (caddr_t)un); 14138 } 14139 14140 if (pktp == NULL) { 14141 *pktpp = NULL; 14142 /* 14143 * Set the driver state to RWAIT to indicate the driver 14144 * is waiting on resource allocations. The driver will not 14145 * suspend, pm_suspend, or detatch while the state is RWAIT. 14146 */ 14147 New_state(un, SD_STATE_RWAIT); 14148 14149 SD_ERROR(SD_LOG_IO_CORE, un, 14150 "sd_initpkt_for_uscsi: No pktp. exit bp:0x%p\n", bp); 14151 14152 if ((bp->b_flags & B_ERROR) != 0) { 14153 return (SD_PKT_ALLOC_FAILURE_NO_DMA); 14154 } 14155 return (SD_PKT_ALLOC_FAILURE); 14156 } 14157 14158 /* 14159 * We do not do DMA breakup for USCSI commands, so return failure 14160 * here if all the needed DMA resources were not allocated. 14161 */ 14162 if ((un->un_pkt_flags & PKT_DMA_PARTIAL) && 14163 (bp->b_bcount != 0) && (pktp->pkt_resid != 0)) { 14164 scsi_destroy_pkt(pktp); 14165 SD_ERROR(SD_LOG_IO_CORE, un, "sd_initpkt_for_uscsi: " 14166 "No partial DMA for USCSI. exit: buf:0x%p\n", bp); 14167 return (SD_PKT_ALLOC_FAILURE_PKT_TOO_SMALL); 14168 } 14169 14170 /* Init the cdb from the given uscsi struct */ 14171 (void) scsi_setup_cdb((union scsi_cdb *)pktp->pkt_cdbp, 14172 uscmd->uscsi_cdb[0], 0, 0, 0); 14173 14174 SD_FILL_SCSI1_LUN(un, pktp); 14175 14176 /* 14177 * Set up the optional USCSI flags. See the uscsi (7I) man page 14178 * for listing of the supported flags. 14179 */ 14180 14181 if (uscmd->uscsi_flags & USCSI_SILENT) { 14182 flags |= FLAG_SILENT; 14183 } 14184 14185 if (uscmd->uscsi_flags & USCSI_DIAGNOSE) { 14186 flags |= FLAG_DIAGNOSE; 14187 } 14188 14189 if (uscmd->uscsi_flags & USCSI_ISOLATE) { 14190 flags |= FLAG_ISOLATE; 14191 } 14192 14193 if (un->un_f_is_fibre == FALSE) { 14194 if (uscmd->uscsi_flags & USCSI_RENEGOT) { 14195 flags |= FLAG_RENEGOTIATE_WIDE_SYNC; 14196 } 14197 } 14198 14199 /* 14200 * Set the pkt flags here so we save time later. 14201 * Note: These flags are NOT in the uscsi man page!!! 14202 */ 14203 if (uscmd->uscsi_flags & USCSI_HEAD) { 14204 flags |= FLAG_HEAD; 14205 } 14206 14207 if (uscmd->uscsi_flags & USCSI_NOINTR) { 14208 flags |= FLAG_NOINTR; 14209 } 14210 14211 /* 14212 * For tagged queueing, things get a bit complicated. 14213 * Check first for head of queue and last for ordered queue. 14214 * If neither head nor order, use the default driver tag flags. 14215 */ 14216 if ((uscmd->uscsi_flags & USCSI_NOTAG) == 0) { 14217 if (uscmd->uscsi_flags & USCSI_HTAG) { 14218 flags |= FLAG_HTAG; 14219 } else if (uscmd->uscsi_flags & USCSI_OTAG) { 14220 flags |= FLAG_OTAG; 14221 } else { 14222 flags |= un->un_tagflags & FLAG_TAGMASK; 14223 } 14224 } 14225 14226 if (uscmd->uscsi_flags & USCSI_NODISCON) { 14227 flags = (flags & ~FLAG_TAGMASK) | FLAG_NODISCON; 14228 } 14229 14230 pktp->pkt_flags = flags; 14231 14232 /* Transfer uscsi information to scsi_pkt */ 14233 (void) scsi_uscsi_pktinit(uscmd, pktp); 14234 14235 /* Copy the caller's CDB into the pkt... */ 14236 bcopy(uscmd->uscsi_cdb, pktp->pkt_cdbp, uscmd->uscsi_cdblen); 14237 14238 if (uscmd->uscsi_timeout == 0) { 14239 pktp->pkt_time = un->un_uscsi_timeout; 14240 } else { 14241 pktp->pkt_time = uscmd->uscsi_timeout; 14242 } 14243 14244 /* need it later to identify USCSI request in sdintr */ 14245 xp->xb_pkt_flags |= SD_XB_USCSICMD; 14246 14247 xp->xb_sense_resid = uscmd->uscsi_rqresid; 14248 14249 pktp->pkt_private = bp; 14250 pktp->pkt_comp = sdintr; 14251 *pktpp = pktp; 14252 14253 SD_TRACE(SD_LOG_IO_CORE, un, 14254 "sd_initpkt_for_uscsi: exit: buf:0x%p\n", bp); 14255 14256 return (SD_PKT_ALLOC_SUCCESS); 14257 } 14258 14259 14260 /* 14261 * Function: sd_destroypkt_for_uscsi 14262 * 14263 * Description: Free the scsi_pkt(9S) struct for the given bp, for uscsi 14264 * IOs.. Also saves relevant info into the associated uscsi_cmd 14265 * struct. 14266 * 14267 * Context: May be called under interrupt context 14268 */ 14269 14270 static void 14271 sd_destroypkt_for_uscsi(struct buf *bp) 14272 { 14273 struct uscsi_cmd *uscmd; 14274 struct sd_xbuf *xp; 14275 struct scsi_pkt *pktp; 14276 struct sd_lun *un; 14277 struct sd_uscsi_info *suip; 14278 14279 ASSERT(bp != NULL); 14280 xp = SD_GET_XBUF(bp); 14281 ASSERT(xp != NULL); 14282 un = SD_GET_UN(bp); 14283 ASSERT(un != NULL); 14284 ASSERT(!mutex_owned(SD_MUTEX(un))); 14285 pktp = SD_GET_PKTP(bp); 14286 ASSERT(pktp != NULL); 14287 14288 SD_TRACE(SD_LOG_IO_CORE, un, 14289 "sd_destroypkt_for_uscsi: entry: buf:0x%p\n", bp); 14290 14291 /* The pointer to the uscsi_cmd struct is expected in xb_pktinfo */ 14292 uscmd = (struct uscsi_cmd *)xp->xb_pktinfo; 14293 ASSERT(uscmd != NULL); 14294 14295 /* Save the status and the residual into the uscsi_cmd struct */ 14296 uscmd->uscsi_status = ((*(pktp)->pkt_scbp) & STATUS_MASK); 14297 uscmd->uscsi_resid = bp->b_resid; 14298 14299 /* Transfer scsi_pkt information to uscsi */ 14300 (void) scsi_uscsi_pktfini(pktp, uscmd); 14301 14302 /* 14303 * If enabled, copy any saved sense data into the area specified 14304 * by the uscsi command. 14305 */ 14306 if (((uscmd->uscsi_flags & USCSI_RQENABLE) != 0) && 14307 (uscmd->uscsi_rqlen != 0) && (uscmd->uscsi_rqbuf != NULL)) { 14308 /* 14309 * Note: uscmd->uscsi_rqbuf should always point to a buffer 14310 * at least SENSE_LENGTH bytes in size (see sd_send_scsi_cmd()) 14311 */ 14312 uscmd->uscsi_rqstatus = xp->xb_sense_status; 14313 uscmd->uscsi_rqresid = xp->xb_sense_resid; 14314 if (uscmd->uscsi_rqlen > SENSE_LENGTH) { 14315 bcopy(xp->xb_sense_data, uscmd->uscsi_rqbuf, 14316 MAX_SENSE_LENGTH); 14317 } else { 14318 bcopy(xp->xb_sense_data, uscmd->uscsi_rqbuf, 14319 SENSE_LENGTH); 14320 } 14321 } 14322 /* 14323 * The following assignments are for SCSI FMA. 14324 */ 14325 ASSERT(xp->xb_private != NULL); 14326 suip = (struct sd_uscsi_info *)xp->xb_private; 14327 suip->ui_pkt_reason = pktp->pkt_reason; 14328 suip->ui_pkt_state = pktp->pkt_state; 14329 suip->ui_pkt_statistics = pktp->pkt_statistics; 14330 suip->ui_lba = (uint64_t)SD_GET_BLKNO(bp); 14331 14332 /* We are done with the scsi_pkt; free it now */ 14333 ASSERT(SD_GET_PKTP(bp) != NULL); 14334 scsi_destroy_pkt(SD_GET_PKTP(bp)); 14335 14336 SD_TRACE(SD_LOG_IO_CORE, un, 14337 "sd_destroypkt_for_uscsi: exit: buf:0x%p\n", bp); 14338 } 14339 14340 14341 /* 14342 * Function: sd_bioclone_alloc 14343 * 14344 * Description: Allocate a buf(9S) and init it as per the given buf 14345 * and the various arguments. The associated sd_xbuf 14346 * struct is (nearly) duplicated. The struct buf *bp 14347 * argument is saved in new_xp->xb_private. 14348 * 14349 * Arguments: bp - ptr the the buf(9S) to be "shadowed" 14350 * datalen - size of data area for the shadow bp 14351 * blkno - starting LBA 14352 * func - function pointer for b_iodone in the shadow buf. (May 14353 * be NULL if none.) 14354 * 14355 * Return Code: Pointer to allocates buf(9S) struct 14356 * 14357 * Context: Can sleep. 14358 */ 14359 14360 static struct buf * 14361 sd_bioclone_alloc(struct buf *bp, size_t datalen, 14362 daddr_t blkno, int (*func)(struct buf *)) 14363 { 14364 struct sd_lun *un; 14365 struct sd_xbuf *xp; 14366 struct sd_xbuf *new_xp; 14367 struct buf *new_bp; 14368 14369 ASSERT(bp != NULL); 14370 xp = SD_GET_XBUF(bp); 14371 ASSERT(xp != NULL); 14372 un = SD_GET_UN(bp); 14373 ASSERT(un != NULL); 14374 ASSERT(!mutex_owned(SD_MUTEX(un))); 14375 14376 new_bp = bioclone(bp, 0, datalen, SD_GET_DEV(un), blkno, func, 14377 NULL, KM_SLEEP); 14378 14379 new_bp->b_lblkno = blkno; 14380 14381 /* 14382 * Allocate an xbuf for the shadow bp and copy the contents of the 14383 * original xbuf into it. 14384 */ 14385 new_xp = kmem_alloc(sizeof (struct sd_xbuf), KM_SLEEP); 14386 bcopy(xp, new_xp, sizeof (struct sd_xbuf)); 14387 14388 /* 14389 * The given bp is automatically saved in the xb_private member 14390 * of the new xbuf. Callers are allowed to depend on this. 14391 */ 14392 new_xp->xb_private = bp; 14393 14394 new_bp->b_private = new_xp; 14395 14396 return (new_bp); 14397 } 14398 14399 /* 14400 * Function: sd_shadow_buf_alloc 14401 * 14402 * Description: Allocate a buf(9S) and init it as per the given buf 14403 * and the various arguments. The associated sd_xbuf 14404 * struct is (nearly) duplicated. The struct buf *bp 14405 * argument is saved in new_xp->xb_private. 14406 * 14407 * Arguments: bp - ptr the the buf(9S) to be "shadowed" 14408 * datalen - size of data area for the shadow bp 14409 * bflags - B_READ or B_WRITE (pseudo flag) 14410 * blkno - starting LBA 14411 * func - function pointer for b_iodone in the shadow buf. (May 14412 * be NULL if none.) 14413 * 14414 * Return Code: Pointer to allocates buf(9S) struct 14415 * 14416 * Context: Can sleep. 14417 */ 14418 14419 static struct buf * 14420 sd_shadow_buf_alloc(struct buf *bp, size_t datalen, uint_t bflags, 14421 daddr_t blkno, int (*func)(struct buf *)) 14422 { 14423 struct sd_lun *un; 14424 struct sd_xbuf *xp; 14425 struct sd_xbuf *new_xp; 14426 struct buf *new_bp; 14427 14428 ASSERT(bp != NULL); 14429 xp = SD_GET_XBUF(bp); 14430 ASSERT(xp != NULL); 14431 un = SD_GET_UN(bp); 14432 ASSERT(un != NULL); 14433 ASSERT(!mutex_owned(SD_MUTEX(un))); 14434 14435 if (bp->b_flags & (B_PAGEIO | B_PHYS)) { 14436 bp_mapin(bp); 14437 } 14438 14439 bflags &= (B_READ | B_WRITE); 14440 #if defined(__i386) || defined(__amd64) 14441 new_bp = getrbuf(KM_SLEEP); 14442 new_bp->b_un.b_addr = kmem_zalloc(datalen, KM_SLEEP); 14443 new_bp->b_bcount = datalen; 14444 new_bp->b_flags = bflags | 14445 (bp->b_flags & ~(B_PAGEIO | B_PHYS | B_REMAPPED | B_SHADOW)); 14446 #else 14447 new_bp = scsi_alloc_consistent_buf(SD_ADDRESS(un), NULL, 14448 datalen, bflags, SLEEP_FUNC, NULL); 14449 #endif 14450 new_bp->av_forw = NULL; 14451 new_bp->av_back = NULL; 14452 new_bp->b_dev = bp->b_dev; 14453 new_bp->b_blkno = blkno; 14454 new_bp->b_iodone = func; 14455 new_bp->b_edev = bp->b_edev; 14456 new_bp->b_resid = 0; 14457 14458 /* We need to preserve the B_FAILFAST flag */ 14459 if (bp->b_flags & B_FAILFAST) { 14460 new_bp->b_flags |= B_FAILFAST; 14461 } 14462 14463 /* 14464 * Allocate an xbuf for the shadow bp and copy the contents of the 14465 * original xbuf into it. 14466 */ 14467 new_xp = kmem_alloc(sizeof (struct sd_xbuf), KM_SLEEP); 14468 bcopy(xp, new_xp, sizeof (struct sd_xbuf)); 14469 14470 /* Need later to copy data between the shadow buf & original buf! */ 14471 new_xp->xb_pkt_flags |= PKT_CONSISTENT; 14472 14473 /* 14474 * The given bp is automatically saved in the xb_private member 14475 * of the new xbuf. Callers are allowed to depend on this. 14476 */ 14477 new_xp->xb_private = bp; 14478 14479 new_bp->b_private = new_xp; 14480 14481 return (new_bp); 14482 } 14483 14484 /* 14485 * Function: sd_bioclone_free 14486 * 14487 * Description: Deallocate a buf(9S) that was used for 'shadow' IO operations 14488 * in the larger than partition operation. 14489 * 14490 * Context: May be called under interrupt context 14491 */ 14492 14493 static void 14494 sd_bioclone_free(struct buf *bp) 14495 { 14496 struct sd_xbuf *xp; 14497 14498 ASSERT(bp != NULL); 14499 xp = SD_GET_XBUF(bp); 14500 ASSERT(xp != NULL); 14501 14502 /* 14503 * Call bp_mapout() before freeing the buf, in case a lower 14504 * layer or HBA had done a bp_mapin(). we must do this here 14505 * as we are the "originator" of the shadow buf. 14506 */ 14507 bp_mapout(bp); 14508 14509 /* 14510 * Null out b_iodone before freeing the bp, to ensure that the driver 14511 * never gets confused by a stale value in this field. (Just a little 14512 * extra defensiveness here.) 14513 */ 14514 bp->b_iodone = NULL; 14515 14516 freerbuf(bp); 14517 14518 kmem_free(xp, sizeof (struct sd_xbuf)); 14519 } 14520 14521 /* 14522 * Function: sd_shadow_buf_free 14523 * 14524 * Description: Deallocate a buf(9S) that was used for 'shadow' IO operations. 14525 * 14526 * Context: May be called under interrupt context 14527 */ 14528 14529 static void 14530 sd_shadow_buf_free(struct buf *bp) 14531 { 14532 struct sd_xbuf *xp; 14533 14534 ASSERT(bp != NULL); 14535 xp = SD_GET_XBUF(bp); 14536 ASSERT(xp != NULL); 14537 14538 #if defined(__sparc) 14539 /* 14540 * Call bp_mapout() before freeing the buf, in case a lower 14541 * layer or HBA had done a bp_mapin(). we must do this here 14542 * as we are the "originator" of the shadow buf. 14543 */ 14544 bp_mapout(bp); 14545 #endif 14546 14547 /* 14548 * Null out b_iodone before freeing the bp, to ensure that the driver 14549 * never gets confused by a stale value in this field. (Just a little 14550 * extra defensiveness here.) 14551 */ 14552 bp->b_iodone = NULL; 14553 14554 #if defined(__i386) || defined(__amd64) 14555 kmem_free(bp->b_un.b_addr, bp->b_bcount); 14556 freerbuf(bp); 14557 #else 14558 scsi_free_consistent_buf(bp); 14559 #endif 14560 14561 kmem_free(xp, sizeof (struct sd_xbuf)); 14562 } 14563 14564 14565 /* 14566 * Function: sd_print_transport_rejected_message 14567 * 14568 * Description: This implements the ludicrously complex rules for printing 14569 * a "transport rejected" message. This is to address the 14570 * specific problem of having a flood of this error message 14571 * produced when a failover occurs. 14572 * 14573 * Context: Any. 14574 */ 14575 14576 static void 14577 sd_print_transport_rejected_message(struct sd_lun *un, struct sd_xbuf *xp, 14578 int code) 14579 { 14580 ASSERT(un != NULL); 14581 ASSERT(mutex_owned(SD_MUTEX(un))); 14582 ASSERT(xp != NULL); 14583 14584 /* 14585 * Print the "transport rejected" message under the following 14586 * conditions: 14587 * 14588 * - Whenever the SD_LOGMASK_DIAG bit of sd_level_mask is set 14589 * - The error code from scsi_transport() is NOT a TRAN_FATAL_ERROR. 14590 * - If the error code IS a TRAN_FATAL_ERROR, then the message is 14591 * printed the FIRST time a TRAN_FATAL_ERROR is returned from 14592 * scsi_transport(9F) (which indicates that the target might have 14593 * gone off-line). This uses the un->un_tran_fatal_count 14594 * count, which is incremented whenever a TRAN_FATAL_ERROR is 14595 * received, and reset to zero whenver a TRAN_ACCEPT is returned 14596 * from scsi_transport(). 14597 * 14598 * The FLAG_SILENT in the scsi_pkt must be CLEARED in ALL of 14599 * the preceeding cases in order for the message to be printed. 14600 */ 14601 if (((xp->xb_pktp->pkt_flags & FLAG_SILENT) == 0) && 14602 (SD_FM_LOG(un) == SD_FM_LOG_NSUP)) { 14603 if ((sd_level_mask & SD_LOGMASK_DIAG) || 14604 (code != TRAN_FATAL_ERROR) || 14605 (un->un_tran_fatal_count == 1)) { 14606 switch (code) { 14607 case TRAN_BADPKT: 14608 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 14609 "transport rejected bad packet\n"); 14610 break; 14611 case TRAN_FATAL_ERROR: 14612 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 14613 "transport rejected fatal error\n"); 14614 break; 14615 default: 14616 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 14617 "transport rejected (%d)\n", code); 14618 break; 14619 } 14620 } 14621 } 14622 } 14623 14624 14625 /* 14626 * Function: sd_add_buf_to_waitq 14627 * 14628 * Description: Add the given buf(9S) struct to the wait queue for the 14629 * instance. If sorting is enabled, then the buf is added 14630 * to the queue via an elevator sort algorithm (a la 14631 * disksort(9F)). The SD_GET_BLKNO(bp) is used as the sort key. 14632 * If sorting is not enabled, then the buf is just added 14633 * to the end of the wait queue. 14634 * 14635 * Return Code: void 14636 * 14637 * Context: Does not sleep/block, therefore technically can be called 14638 * from any context. However if sorting is enabled then the 14639 * execution time is indeterminate, and may take long if 14640 * the wait queue grows large. 14641 */ 14642 14643 static void 14644 sd_add_buf_to_waitq(struct sd_lun *un, struct buf *bp) 14645 { 14646 struct buf *ap; 14647 14648 ASSERT(bp != NULL); 14649 ASSERT(un != NULL); 14650 ASSERT(mutex_owned(SD_MUTEX(un))); 14651 14652 /* If the queue is empty, add the buf as the only entry & return. */ 14653 if (un->un_waitq_headp == NULL) { 14654 ASSERT(un->un_waitq_tailp == NULL); 14655 un->un_waitq_headp = un->un_waitq_tailp = bp; 14656 bp->av_forw = NULL; 14657 return; 14658 } 14659 14660 ASSERT(un->un_waitq_tailp != NULL); 14661 14662 /* 14663 * If sorting is disabled, just add the buf to the tail end of 14664 * the wait queue and return. 14665 */ 14666 if (un->un_f_disksort_disabled || un->un_f_enable_rmw) { 14667 un->un_waitq_tailp->av_forw = bp; 14668 un->un_waitq_tailp = bp; 14669 bp->av_forw = NULL; 14670 return; 14671 } 14672 14673 /* 14674 * Sort thru the list of requests currently on the wait queue 14675 * and add the new buf request at the appropriate position. 14676 * 14677 * The un->un_waitq_headp is an activity chain pointer on which 14678 * we keep two queues, sorted in ascending SD_GET_BLKNO() order. The 14679 * first queue holds those requests which are positioned after 14680 * the current SD_GET_BLKNO() (in the first request); the second holds 14681 * requests which came in after their SD_GET_BLKNO() number was passed. 14682 * Thus we implement a one way scan, retracting after reaching 14683 * the end of the drive to the first request on the second 14684 * queue, at which time it becomes the first queue. 14685 * A one-way scan is natural because of the way UNIX read-ahead 14686 * blocks are allocated. 14687 * 14688 * If we lie after the first request, then we must locate the 14689 * second request list and add ourselves to it. 14690 */ 14691 ap = un->un_waitq_headp; 14692 if (SD_GET_BLKNO(bp) < SD_GET_BLKNO(ap)) { 14693 while (ap->av_forw != NULL) { 14694 /* 14695 * Look for an "inversion" in the (normally 14696 * ascending) block numbers. This indicates 14697 * the start of the second request list. 14698 */ 14699 if (SD_GET_BLKNO(ap->av_forw) < SD_GET_BLKNO(ap)) { 14700 /* 14701 * Search the second request list for the 14702 * first request at a larger block number. 14703 * We go before that; however if there is 14704 * no such request, we go at the end. 14705 */ 14706 do { 14707 if (SD_GET_BLKNO(bp) < 14708 SD_GET_BLKNO(ap->av_forw)) { 14709 goto insert; 14710 } 14711 ap = ap->av_forw; 14712 } while (ap->av_forw != NULL); 14713 goto insert; /* after last */ 14714 } 14715 ap = ap->av_forw; 14716 } 14717 14718 /* 14719 * No inversions... we will go after the last, and 14720 * be the first request in the second request list. 14721 */ 14722 goto insert; 14723 } 14724 14725 /* 14726 * Request is at/after the current request... 14727 * sort in the first request list. 14728 */ 14729 while (ap->av_forw != NULL) { 14730 /* 14731 * We want to go after the current request (1) if 14732 * there is an inversion after it (i.e. it is the end 14733 * of the first request list), or (2) if the next 14734 * request is a larger block no. than our request. 14735 */ 14736 if ((SD_GET_BLKNO(ap->av_forw) < SD_GET_BLKNO(ap)) || 14737 (SD_GET_BLKNO(bp) < SD_GET_BLKNO(ap->av_forw))) { 14738 goto insert; 14739 } 14740 ap = ap->av_forw; 14741 } 14742 14743 /* 14744 * Neither a second list nor a larger request, therefore 14745 * we go at the end of the first list (which is the same 14746 * as the end of the whole schebang). 14747 */ 14748 insert: 14749 bp->av_forw = ap->av_forw; 14750 ap->av_forw = bp; 14751 14752 /* 14753 * If we inserted onto the tail end of the waitq, make sure the 14754 * tail pointer is updated. 14755 */ 14756 if (ap == un->un_waitq_tailp) { 14757 un->un_waitq_tailp = bp; 14758 } 14759 } 14760 14761 14762 /* 14763 * Function: sd_start_cmds 14764 * 14765 * Description: Remove and transport cmds from the driver queues. 14766 * 14767 * Arguments: un - pointer to the unit (soft state) struct for the target. 14768 * 14769 * immed_bp - ptr to a buf to be transported immediately. Only 14770 * the immed_bp is transported; bufs on the waitq are not 14771 * processed and the un_retry_bp is not checked. If immed_bp is 14772 * NULL, then normal queue processing is performed. 14773 * 14774 * Context: May be called from kernel thread context, interrupt context, 14775 * or runout callback context. This function may not block or 14776 * call routines that block. 14777 */ 14778 14779 static void 14780 sd_start_cmds(struct sd_lun *un, struct buf *immed_bp) 14781 { 14782 struct sd_xbuf *xp; 14783 struct buf *bp; 14784 void (*statp)(kstat_io_t *); 14785 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */ 14786 void (*saved_statp)(kstat_io_t *); 14787 #endif 14788 int rval; 14789 struct sd_fm_internal *sfip = NULL; 14790 14791 ASSERT(un != NULL); 14792 ASSERT(mutex_owned(SD_MUTEX(un))); 14793 ASSERT(un->un_ncmds_in_transport >= 0); 14794 ASSERT(un->un_throttle >= 0); 14795 14796 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_start_cmds: entry\n"); 14797 14798 do { 14799 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */ 14800 saved_statp = NULL; 14801 #endif 14802 14803 /* 14804 * If we are syncing or dumping, fail the command to 14805 * avoid recursively calling back into scsi_transport(). 14806 * The dump I/O itself uses a separate code path so this 14807 * only prevents non-dump I/O from being sent while dumping. 14808 * File system sync takes place before dumping begins. 14809 * During panic, filesystem I/O is allowed provided 14810 * un_in_callback is <= 1. This is to prevent recursion 14811 * such as sd_start_cmds -> scsi_transport -> sdintr -> 14812 * sd_start_cmds and so on. See panic.c for more information 14813 * about the states the system can be in during panic. 14814 */ 14815 if ((un->un_state == SD_STATE_DUMPING) || 14816 (ddi_in_panic() && (un->un_in_callback > 1))) { 14817 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 14818 "sd_start_cmds: panicking\n"); 14819 goto exit; 14820 } 14821 14822 if ((bp = immed_bp) != NULL) { 14823 /* 14824 * We have a bp that must be transported immediately. 14825 * It's OK to transport the immed_bp here without doing 14826 * the throttle limit check because the immed_bp is 14827 * always used in a retry/recovery case. This means 14828 * that we know we are not at the throttle limit by 14829 * virtue of the fact that to get here we must have 14830 * already gotten a command back via sdintr(). This also 14831 * relies on (1) the command on un_retry_bp preventing 14832 * further commands from the waitq from being issued; 14833 * and (2) the code in sd_retry_command checking the 14834 * throttle limit before issuing a delayed or immediate 14835 * retry. This holds even if the throttle limit is 14836 * currently ratcheted down from its maximum value. 14837 */ 14838 statp = kstat_runq_enter; 14839 if (bp == un->un_retry_bp) { 14840 ASSERT((un->un_retry_statp == NULL) || 14841 (un->un_retry_statp == kstat_waitq_enter) || 14842 (un->un_retry_statp == 14843 kstat_runq_back_to_waitq)); 14844 /* 14845 * If the waitq kstat was incremented when 14846 * sd_set_retry_bp() queued this bp for a retry, 14847 * then we must set up statp so that the waitq 14848 * count will get decremented correctly below. 14849 * Also we must clear un->un_retry_statp to 14850 * ensure that we do not act on a stale value 14851 * in this field. 14852 */ 14853 if ((un->un_retry_statp == kstat_waitq_enter) || 14854 (un->un_retry_statp == 14855 kstat_runq_back_to_waitq)) { 14856 statp = kstat_waitq_to_runq; 14857 } 14858 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */ 14859 saved_statp = un->un_retry_statp; 14860 #endif 14861 un->un_retry_statp = NULL; 14862 14863 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, 14864 "sd_start_cmds: un:0x%p: GOT retry_bp:0x%p " 14865 "un_throttle:%d un_ncmds_in_transport:%d\n", 14866 un, un->un_retry_bp, un->un_throttle, 14867 un->un_ncmds_in_transport); 14868 } else { 14869 SD_TRACE(SD_LOG_IO_CORE, un, "sd_start_cmds: " 14870 "processing priority bp:0x%p\n", bp); 14871 } 14872 14873 } else if ((bp = un->un_waitq_headp) != NULL) { 14874 /* 14875 * A command on the waitq is ready to go, but do not 14876 * send it if: 14877 * 14878 * (1) the throttle limit has been reached, or 14879 * (2) a retry is pending, or 14880 * (3) a START_STOP_UNIT callback pending, or 14881 * (4) a callback for a SD_PATH_DIRECT_PRIORITY 14882 * command is pending. 14883 * 14884 * For all of these conditions, IO processing will 14885 * restart after the condition is cleared. 14886 */ 14887 if (un->un_ncmds_in_transport >= un->un_throttle) { 14888 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 14889 "sd_start_cmds: exiting, " 14890 "throttle limit reached!\n"); 14891 goto exit; 14892 } 14893 if (un->un_retry_bp != NULL) { 14894 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 14895 "sd_start_cmds: exiting, retry pending!\n"); 14896 goto exit; 14897 } 14898 if (un->un_startstop_timeid != NULL) { 14899 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 14900 "sd_start_cmds: exiting, " 14901 "START_STOP pending!\n"); 14902 goto exit; 14903 } 14904 if (un->un_direct_priority_timeid != NULL) { 14905 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 14906 "sd_start_cmds: exiting, " 14907 "SD_PATH_DIRECT_PRIORITY cmd. pending!\n"); 14908 goto exit; 14909 } 14910 14911 /* Dequeue the command */ 14912 un->un_waitq_headp = bp->av_forw; 14913 if (un->un_waitq_headp == NULL) { 14914 un->un_waitq_tailp = NULL; 14915 } 14916 bp->av_forw = NULL; 14917 statp = kstat_waitq_to_runq; 14918 SD_TRACE(SD_LOG_IO_CORE, un, 14919 "sd_start_cmds: processing waitq bp:0x%p\n", bp); 14920 14921 } else { 14922 /* No work to do so bail out now */ 14923 SD_TRACE(SD_LOG_IO_CORE, un, 14924 "sd_start_cmds: no more work, exiting!\n"); 14925 goto exit; 14926 } 14927 14928 /* 14929 * Reset the state to normal. This is the mechanism by which 14930 * the state transitions from either SD_STATE_RWAIT or 14931 * SD_STATE_OFFLINE to SD_STATE_NORMAL. 14932 * If state is SD_STATE_PM_CHANGING then this command is 14933 * part of the device power control and the state must 14934 * not be put back to normal. Doing so would would 14935 * allow new commands to proceed when they shouldn't, 14936 * the device may be going off. 14937 */ 14938 if ((un->un_state != SD_STATE_SUSPENDED) && 14939 (un->un_state != SD_STATE_PM_CHANGING)) { 14940 New_state(un, SD_STATE_NORMAL); 14941 } 14942 14943 xp = SD_GET_XBUF(bp); 14944 ASSERT(xp != NULL); 14945 14946 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */ 14947 /* 14948 * Allocate the scsi_pkt if we need one, or attach DMA 14949 * resources if we have a scsi_pkt that needs them. The 14950 * latter should only occur for commands that are being 14951 * retried. 14952 */ 14953 if ((xp->xb_pktp == NULL) || 14954 ((xp->xb_pkt_flags & SD_XB_DMA_FREED) != 0)) { 14955 #else 14956 if (xp->xb_pktp == NULL) { 14957 #endif 14958 /* 14959 * There is no scsi_pkt allocated for this buf. Call 14960 * the initpkt function to allocate & init one. 14961 * 14962 * The scsi_init_pkt runout callback functionality is 14963 * implemented as follows: 14964 * 14965 * 1) The initpkt function always calls 14966 * scsi_init_pkt(9F) with sdrunout specified as the 14967 * callback routine. 14968 * 2) A successful packet allocation is initialized and 14969 * the I/O is transported. 14970 * 3) The I/O associated with an allocation resource 14971 * failure is left on its queue to be retried via 14972 * runout or the next I/O. 14973 * 4) The I/O associated with a DMA error is removed 14974 * from the queue and failed with EIO. Processing of 14975 * the transport queues is also halted to be 14976 * restarted via runout or the next I/O. 14977 * 5) The I/O associated with a CDB size or packet 14978 * size error is removed from the queue and failed 14979 * with EIO. Processing of the transport queues is 14980 * continued. 14981 * 14982 * Note: there is no interface for canceling a runout 14983 * callback. To prevent the driver from detaching or 14984 * suspending while a runout is pending the driver 14985 * state is set to SD_STATE_RWAIT 14986 * 14987 * Note: using the scsi_init_pkt callback facility can 14988 * result in an I/O request persisting at the head of 14989 * the list which cannot be satisfied even after 14990 * multiple retries. In the future the driver may 14991 * implement some kind of maximum runout count before 14992 * failing an I/O. 14993 * 14994 * Note: the use of funcp below may seem superfluous, 14995 * but it helps warlock figure out the correct 14996 * initpkt function calls (see [s]sd.wlcmd). 14997 */ 14998 struct scsi_pkt *pktp; 14999 int (*funcp)(struct buf *bp, struct scsi_pkt **pktp); 15000 15001 ASSERT(bp != un->un_rqs_bp); 15002 15003 funcp = sd_initpkt_map[xp->xb_chain_iostart]; 15004 switch ((*funcp)(bp, &pktp)) { 15005 case SD_PKT_ALLOC_SUCCESS: 15006 xp->xb_pktp = pktp; 15007 SD_TRACE(SD_LOG_IO_CORE, un, 15008 "sd_start_cmd: SD_PKT_ALLOC_SUCCESS 0x%p\n", 15009 pktp); 15010 goto got_pkt; 15011 15012 case SD_PKT_ALLOC_FAILURE: 15013 /* 15014 * Temporary (hopefully) resource depletion. 15015 * Since retries and RQS commands always have a 15016 * scsi_pkt allocated, these cases should never 15017 * get here. So the only cases this needs to 15018 * handle is a bp from the waitq (which we put 15019 * back onto the waitq for sdrunout), or a bp 15020 * sent as an immed_bp (which we just fail). 15021 */ 15022 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15023 "sd_start_cmds: SD_PKT_ALLOC_FAILURE\n"); 15024 15025 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */ 15026 15027 if (bp == immed_bp) { 15028 /* 15029 * If SD_XB_DMA_FREED is clear, then 15030 * this is a failure to allocate a 15031 * scsi_pkt, and we must fail the 15032 * command. 15033 */ 15034 if ((xp->xb_pkt_flags & 15035 SD_XB_DMA_FREED) == 0) { 15036 break; 15037 } 15038 15039 /* 15040 * If this immediate command is NOT our 15041 * un_retry_bp, then we must fail it. 15042 */ 15043 if (bp != un->un_retry_bp) { 15044 break; 15045 } 15046 15047 /* 15048 * We get here if this cmd is our 15049 * un_retry_bp that was DMAFREED, but 15050 * scsi_init_pkt() failed to reallocate 15051 * DMA resources when we attempted to 15052 * retry it. This can happen when an 15053 * mpxio failover is in progress, but 15054 * we don't want to just fail the 15055 * command in this case. 15056 * 15057 * Use timeout(9F) to restart it after 15058 * a 100ms delay. We don't want to 15059 * let sdrunout() restart it, because 15060 * sdrunout() is just supposed to start 15061 * commands that are sitting on the 15062 * wait queue. The un_retry_bp stays 15063 * set until the command completes, but 15064 * sdrunout can be called many times 15065 * before that happens. Since sdrunout 15066 * cannot tell if the un_retry_bp is 15067 * already in the transport, it could 15068 * end up calling scsi_transport() for 15069 * the un_retry_bp multiple times. 15070 * 15071 * Also: don't schedule the callback 15072 * if some other callback is already 15073 * pending. 15074 */ 15075 if (un->un_retry_statp == NULL) { 15076 /* 15077 * restore the kstat pointer to 15078 * keep kstat counts coherent 15079 * when we do retry the command. 15080 */ 15081 un->un_retry_statp = 15082 saved_statp; 15083 } 15084 15085 if ((un->un_startstop_timeid == NULL) && 15086 (un->un_retry_timeid == NULL) && 15087 (un->un_direct_priority_timeid == 15088 NULL)) { 15089 15090 un->un_retry_timeid = 15091 timeout( 15092 sd_start_retry_command, 15093 un, SD_RESTART_TIMEOUT); 15094 } 15095 goto exit; 15096 } 15097 15098 #else 15099 if (bp == immed_bp) { 15100 break; /* Just fail the command */ 15101 } 15102 #endif 15103 15104 /* Add the buf back to the head of the waitq */ 15105 bp->av_forw = un->un_waitq_headp; 15106 un->un_waitq_headp = bp; 15107 if (un->un_waitq_tailp == NULL) { 15108 un->un_waitq_tailp = bp; 15109 } 15110 goto exit; 15111 15112 case SD_PKT_ALLOC_FAILURE_NO_DMA: 15113 /* 15114 * HBA DMA resource failure. Fail the command 15115 * and continue processing of the queues. 15116 */ 15117 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15118 "sd_start_cmds: " 15119 "SD_PKT_ALLOC_FAILURE_NO_DMA\n"); 15120 break; 15121 15122 case SD_PKT_ALLOC_FAILURE_PKT_TOO_SMALL: 15123 /* 15124 * Note:x86: Partial DMA mapping not supported 15125 * for USCSI commands, and all the needed DMA 15126 * resources were not allocated. 15127 */ 15128 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15129 "sd_start_cmds: " 15130 "SD_PKT_ALLOC_FAILURE_PKT_TOO_SMALL\n"); 15131 break; 15132 15133 case SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL: 15134 /* 15135 * Note:x86: Request cannot fit into CDB based 15136 * on lba and len. 15137 */ 15138 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15139 "sd_start_cmds: " 15140 "SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL\n"); 15141 break; 15142 15143 default: 15144 /* Should NEVER get here! */ 15145 panic("scsi_initpkt error"); 15146 /*NOTREACHED*/ 15147 } 15148 15149 /* 15150 * Fatal error in allocating a scsi_pkt for this buf. 15151 * Update kstats & return the buf with an error code. 15152 * We must use sd_return_failed_command_no_restart() to 15153 * avoid a recursive call back into sd_start_cmds(). 15154 * However this also means that we must keep processing 15155 * the waitq here in order to avoid stalling. 15156 */ 15157 if (statp == kstat_waitq_to_runq) { 15158 SD_UPDATE_KSTATS(un, kstat_waitq_exit, bp); 15159 } 15160 sd_return_failed_command_no_restart(un, bp, EIO); 15161 if (bp == immed_bp) { 15162 /* immed_bp is gone by now, so clear this */ 15163 immed_bp = NULL; 15164 } 15165 continue; 15166 } 15167 got_pkt: 15168 if (bp == immed_bp) { 15169 /* goto the head of the class.... */ 15170 xp->xb_pktp->pkt_flags |= FLAG_HEAD; 15171 } 15172 15173 un->un_ncmds_in_transport++; 15174 SD_UPDATE_KSTATS(un, statp, bp); 15175 15176 /* 15177 * Call scsi_transport() to send the command to the target. 15178 * According to SCSA architecture, we must drop the mutex here 15179 * before calling scsi_transport() in order to avoid deadlock. 15180 * Note that the scsi_pkt's completion routine can be executed 15181 * (from interrupt context) even before the call to 15182 * scsi_transport() returns. 15183 */ 15184 SD_TRACE(SD_LOG_IO_CORE, un, 15185 "sd_start_cmds: calling scsi_transport()\n"); 15186 DTRACE_PROBE1(scsi__transport__dispatch, struct buf *, bp); 15187 15188 mutex_exit(SD_MUTEX(un)); 15189 rval = scsi_transport(xp->xb_pktp); 15190 mutex_enter(SD_MUTEX(un)); 15191 15192 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15193 "sd_start_cmds: scsi_transport() returned %d\n", rval); 15194 15195 switch (rval) { 15196 case TRAN_ACCEPT: 15197 /* Clear this with every pkt accepted by the HBA */ 15198 un->un_tran_fatal_count = 0; 15199 break; /* Success; try the next cmd (if any) */ 15200 15201 case TRAN_BUSY: 15202 un->un_ncmds_in_transport--; 15203 ASSERT(un->un_ncmds_in_transport >= 0); 15204 15205 /* 15206 * Don't retry request sense, the sense data 15207 * is lost when another request is sent. 15208 * Free up the rqs buf and retry 15209 * the original failed cmd. Update kstat. 15210 */ 15211 if (bp == un->un_rqs_bp) { 15212 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp); 15213 bp = sd_mark_rqs_idle(un, xp); 15214 sd_retry_command(un, bp, SD_RETRIES_STANDARD, 15215 NULL, NULL, EIO, un->un_busy_timeout / 500, 15216 kstat_waitq_enter); 15217 goto exit; 15218 } 15219 15220 #if defined(__i386) || defined(__amd64) /* DMAFREE for x86 only */ 15221 /* 15222 * Free the DMA resources for the scsi_pkt. This will 15223 * allow mpxio to select another path the next time 15224 * we call scsi_transport() with this scsi_pkt. 15225 * See sdintr() for the rationalization behind this. 15226 */ 15227 if ((un->un_f_is_fibre == TRUE) && 15228 ((xp->xb_pkt_flags & SD_XB_USCSICMD) == 0) && 15229 ((xp->xb_pktp->pkt_flags & FLAG_SENSING) == 0)) { 15230 scsi_dmafree(xp->xb_pktp); 15231 xp->xb_pkt_flags |= SD_XB_DMA_FREED; 15232 } 15233 #endif 15234 15235 if (SD_IS_DIRECT_PRIORITY(SD_GET_XBUF(bp))) { 15236 /* 15237 * Commands that are SD_PATH_DIRECT_PRIORITY 15238 * are for error recovery situations. These do 15239 * not use the normal command waitq, so if they 15240 * get a TRAN_BUSY we cannot put them back onto 15241 * the waitq for later retry. One possible 15242 * problem is that there could already be some 15243 * other command on un_retry_bp that is waiting 15244 * for this one to complete, so we would be 15245 * deadlocked if we put this command back onto 15246 * the waitq for later retry (since un_retry_bp 15247 * must complete before the driver gets back to 15248 * commands on the waitq). 15249 * 15250 * To avoid deadlock we must schedule a callback 15251 * that will restart this command after a set 15252 * interval. This should keep retrying for as 15253 * long as the underlying transport keeps 15254 * returning TRAN_BUSY (just like for other 15255 * commands). Use the same timeout interval as 15256 * for the ordinary TRAN_BUSY retry. 15257 */ 15258 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15259 "sd_start_cmds: scsi_transport() returned " 15260 "TRAN_BUSY for DIRECT_PRIORITY cmd!\n"); 15261 15262 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp); 15263 un->un_direct_priority_timeid = 15264 timeout(sd_start_direct_priority_command, 15265 bp, un->un_busy_timeout / 500); 15266 15267 goto exit; 15268 } 15269 15270 /* 15271 * For TRAN_BUSY, we want to reduce the throttle value, 15272 * unless we are retrying a command. 15273 */ 15274 if (bp != un->un_retry_bp) { 15275 sd_reduce_throttle(un, SD_THROTTLE_TRAN_BUSY); 15276 } 15277 15278 /* 15279 * Set up the bp to be tried again 10 ms later. 15280 * Note:x86: Is there a timeout value in the sd_lun 15281 * for this condition? 15282 */ 15283 sd_set_retry_bp(un, bp, un->un_busy_timeout / 500, 15284 kstat_runq_back_to_waitq); 15285 goto exit; 15286 15287 case TRAN_FATAL_ERROR: 15288 un->un_tran_fatal_count++; 15289 /* FALLTHRU */ 15290 15291 case TRAN_BADPKT: 15292 default: 15293 un->un_ncmds_in_transport--; 15294 ASSERT(un->un_ncmds_in_transport >= 0); 15295 15296 /* 15297 * If this is our REQUEST SENSE command with a 15298 * transport error, we must get back the pointers 15299 * to the original buf, and mark the REQUEST 15300 * SENSE command as "available". 15301 */ 15302 if (bp == un->un_rqs_bp) { 15303 bp = sd_mark_rqs_idle(un, xp); 15304 xp = SD_GET_XBUF(bp); 15305 } else { 15306 /* 15307 * Legacy behavior: do not update transport 15308 * error count for request sense commands. 15309 */ 15310 SD_UPDATE_ERRSTATS(un, sd_transerrs); 15311 } 15312 15313 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp); 15314 sd_print_transport_rejected_message(un, xp, rval); 15315 15316 /* 15317 * This command will be terminated by SD driver due 15318 * to a fatal transport error. We should post 15319 * ereport.io.scsi.cmd.disk.tran with driver-assessment 15320 * of "fail" for any command to indicate this 15321 * situation. 15322 */ 15323 if (xp->xb_ena > 0) { 15324 ASSERT(un->un_fm_private != NULL); 15325 sfip = un->un_fm_private; 15326 sfip->fm_ssc.ssc_flags |= SSC_FLAGS_TRAN_ABORT; 15327 sd_ssc_extract_info(&sfip->fm_ssc, un, 15328 xp->xb_pktp, bp, xp); 15329 sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_FATAL); 15330 } 15331 15332 /* 15333 * We must use sd_return_failed_command_no_restart() to 15334 * avoid a recursive call back into sd_start_cmds(). 15335 * However this also means that we must keep processing 15336 * the waitq here in order to avoid stalling. 15337 */ 15338 sd_return_failed_command_no_restart(un, bp, EIO); 15339 15340 /* 15341 * Notify any threads waiting in sd_ddi_suspend() that 15342 * a command completion has occurred. 15343 */ 15344 if (un->un_state == SD_STATE_SUSPENDED) { 15345 cv_broadcast(&un->un_disk_busy_cv); 15346 } 15347 15348 if (bp == immed_bp) { 15349 /* immed_bp is gone by now, so clear this */ 15350 immed_bp = NULL; 15351 } 15352 break; 15353 } 15354 15355 } while (immed_bp == NULL); 15356 15357 exit: 15358 ASSERT(mutex_owned(SD_MUTEX(un))); 15359 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_start_cmds: exit\n"); 15360 } 15361 15362 15363 /* 15364 * Function: sd_return_command 15365 * 15366 * Description: Returns a command to its originator (with or without an 15367 * error). Also starts commands waiting to be transported 15368 * to the target. 15369 * 15370 * Context: May be called from interrupt, kernel, or timeout context 15371 */ 15372 15373 static void 15374 sd_return_command(struct sd_lun *un, struct buf *bp) 15375 { 15376 struct sd_xbuf *xp; 15377 struct scsi_pkt *pktp; 15378 struct sd_fm_internal *sfip; 15379 15380 ASSERT(bp != NULL); 15381 ASSERT(un != NULL); 15382 ASSERT(mutex_owned(SD_MUTEX(un))); 15383 ASSERT(bp != un->un_rqs_bp); 15384 xp = SD_GET_XBUF(bp); 15385 ASSERT(xp != NULL); 15386 15387 pktp = SD_GET_PKTP(bp); 15388 sfip = (struct sd_fm_internal *)un->un_fm_private; 15389 ASSERT(sfip != NULL); 15390 15391 SD_TRACE(SD_LOG_IO_CORE, un, "sd_return_command: entry\n"); 15392 15393 /* 15394 * Note: check for the "sdrestart failed" case. 15395 */ 15396 if ((un->un_partial_dma_supported == 1) && 15397 ((xp->xb_pkt_flags & SD_XB_USCSICMD) != SD_XB_USCSICMD) && 15398 (geterror(bp) == 0) && (xp->xb_dma_resid != 0) && 15399 (xp->xb_pktp->pkt_resid == 0)) { 15400 15401 if (sd_setup_next_xfer(un, bp, pktp, xp) != 0) { 15402 /* 15403 * Successfully set up next portion of cmd 15404 * transfer, try sending it 15405 */ 15406 sd_retry_command(un, bp, SD_RETRIES_NOCHECK, 15407 NULL, NULL, 0, (clock_t)0, NULL); 15408 sd_start_cmds(un, NULL); 15409 return; /* Note:x86: need a return here? */ 15410 } 15411 } 15412 15413 /* 15414 * If this is the failfast bp, clear it from un_failfast_bp. This 15415 * can happen if upon being re-tried the failfast bp either 15416 * succeeded or encountered another error (possibly even a different 15417 * error than the one that precipitated the failfast state, but in 15418 * that case it would have had to exhaust retries as well). Regardless, 15419 * this should not occur whenever the instance is in the active 15420 * failfast state. 15421 */ 15422 if (bp == un->un_failfast_bp) { 15423 ASSERT(un->un_failfast_state == SD_FAILFAST_INACTIVE); 15424 un->un_failfast_bp = NULL; 15425 } 15426 15427 /* 15428 * Clear the failfast state upon successful completion of ANY cmd. 15429 */ 15430 if (bp->b_error == 0) { 15431 un->un_failfast_state = SD_FAILFAST_INACTIVE; 15432 /* 15433 * If this is a successful command, but used to be retried, 15434 * we will take it as a recovered command and post an 15435 * ereport with driver-assessment of "recovered". 15436 */ 15437 if (xp->xb_ena > 0) { 15438 sd_ssc_extract_info(&sfip->fm_ssc, un, pktp, bp, xp); 15439 sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_RECOVERY); 15440 } 15441 } else { 15442 /* 15443 * If this is a failed non-USCSI command we will post an 15444 * ereport with driver-assessment set accordingly("fail" or 15445 * "fatal"). 15446 */ 15447 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) { 15448 sd_ssc_extract_info(&sfip->fm_ssc, un, pktp, bp, xp); 15449 sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_FATAL); 15450 } 15451 } 15452 15453 /* 15454 * This is used if the command was retried one or more times. Show that 15455 * we are done with it, and allow processing of the waitq to resume. 15456 */ 15457 if (bp == un->un_retry_bp) { 15458 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15459 "sd_return_command: un:0x%p: " 15460 "RETURNING retry_bp:0x%p\n", un, un->un_retry_bp); 15461 un->un_retry_bp = NULL; 15462 un->un_retry_statp = NULL; 15463 } 15464 15465 SD_UPDATE_RDWR_STATS(un, bp); 15466 SD_UPDATE_PARTITION_STATS(un, bp); 15467 15468 switch (un->un_state) { 15469 case SD_STATE_SUSPENDED: 15470 /* 15471 * Notify any threads waiting in sd_ddi_suspend() that 15472 * a command completion has occurred. 15473 */ 15474 cv_broadcast(&un->un_disk_busy_cv); 15475 break; 15476 default: 15477 sd_start_cmds(un, NULL); 15478 break; 15479 } 15480 15481 /* Return this command up the iodone chain to its originator. */ 15482 mutex_exit(SD_MUTEX(un)); 15483 15484 (*(sd_destroypkt_map[xp->xb_chain_iodone]))(bp); 15485 xp->xb_pktp = NULL; 15486 15487 SD_BEGIN_IODONE(xp->xb_chain_iodone, un, bp); 15488 15489 ASSERT(!mutex_owned(SD_MUTEX(un))); 15490 mutex_enter(SD_MUTEX(un)); 15491 15492 SD_TRACE(SD_LOG_IO_CORE, un, "sd_return_command: exit\n"); 15493 } 15494 15495 15496 /* 15497 * Function: sd_return_failed_command 15498 * 15499 * Description: Command completion when an error occurred. 15500 * 15501 * Context: May be called from interrupt context 15502 */ 15503 15504 static void 15505 sd_return_failed_command(struct sd_lun *un, struct buf *bp, int errcode) 15506 { 15507 ASSERT(bp != NULL); 15508 ASSERT(un != NULL); 15509 ASSERT(mutex_owned(SD_MUTEX(un))); 15510 15511 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15512 "sd_return_failed_command: entry\n"); 15513 15514 /* 15515 * b_resid could already be nonzero due to a partial data 15516 * transfer, so do not change it here. 15517 */ 15518 SD_BIOERROR(bp, errcode); 15519 15520 sd_return_command(un, bp); 15521 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15522 "sd_return_failed_command: exit\n"); 15523 } 15524 15525 15526 /* 15527 * Function: sd_return_failed_command_no_restart 15528 * 15529 * Description: Same as sd_return_failed_command, but ensures that no 15530 * call back into sd_start_cmds will be issued. 15531 * 15532 * Context: May be called from interrupt context 15533 */ 15534 15535 static void 15536 sd_return_failed_command_no_restart(struct sd_lun *un, struct buf *bp, 15537 int errcode) 15538 { 15539 struct sd_xbuf *xp; 15540 15541 ASSERT(bp != NULL); 15542 ASSERT(un != NULL); 15543 ASSERT(mutex_owned(SD_MUTEX(un))); 15544 xp = SD_GET_XBUF(bp); 15545 ASSERT(xp != NULL); 15546 ASSERT(errcode != 0); 15547 15548 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15549 "sd_return_failed_command_no_restart: entry\n"); 15550 15551 /* 15552 * b_resid could already be nonzero due to a partial data 15553 * transfer, so do not change it here. 15554 */ 15555 SD_BIOERROR(bp, errcode); 15556 15557 /* 15558 * If this is the failfast bp, clear it. This can happen if the 15559 * failfast bp encounterd a fatal error when we attempted to 15560 * re-try it (such as a scsi_transport(9F) failure). However 15561 * we should NOT be in an active failfast state if the failfast 15562 * bp is not NULL. 15563 */ 15564 if (bp == un->un_failfast_bp) { 15565 ASSERT(un->un_failfast_state == SD_FAILFAST_INACTIVE); 15566 un->un_failfast_bp = NULL; 15567 } 15568 15569 if (bp == un->un_retry_bp) { 15570 /* 15571 * This command was retried one or more times. Show that we are 15572 * done with it, and allow processing of the waitq to resume. 15573 */ 15574 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15575 "sd_return_failed_command_no_restart: " 15576 " un:0x%p: RETURNING retry_bp:0x%p\n", un, un->un_retry_bp); 15577 un->un_retry_bp = NULL; 15578 un->un_retry_statp = NULL; 15579 } 15580 15581 SD_UPDATE_RDWR_STATS(un, bp); 15582 SD_UPDATE_PARTITION_STATS(un, bp); 15583 15584 mutex_exit(SD_MUTEX(un)); 15585 15586 if (xp->xb_pktp != NULL) { 15587 (*(sd_destroypkt_map[xp->xb_chain_iodone]))(bp); 15588 xp->xb_pktp = NULL; 15589 } 15590 15591 SD_BEGIN_IODONE(xp->xb_chain_iodone, un, bp); 15592 15593 mutex_enter(SD_MUTEX(un)); 15594 15595 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15596 "sd_return_failed_command_no_restart: exit\n"); 15597 } 15598 15599 15600 /* 15601 * Function: sd_retry_command 15602 * 15603 * Description: queue up a command for retry, or (optionally) fail it 15604 * if retry counts are exhausted. 15605 * 15606 * Arguments: un - Pointer to the sd_lun struct for the target. 15607 * 15608 * bp - Pointer to the buf for the command to be retried. 15609 * 15610 * retry_check_flag - Flag to see which (if any) of the retry 15611 * counts should be decremented/checked. If the indicated 15612 * retry count is exhausted, then the command will not be 15613 * retried; it will be failed instead. This should use a 15614 * value equal to one of the following: 15615 * 15616 * SD_RETRIES_NOCHECK 15617 * SD_RESD_RETRIES_STANDARD 15618 * SD_RETRIES_VICTIM 15619 * 15620 * Optionally may be bitwise-OR'ed with SD_RETRIES_ISOLATE 15621 * if the check should be made to see of FLAG_ISOLATE is set 15622 * in the pkt. If FLAG_ISOLATE is set, then the command is 15623 * not retried, it is simply failed. 15624 * 15625 * user_funcp - Ptr to function to call before dispatching the 15626 * command. May be NULL if no action needs to be performed. 15627 * (Primarily intended for printing messages.) 15628 * 15629 * user_arg - Optional argument to be passed along to 15630 * the user_funcp call. 15631 * 15632 * failure_code - errno return code to set in the bp if the 15633 * command is going to be failed. 15634 * 15635 * retry_delay - Retry delay interval in (clock_t) units. May 15636 * be zero which indicates that the retry should be retried 15637 * immediately (ie, without an intervening delay). 15638 * 15639 * statp - Ptr to kstat function to be updated if the command 15640 * is queued for a delayed retry. May be NULL if no kstat 15641 * update is desired. 15642 * 15643 * Context: May be called from interrupt context. 15644 */ 15645 15646 static void 15647 sd_retry_command(struct sd_lun *un, struct buf *bp, int retry_check_flag, 15648 void (*user_funcp)(struct sd_lun *un, struct buf *bp, void *argp, int 15649 code), void *user_arg, int failure_code, clock_t retry_delay, 15650 void (*statp)(kstat_io_t *)) 15651 { 15652 struct sd_xbuf *xp; 15653 struct scsi_pkt *pktp; 15654 struct sd_fm_internal *sfip; 15655 15656 ASSERT(un != NULL); 15657 ASSERT(mutex_owned(SD_MUTEX(un))); 15658 ASSERT(bp != NULL); 15659 xp = SD_GET_XBUF(bp); 15660 ASSERT(xp != NULL); 15661 pktp = SD_GET_PKTP(bp); 15662 ASSERT(pktp != NULL); 15663 15664 sfip = (struct sd_fm_internal *)un->un_fm_private; 15665 ASSERT(sfip != NULL); 15666 15667 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, 15668 "sd_retry_command: entry: bp:0x%p xp:0x%p\n", bp, xp); 15669 15670 /* 15671 * If we are syncing or dumping, fail the command to avoid 15672 * recursively calling back into scsi_transport(). 15673 */ 15674 if (ddi_in_panic()) { 15675 goto fail_command_no_log; 15676 } 15677 15678 /* 15679 * We should never be be retrying a command with FLAG_DIAGNOSE set, so 15680 * log an error and fail the command. 15681 */ 15682 if ((pktp->pkt_flags & FLAG_DIAGNOSE) != 0) { 15683 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE, 15684 "ERROR, retrying FLAG_DIAGNOSE command.\n"); 15685 sd_dump_memory(un, SD_LOG_IO, "CDB", 15686 (uchar_t *)pktp->pkt_cdbp, CDB_SIZE, SD_LOG_HEX); 15687 sd_dump_memory(un, SD_LOG_IO, "Sense Data", 15688 (uchar_t *)xp->xb_sense_data, SENSE_LENGTH, SD_LOG_HEX); 15689 goto fail_command; 15690 } 15691 15692 /* 15693 * If we are suspended, then put the command onto head of the 15694 * wait queue since we don't want to start more commands, and 15695 * clear the un_retry_bp. Next time when we are resumed, will 15696 * handle the command in the wait queue. 15697 */ 15698 switch (un->un_state) { 15699 case SD_STATE_SUSPENDED: 15700 case SD_STATE_DUMPING: 15701 bp->av_forw = un->un_waitq_headp; 15702 un->un_waitq_headp = bp; 15703 if (un->un_waitq_tailp == NULL) { 15704 un->un_waitq_tailp = bp; 15705 } 15706 if (bp == un->un_retry_bp) { 15707 un->un_retry_bp = NULL; 15708 un->un_retry_statp = NULL; 15709 } 15710 SD_UPDATE_KSTATS(un, kstat_waitq_enter, bp); 15711 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_retry_command: " 15712 "exiting; cmd bp:0x%p requeued for SUSPEND/DUMP\n", bp); 15713 return; 15714 default: 15715 break; 15716 } 15717 15718 /* 15719 * If the caller wants us to check FLAG_ISOLATE, then see if that 15720 * is set; if it is then we do not want to retry the command. 15721 * Normally, FLAG_ISOLATE is only used with USCSI cmds. 15722 */ 15723 if ((retry_check_flag & SD_RETRIES_ISOLATE) != 0) { 15724 if ((pktp->pkt_flags & FLAG_ISOLATE) != 0) { 15725 goto fail_command; 15726 } 15727 } 15728 15729 15730 /* 15731 * If SD_RETRIES_FAILFAST is set, it indicates that either a 15732 * command timeout or a selection timeout has occurred. This means 15733 * that we were unable to establish an kind of communication with 15734 * the target, and subsequent retries and/or commands are likely 15735 * to encounter similar results and take a long time to complete. 15736 * 15737 * If this is a failfast error condition, we need to update the 15738 * failfast state, even if this bp does not have B_FAILFAST set. 15739 */ 15740 if (retry_check_flag & SD_RETRIES_FAILFAST) { 15741 if (un->un_failfast_state == SD_FAILFAST_ACTIVE) { 15742 ASSERT(un->un_failfast_bp == NULL); 15743 /* 15744 * If we are already in the active failfast state, and 15745 * another failfast error condition has been detected, 15746 * then fail this command if it has B_FAILFAST set. 15747 * If B_FAILFAST is clear, then maintain the legacy 15748 * behavior of retrying heroically, even tho this will 15749 * take a lot more time to fail the command. 15750 */ 15751 if (bp->b_flags & B_FAILFAST) { 15752 goto fail_command; 15753 } 15754 } else { 15755 /* 15756 * We're not in the active failfast state, but we 15757 * have a failfast error condition, so we must begin 15758 * transition to the next state. We do this regardless 15759 * of whether or not this bp has B_FAILFAST set. 15760 */ 15761 if (un->un_failfast_bp == NULL) { 15762 /* 15763 * This is the first bp to meet a failfast 15764 * condition so save it on un_failfast_bp & 15765 * do normal retry processing. Do not enter 15766 * active failfast state yet. This marks 15767 * entry into the "failfast pending" state. 15768 */ 15769 un->un_failfast_bp = bp; 15770 15771 } else if (un->un_failfast_bp == bp) { 15772 /* 15773 * This is the second time *this* bp has 15774 * encountered a failfast error condition, 15775 * so enter active failfast state & flush 15776 * queues as appropriate. 15777 */ 15778 un->un_failfast_state = SD_FAILFAST_ACTIVE; 15779 un->un_failfast_bp = NULL; 15780 sd_failfast_flushq(un); 15781 15782 /* 15783 * Fail this bp now if B_FAILFAST set; 15784 * otherwise continue with retries. (It would 15785 * be pretty ironic if this bp succeeded on a 15786 * subsequent retry after we just flushed all 15787 * the queues). 15788 */ 15789 if (bp->b_flags & B_FAILFAST) { 15790 goto fail_command; 15791 } 15792 15793 #if !defined(lint) && !defined(__lint) 15794 } else { 15795 /* 15796 * If neither of the preceeding conditionals 15797 * was true, it means that there is some 15798 * *other* bp that has met an inital failfast 15799 * condition and is currently either being 15800 * retried or is waiting to be retried. In 15801 * that case we should perform normal retry 15802 * processing on *this* bp, since there is a 15803 * chance that the current failfast condition 15804 * is transient and recoverable. If that does 15805 * not turn out to be the case, then retries 15806 * will be cleared when the wait queue is 15807 * flushed anyway. 15808 */ 15809 #endif 15810 } 15811 } 15812 } else { 15813 /* 15814 * SD_RETRIES_FAILFAST is clear, which indicates that we 15815 * likely were able to at least establish some level of 15816 * communication with the target and subsequent commands 15817 * and/or retries are likely to get through to the target, 15818 * In this case we want to be aggressive about clearing 15819 * the failfast state. Note that this does not affect 15820 * the "failfast pending" condition. 15821 */ 15822 un->un_failfast_state = SD_FAILFAST_INACTIVE; 15823 } 15824 15825 15826 /* 15827 * Check the specified retry count to see if we can still do 15828 * any retries with this pkt before we should fail it. 15829 */ 15830 switch (retry_check_flag & SD_RETRIES_MASK) { 15831 case SD_RETRIES_VICTIM: 15832 /* 15833 * Check the victim retry count. If exhausted, then fall 15834 * thru & check against the standard retry count. 15835 */ 15836 if (xp->xb_victim_retry_count < un->un_victim_retry_count) { 15837 /* Increment count & proceed with the retry */ 15838 xp->xb_victim_retry_count++; 15839 break; 15840 } 15841 /* Victim retries exhausted, fall back to std. retries... */ 15842 /* FALLTHRU */ 15843 15844 case SD_RETRIES_STANDARD: 15845 if (xp->xb_retry_count >= un->un_retry_count) { 15846 /* Retries exhausted, fail the command */ 15847 SD_TRACE(SD_LOG_IO_CORE, un, 15848 "sd_retry_command: retries exhausted!\n"); 15849 /* 15850 * update b_resid for failed SCMD_READ & SCMD_WRITE 15851 * commands with nonzero pkt_resid. 15852 */ 15853 if ((pktp->pkt_reason == CMD_CMPLT) && 15854 (SD_GET_PKT_STATUS(pktp) == STATUS_GOOD) && 15855 (pktp->pkt_resid != 0)) { 15856 uchar_t op = SD_GET_PKT_OPCODE(pktp) & 0x1F; 15857 if ((op == SCMD_READ) || (op == SCMD_WRITE)) { 15858 SD_UPDATE_B_RESID(bp, pktp); 15859 } 15860 } 15861 goto fail_command; 15862 } 15863 xp->xb_retry_count++; 15864 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15865 "sd_retry_command: retry count:%d\n", xp->xb_retry_count); 15866 break; 15867 15868 case SD_RETRIES_UA: 15869 if (xp->xb_ua_retry_count >= sd_ua_retry_count) { 15870 /* Retries exhausted, fail the command */ 15871 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 15872 "Unit Attention retries exhausted. " 15873 "Check the target.\n"); 15874 goto fail_command; 15875 } 15876 xp->xb_ua_retry_count++; 15877 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15878 "sd_retry_command: retry count:%d\n", 15879 xp->xb_ua_retry_count); 15880 break; 15881 15882 case SD_RETRIES_BUSY: 15883 if (xp->xb_retry_count >= un->un_busy_retry_count) { 15884 /* Retries exhausted, fail the command */ 15885 SD_TRACE(SD_LOG_IO_CORE, un, 15886 "sd_retry_command: retries exhausted!\n"); 15887 goto fail_command; 15888 } 15889 xp->xb_retry_count++; 15890 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15891 "sd_retry_command: retry count:%d\n", xp->xb_retry_count); 15892 break; 15893 15894 case SD_RETRIES_NOCHECK: 15895 default: 15896 /* No retry count to check. Just proceed with the retry */ 15897 break; 15898 } 15899 15900 xp->xb_pktp->pkt_flags |= FLAG_HEAD; 15901 15902 /* 15903 * If this is a non-USCSI command being retried 15904 * during execution last time, we should post an ereport with 15905 * driver-assessment of the value "retry". 15906 * For partial DMA, request sense and STATUS_QFULL, there are no 15907 * hardware errors, we bypass ereport posting. 15908 */ 15909 if (failure_code != 0) { 15910 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) { 15911 sd_ssc_extract_info(&sfip->fm_ssc, un, pktp, bp, xp); 15912 sd_ssc_post(&sfip->fm_ssc, SD_FM_DRV_RETRY); 15913 } 15914 } 15915 15916 /* 15917 * If we were given a zero timeout, we must attempt to retry the 15918 * command immediately (ie, without a delay). 15919 */ 15920 if (retry_delay == 0) { 15921 /* 15922 * Check some limiting conditions to see if we can actually 15923 * do the immediate retry. If we cannot, then we must 15924 * fall back to queueing up a delayed retry. 15925 */ 15926 if (un->un_ncmds_in_transport >= un->un_throttle) { 15927 /* 15928 * We are at the throttle limit for the target, 15929 * fall back to delayed retry. 15930 */ 15931 retry_delay = un->un_busy_timeout; 15932 statp = kstat_waitq_enter; 15933 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15934 "sd_retry_command: immed. retry hit " 15935 "throttle!\n"); 15936 } else { 15937 /* 15938 * We're clear to proceed with the immediate retry. 15939 * First call the user-provided function (if any) 15940 */ 15941 if (user_funcp != NULL) { 15942 (*user_funcp)(un, bp, user_arg, 15943 SD_IMMEDIATE_RETRY_ISSUED); 15944 #ifdef __lock_lint 15945 sd_print_incomplete_msg(un, bp, user_arg, 15946 SD_IMMEDIATE_RETRY_ISSUED); 15947 sd_print_cmd_incomplete_msg(un, bp, user_arg, 15948 SD_IMMEDIATE_RETRY_ISSUED); 15949 sd_print_sense_failed_msg(un, bp, user_arg, 15950 SD_IMMEDIATE_RETRY_ISSUED); 15951 #endif 15952 } 15953 15954 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15955 "sd_retry_command: issuing immediate retry\n"); 15956 15957 /* 15958 * Call sd_start_cmds() to transport the command to 15959 * the target. 15960 */ 15961 sd_start_cmds(un, bp); 15962 15963 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15964 "sd_retry_command exit\n"); 15965 return; 15966 } 15967 } 15968 15969 /* 15970 * Set up to retry the command after a delay. 15971 * First call the user-provided function (if any) 15972 */ 15973 if (user_funcp != NULL) { 15974 (*user_funcp)(un, bp, user_arg, SD_DELAYED_RETRY_ISSUED); 15975 } 15976 15977 sd_set_retry_bp(un, bp, retry_delay, statp); 15978 15979 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_retry_command: exit\n"); 15980 return; 15981 15982 fail_command: 15983 15984 if (user_funcp != NULL) { 15985 (*user_funcp)(un, bp, user_arg, SD_NO_RETRY_ISSUED); 15986 } 15987 15988 fail_command_no_log: 15989 15990 SD_INFO(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 15991 "sd_retry_command: returning failed command\n"); 15992 15993 sd_return_failed_command(un, bp, failure_code); 15994 15995 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_retry_command: exit\n"); 15996 } 15997 15998 15999 /* 16000 * Function: sd_set_retry_bp 16001 * 16002 * Description: Set up the given bp for retry. 16003 * 16004 * Arguments: un - ptr to associated softstate 16005 * bp - ptr to buf(9S) for the command 16006 * retry_delay - time interval before issuing retry (may be 0) 16007 * statp - optional pointer to kstat function 16008 * 16009 * Context: May be called under interrupt context 16010 */ 16011 16012 static void 16013 sd_set_retry_bp(struct sd_lun *un, struct buf *bp, clock_t retry_delay, 16014 void (*statp)(kstat_io_t *)) 16015 { 16016 ASSERT(un != NULL); 16017 ASSERT(mutex_owned(SD_MUTEX(un))); 16018 ASSERT(bp != NULL); 16019 16020 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, 16021 "sd_set_retry_bp: entry: un:0x%p bp:0x%p\n", un, bp); 16022 16023 /* 16024 * Indicate that the command is being retried. This will not allow any 16025 * other commands on the wait queue to be transported to the target 16026 * until this command has been completed (success or failure). The 16027 * "retry command" is not transported to the target until the given 16028 * time delay expires, unless the user specified a 0 retry_delay. 16029 * 16030 * Note: the timeout(9F) callback routine is what actually calls 16031 * sd_start_cmds() to transport the command, with the exception of a 16032 * zero retry_delay. The only current implementor of a zero retry delay 16033 * is the case where a START_STOP_UNIT is sent to spin-up a device. 16034 */ 16035 if (un->un_retry_bp == NULL) { 16036 ASSERT(un->un_retry_statp == NULL); 16037 un->un_retry_bp = bp; 16038 16039 /* 16040 * If the user has not specified a delay the command should 16041 * be queued and no timeout should be scheduled. 16042 */ 16043 if (retry_delay == 0) { 16044 /* 16045 * Save the kstat pointer that will be used in the 16046 * call to SD_UPDATE_KSTATS() below, so that 16047 * sd_start_cmds() can correctly decrement the waitq 16048 * count when it is time to transport this command. 16049 */ 16050 un->un_retry_statp = statp; 16051 goto done; 16052 } 16053 } 16054 16055 if (un->un_retry_bp == bp) { 16056 /* 16057 * Save the kstat pointer that will be used in the call to 16058 * SD_UPDATE_KSTATS() below, so that sd_start_cmds() can 16059 * correctly decrement the waitq count when it is time to 16060 * transport this command. 16061 */ 16062 un->un_retry_statp = statp; 16063 16064 /* 16065 * Schedule a timeout if: 16066 * 1) The user has specified a delay. 16067 * 2) There is not a START_STOP_UNIT callback pending. 16068 * 16069 * If no delay has been specified, then it is up to the caller 16070 * to ensure that IO processing continues without stalling. 16071 * Effectively, this means that the caller will issue the 16072 * required call to sd_start_cmds(). The START_STOP_UNIT 16073 * callback does this after the START STOP UNIT command has 16074 * completed. In either of these cases we should not schedule 16075 * a timeout callback here. Also don't schedule the timeout if 16076 * an SD_PATH_DIRECT_PRIORITY command is waiting to restart. 16077 */ 16078 if ((retry_delay != 0) && (un->un_startstop_timeid == NULL) && 16079 (un->un_direct_priority_timeid == NULL)) { 16080 un->un_retry_timeid = 16081 timeout(sd_start_retry_command, un, retry_delay); 16082 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16083 "sd_set_retry_bp: setting timeout: un: 0x%p" 16084 " bp:0x%p un_retry_timeid:0x%p\n", 16085 un, bp, un->un_retry_timeid); 16086 } 16087 } else { 16088 /* 16089 * We only get in here if there is already another command 16090 * waiting to be retried. In this case, we just put the 16091 * given command onto the wait queue, so it can be transported 16092 * after the current retry command has completed. 16093 * 16094 * Also we have to make sure that if the command at the head 16095 * of the wait queue is the un_failfast_bp, that we do not 16096 * put ahead of it any other commands that are to be retried. 16097 */ 16098 if ((un->un_failfast_bp != NULL) && 16099 (un->un_failfast_bp == un->un_waitq_headp)) { 16100 /* 16101 * Enqueue this command AFTER the first command on 16102 * the wait queue (which is also un_failfast_bp). 16103 */ 16104 bp->av_forw = un->un_waitq_headp->av_forw; 16105 un->un_waitq_headp->av_forw = bp; 16106 if (un->un_waitq_headp == un->un_waitq_tailp) { 16107 un->un_waitq_tailp = bp; 16108 } 16109 } else { 16110 /* Enqueue this command at the head of the waitq. */ 16111 bp->av_forw = un->un_waitq_headp; 16112 un->un_waitq_headp = bp; 16113 if (un->un_waitq_tailp == NULL) { 16114 un->un_waitq_tailp = bp; 16115 } 16116 } 16117 16118 if (statp == NULL) { 16119 statp = kstat_waitq_enter; 16120 } 16121 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16122 "sd_set_retry_bp: un:0x%p already delayed retry\n", un); 16123 } 16124 16125 done: 16126 if (statp != NULL) { 16127 SD_UPDATE_KSTATS(un, statp, bp); 16128 } 16129 16130 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16131 "sd_set_retry_bp: exit un:0x%p\n", un); 16132 } 16133 16134 16135 /* 16136 * Function: sd_start_retry_command 16137 * 16138 * Description: Start the command that has been waiting on the target's 16139 * retry queue. Called from timeout(9F) context after the 16140 * retry delay interval has expired. 16141 * 16142 * Arguments: arg - pointer to associated softstate for the device. 16143 * 16144 * Context: timeout(9F) thread context. May not sleep. 16145 */ 16146 16147 static void 16148 sd_start_retry_command(void *arg) 16149 { 16150 struct sd_lun *un = arg; 16151 16152 ASSERT(un != NULL); 16153 ASSERT(!mutex_owned(SD_MUTEX(un))); 16154 16155 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16156 "sd_start_retry_command: entry\n"); 16157 16158 mutex_enter(SD_MUTEX(un)); 16159 16160 un->un_retry_timeid = NULL; 16161 16162 if (un->un_retry_bp != NULL) { 16163 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16164 "sd_start_retry_command: un:0x%p STARTING bp:0x%p\n", 16165 un, un->un_retry_bp); 16166 sd_start_cmds(un, un->un_retry_bp); 16167 } 16168 16169 mutex_exit(SD_MUTEX(un)); 16170 16171 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16172 "sd_start_retry_command: exit\n"); 16173 } 16174 16175 /* 16176 * Function: sd_rmw_msg_print_handler 16177 * 16178 * Description: If RMW mode is enabled and warning message is triggered 16179 * print I/O count during a fixed interval. 16180 * 16181 * Arguments: arg - pointer to associated softstate for the device. 16182 * 16183 * Context: timeout(9F) thread context. May not sleep. 16184 */ 16185 static void 16186 sd_rmw_msg_print_handler(void *arg) 16187 { 16188 struct sd_lun *un = arg; 16189 16190 ASSERT(un != NULL); 16191 ASSERT(!mutex_owned(SD_MUTEX(un))); 16192 16193 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16194 "sd_rmw_msg_print_handler: entry\n"); 16195 16196 mutex_enter(SD_MUTEX(un)); 16197 16198 if (un->un_rmw_incre_count > 0) { 16199 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 16200 "%"PRIu64" I/O requests are not aligned with %d disk " 16201 "sector size in %ld seconds. They are handled through " 16202 "Read Modify Write but the performance is very low!\n", 16203 un->un_rmw_incre_count, un->un_tgt_blocksize, 16204 drv_hztousec(SD_RMW_MSG_PRINT_TIMEOUT) / 1000000); 16205 un->un_rmw_incre_count = 0; 16206 un->un_rmw_msg_timeid = timeout(sd_rmw_msg_print_handler, 16207 un, SD_RMW_MSG_PRINT_TIMEOUT); 16208 } else { 16209 un->un_rmw_msg_timeid = NULL; 16210 } 16211 16212 mutex_exit(SD_MUTEX(un)); 16213 16214 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16215 "sd_rmw_msg_print_handler: exit\n"); 16216 } 16217 16218 /* 16219 * Function: sd_start_direct_priority_command 16220 * 16221 * Description: Used to re-start an SD_PATH_DIRECT_PRIORITY command that had 16222 * received TRAN_BUSY when we called scsi_transport() to send it 16223 * to the underlying HBA. This function is called from timeout(9F) 16224 * context after the delay interval has expired. 16225 * 16226 * Arguments: arg - pointer to associated buf(9S) to be restarted. 16227 * 16228 * Context: timeout(9F) thread context. May not sleep. 16229 */ 16230 16231 static void 16232 sd_start_direct_priority_command(void *arg) 16233 { 16234 struct buf *priority_bp = arg; 16235 struct sd_lun *un; 16236 16237 ASSERT(priority_bp != NULL); 16238 un = SD_GET_UN(priority_bp); 16239 ASSERT(un != NULL); 16240 ASSERT(!mutex_owned(SD_MUTEX(un))); 16241 16242 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16243 "sd_start_direct_priority_command: entry\n"); 16244 16245 mutex_enter(SD_MUTEX(un)); 16246 un->un_direct_priority_timeid = NULL; 16247 sd_start_cmds(un, priority_bp); 16248 mutex_exit(SD_MUTEX(un)); 16249 16250 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16251 "sd_start_direct_priority_command: exit\n"); 16252 } 16253 16254 16255 /* 16256 * Function: sd_send_request_sense_command 16257 * 16258 * Description: Sends a REQUEST SENSE command to the target 16259 * 16260 * Context: May be called from interrupt context. 16261 */ 16262 16263 static void 16264 sd_send_request_sense_command(struct sd_lun *un, struct buf *bp, 16265 struct scsi_pkt *pktp) 16266 { 16267 ASSERT(bp != NULL); 16268 ASSERT(un != NULL); 16269 ASSERT(mutex_owned(SD_MUTEX(un))); 16270 16271 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_send_request_sense_command: " 16272 "entry: buf:0x%p\n", bp); 16273 16274 /* 16275 * If we are syncing or dumping, then fail the command to avoid a 16276 * recursive callback into scsi_transport(). Also fail the command 16277 * if we are suspended (legacy behavior). 16278 */ 16279 if (ddi_in_panic() || (un->un_state == SD_STATE_SUSPENDED) || 16280 (un->un_state == SD_STATE_DUMPING)) { 16281 sd_return_failed_command(un, bp, EIO); 16282 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16283 "sd_send_request_sense_command: syncing/dumping, exit\n"); 16284 return; 16285 } 16286 16287 /* 16288 * Retry the failed command and don't issue the request sense if: 16289 * 1) the sense buf is busy 16290 * 2) we have 1 or more outstanding commands on the target 16291 * (the sense data will be cleared or invalidated any way) 16292 * 16293 * Note: There could be an issue with not checking a retry limit here, 16294 * the problem is determining which retry limit to check. 16295 */ 16296 if ((un->un_sense_isbusy != 0) || (un->un_ncmds_in_transport > 0)) { 16297 /* Don't retry if the command is flagged as non-retryable */ 16298 if ((pktp->pkt_flags & FLAG_DIAGNOSE) == 0) { 16299 sd_retry_command(un, bp, SD_RETRIES_NOCHECK, 16300 NULL, NULL, 0, un->un_busy_timeout, 16301 kstat_waitq_enter); 16302 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16303 "sd_send_request_sense_command: " 16304 "at full throttle, retrying exit\n"); 16305 } else { 16306 sd_return_failed_command(un, bp, EIO); 16307 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16308 "sd_send_request_sense_command: " 16309 "at full throttle, non-retryable exit\n"); 16310 } 16311 return; 16312 } 16313 16314 sd_mark_rqs_busy(un, bp); 16315 sd_start_cmds(un, un->un_rqs_bp); 16316 16317 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16318 "sd_send_request_sense_command: exit\n"); 16319 } 16320 16321 16322 /* 16323 * Function: sd_mark_rqs_busy 16324 * 16325 * Description: Indicate that the request sense bp for this instance is 16326 * in use. 16327 * 16328 * Context: May be called under interrupt context 16329 */ 16330 16331 static void 16332 sd_mark_rqs_busy(struct sd_lun *un, struct buf *bp) 16333 { 16334 struct sd_xbuf *sense_xp; 16335 16336 ASSERT(un != NULL); 16337 ASSERT(bp != NULL); 16338 ASSERT(mutex_owned(SD_MUTEX(un))); 16339 ASSERT(un->un_sense_isbusy == 0); 16340 16341 SD_TRACE(SD_LOG_IO_CORE, un, "sd_mark_rqs_busy: entry: " 16342 "buf:0x%p xp:0x%p un:0x%p\n", bp, SD_GET_XBUF(bp), un); 16343 16344 sense_xp = SD_GET_XBUF(un->un_rqs_bp); 16345 ASSERT(sense_xp != NULL); 16346 16347 SD_INFO(SD_LOG_IO, un, 16348 "sd_mark_rqs_busy: entry: sense_xp:0x%p\n", sense_xp); 16349 16350 ASSERT(sense_xp->xb_pktp != NULL); 16351 ASSERT((sense_xp->xb_pktp->pkt_flags & (FLAG_SENSING | FLAG_HEAD)) 16352 == (FLAG_SENSING | FLAG_HEAD)); 16353 16354 un->un_sense_isbusy = 1; 16355 un->un_rqs_bp->b_resid = 0; 16356 sense_xp->xb_pktp->pkt_resid = 0; 16357 sense_xp->xb_pktp->pkt_reason = 0; 16358 16359 /* So we can get back the bp at interrupt time! */ 16360 sense_xp->xb_sense_bp = bp; 16361 16362 bzero(un->un_rqs_bp->b_un.b_addr, SENSE_LENGTH); 16363 16364 /* 16365 * Mark this buf as awaiting sense data. (This is already set in 16366 * the pkt_flags for the RQS packet.) 16367 */ 16368 ((SD_GET_XBUF(bp))->xb_pktp)->pkt_flags |= FLAG_SENSING; 16369 16370 /* Request sense down same path */ 16371 if (scsi_pkt_allocated_correctly((SD_GET_XBUF(bp))->xb_pktp) && 16372 ((SD_GET_XBUF(bp))->xb_pktp)->pkt_path_instance) 16373 sense_xp->xb_pktp->pkt_path_instance = 16374 ((SD_GET_XBUF(bp))->xb_pktp)->pkt_path_instance; 16375 16376 sense_xp->xb_retry_count = 0; 16377 sense_xp->xb_victim_retry_count = 0; 16378 sense_xp->xb_ua_retry_count = 0; 16379 sense_xp->xb_nr_retry_count = 0; 16380 sense_xp->xb_dma_resid = 0; 16381 16382 /* Clean up the fields for auto-request sense */ 16383 sense_xp->xb_sense_status = 0; 16384 sense_xp->xb_sense_state = 0; 16385 sense_xp->xb_sense_resid = 0; 16386 bzero(sense_xp->xb_sense_data, sizeof (sense_xp->xb_sense_data)); 16387 16388 SD_TRACE(SD_LOG_IO_CORE, un, "sd_mark_rqs_busy: exit\n"); 16389 } 16390 16391 16392 /* 16393 * Function: sd_mark_rqs_idle 16394 * 16395 * Description: SD_MUTEX must be held continuously through this routine 16396 * to prevent reuse of the rqs struct before the caller can 16397 * complete it's processing. 16398 * 16399 * Return Code: Pointer to the RQS buf 16400 * 16401 * Context: May be called under interrupt context 16402 */ 16403 16404 static struct buf * 16405 sd_mark_rqs_idle(struct sd_lun *un, struct sd_xbuf *sense_xp) 16406 { 16407 struct buf *bp; 16408 ASSERT(un != NULL); 16409 ASSERT(sense_xp != NULL); 16410 ASSERT(mutex_owned(SD_MUTEX(un))); 16411 ASSERT(un->un_sense_isbusy != 0); 16412 16413 un->un_sense_isbusy = 0; 16414 bp = sense_xp->xb_sense_bp; 16415 sense_xp->xb_sense_bp = NULL; 16416 16417 /* This pkt is no longer interested in getting sense data */ 16418 ((SD_GET_XBUF(bp))->xb_pktp)->pkt_flags &= ~FLAG_SENSING; 16419 16420 return (bp); 16421 } 16422 16423 16424 16425 /* 16426 * Function: sd_alloc_rqs 16427 * 16428 * Description: Set up the unit to receive auto request sense data 16429 * 16430 * Return Code: DDI_SUCCESS or DDI_FAILURE 16431 * 16432 * Context: Called under attach(9E) context 16433 */ 16434 16435 static int 16436 sd_alloc_rqs(struct scsi_device *devp, struct sd_lun *un) 16437 { 16438 struct sd_xbuf *xp; 16439 16440 ASSERT(un != NULL); 16441 ASSERT(!mutex_owned(SD_MUTEX(un))); 16442 ASSERT(un->un_rqs_bp == NULL); 16443 ASSERT(un->un_rqs_pktp == NULL); 16444 16445 /* 16446 * First allocate the required buf and scsi_pkt structs, then set up 16447 * the CDB in the scsi_pkt for a REQUEST SENSE command. 16448 */ 16449 un->un_rqs_bp = scsi_alloc_consistent_buf(&devp->sd_address, NULL, 16450 MAX_SENSE_LENGTH, B_READ, SLEEP_FUNC, NULL); 16451 if (un->un_rqs_bp == NULL) { 16452 return (DDI_FAILURE); 16453 } 16454 16455 un->un_rqs_pktp = scsi_init_pkt(&devp->sd_address, NULL, un->un_rqs_bp, 16456 CDB_GROUP0, 1, 0, PKT_CONSISTENT, SLEEP_FUNC, NULL); 16457 16458 if (un->un_rqs_pktp == NULL) { 16459 sd_free_rqs(un); 16460 return (DDI_FAILURE); 16461 } 16462 16463 /* Set up the CDB in the scsi_pkt for a REQUEST SENSE command. */ 16464 (void) scsi_setup_cdb((union scsi_cdb *)un->un_rqs_pktp->pkt_cdbp, 16465 SCMD_REQUEST_SENSE, 0, MAX_SENSE_LENGTH, 0); 16466 16467 SD_FILL_SCSI1_LUN(un, un->un_rqs_pktp); 16468 16469 /* Set up the other needed members in the ARQ scsi_pkt. */ 16470 un->un_rqs_pktp->pkt_comp = sdintr; 16471 un->un_rqs_pktp->pkt_time = sd_io_time; 16472 un->un_rqs_pktp->pkt_flags |= 16473 (FLAG_SENSING | FLAG_HEAD); /* (1222170) */ 16474 16475 /* 16476 * Allocate & init the sd_xbuf struct for the RQS command. Do not 16477 * provide any intpkt, destroypkt routines as we take care of 16478 * scsi_pkt allocation/freeing here and in sd_free_rqs(). 16479 */ 16480 xp = kmem_alloc(sizeof (struct sd_xbuf), KM_SLEEP); 16481 sd_xbuf_init(un, un->un_rqs_bp, xp, SD_CHAIN_NULL, NULL); 16482 xp->xb_pktp = un->un_rqs_pktp; 16483 SD_INFO(SD_LOG_ATTACH_DETACH, un, 16484 "sd_alloc_rqs: un 0x%p, rqs xp 0x%p, pkt 0x%p, buf 0x%p\n", 16485 un, xp, un->un_rqs_pktp, un->un_rqs_bp); 16486 16487 /* 16488 * Save the pointer to the request sense private bp so it can 16489 * be retrieved in sdintr. 16490 */ 16491 un->un_rqs_pktp->pkt_private = un->un_rqs_bp; 16492 ASSERT(un->un_rqs_bp->b_private == xp); 16493 16494 /* 16495 * See if the HBA supports auto-request sense for the specified 16496 * target/lun. If it does, then try to enable it (if not already 16497 * enabled). 16498 * 16499 * Note: For some HBAs (ifp & sf), scsi_ifsetcap will always return 16500 * failure, while for other HBAs (pln) scsi_ifsetcap will always 16501 * return success. However, in both of these cases ARQ is always 16502 * enabled and scsi_ifgetcap will always return true. The best approach 16503 * is to issue the scsi_ifgetcap() first, then try the scsi_ifsetcap(). 16504 * 16505 * The 3rd case is the HBA (adp) always return enabled on 16506 * scsi_ifgetgetcap even when it's not enable, the best approach 16507 * is issue a scsi_ifsetcap then a scsi_ifgetcap 16508 * Note: this case is to circumvent the Adaptec bug. (x86 only) 16509 */ 16510 16511 if (un->un_f_is_fibre == TRUE) { 16512 un->un_f_arq_enabled = TRUE; 16513 } else { 16514 #if defined(__i386) || defined(__amd64) 16515 /* 16516 * Circumvent the Adaptec bug, remove this code when 16517 * the bug is fixed 16518 */ 16519 (void) scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 1, 1); 16520 #endif 16521 switch (scsi_ifgetcap(SD_ADDRESS(un), "auto-rqsense", 1)) { 16522 case 0: 16523 SD_INFO(SD_LOG_ATTACH_DETACH, un, 16524 "sd_alloc_rqs: HBA supports ARQ\n"); 16525 /* 16526 * ARQ is supported by this HBA but currently is not 16527 * enabled. Attempt to enable it and if successful then 16528 * mark this instance as ARQ enabled. 16529 */ 16530 if (scsi_ifsetcap(SD_ADDRESS(un), "auto-rqsense", 1, 1) 16531 == 1) { 16532 /* Successfully enabled ARQ in the HBA */ 16533 SD_INFO(SD_LOG_ATTACH_DETACH, un, 16534 "sd_alloc_rqs: ARQ enabled\n"); 16535 un->un_f_arq_enabled = TRUE; 16536 } else { 16537 /* Could not enable ARQ in the HBA */ 16538 SD_INFO(SD_LOG_ATTACH_DETACH, un, 16539 "sd_alloc_rqs: failed ARQ enable\n"); 16540 un->un_f_arq_enabled = FALSE; 16541 } 16542 break; 16543 case 1: 16544 /* 16545 * ARQ is supported by this HBA and is already enabled. 16546 * Just mark ARQ as enabled for this instance. 16547 */ 16548 SD_INFO(SD_LOG_ATTACH_DETACH, un, 16549 "sd_alloc_rqs: ARQ already enabled\n"); 16550 un->un_f_arq_enabled = TRUE; 16551 break; 16552 default: 16553 /* 16554 * ARQ is not supported by this HBA; disable it for this 16555 * instance. 16556 */ 16557 SD_INFO(SD_LOG_ATTACH_DETACH, un, 16558 "sd_alloc_rqs: HBA does not support ARQ\n"); 16559 un->un_f_arq_enabled = FALSE; 16560 break; 16561 } 16562 } 16563 16564 return (DDI_SUCCESS); 16565 } 16566 16567 16568 /* 16569 * Function: sd_free_rqs 16570 * 16571 * Description: Cleanup for the pre-instance RQS command. 16572 * 16573 * Context: Kernel thread context 16574 */ 16575 16576 static void 16577 sd_free_rqs(struct sd_lun *un) 16578 { 16579 ASSERT(un != NULL); 16580 16581 SD_TRACE(SD_LOG_IO_CORE, un, "sd_free_rqs: entry\n"); 16582 16583 /* 16584 * If consistent memory is bound to a scsi_pkt, the pkt 16585 * has to be destroyed *before* freeing the consistent memory. 16586 * Don't change the sequence of this operations. 16587 * scsi_destroy_pkt() might access memory, which isn't allowed, 16588 * after it was freed in scsi_free_consistent_buf(). 16589 */ 16590 if (un->un_rqs_pktp != NULL) { 16591 scsi_destroy_pkt(un->un_rqs_pktp); 16592 un->un_rqs_pktp = NULL; 16593 } 16594 16595 if (un->un_rqs_bp != NULL) { 16596 struct sd_xbuf *xp = SD_GET_XBUF(un->un_rqs_bp); 16597 if (xp != NULL) { 16598 kmem_free(xp, sizeof (struct sd_xbuf)); 16599 } 16600 scsi_free_consistent_buf(un->un_rqs_bp); 16601 un->un_rqs_bp = NULL; 16602 } 16603 SD_TRACE(SD_LOG_IO_CORE, un, "sd_free_rqs: exit\n"); 16604 } 16605 16606 16607 16608 /* 16609 * Function: sd_reduce_throttle 16610 * 16611 * Description: Reduces the maximum # of outstanding commands on a 16612 * target to the current number of outstanding commands. 16613 * Queues a tiemout(9F) callback to restore the limit 16614 * after a specified interval has elapsed. 16615 * Typically used when we get a TRAN_BUSY return code 16616 * back from scsi_transport(). 16617 * 16618 * Arguments: un - ptr to the sd_lun softstate struct 16619 * throttle_type: SD_THROTTLE_TRAN_BUSY or SD_THROTTLE_QFULL 16620 * 16621 * Context: May be called from interrupt context 16622 */ 16623 16624 static void 16625 sd_reduce_throttle(struct sd_lun *un, int throttle_type) 16626 { 16627 ASSERT(un != NULL); 16628 ASSERT(mutex_owned(SD_MUTEX(un))); 16629 ASSERT(un->un_ncmds_in_transport >= 0); 16630 16631 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reduce_throttle: " 16632 "entry: un:0x%p un_throttle:%d un_ncmds_in_transport:%d\n", 16633 un, un->un_throttle, un->un_ncmds_in_transport); 16634 16635 if (un->un_throttle > 1) { 16636 if (un->un_f_use_adaptive_throttle == TRUE) { 16637 switch (throttle_type) { 16638 case SD_THROTTLE_TRAN_BUSY: 16639 if (un->un_busy_throttle == 0) { 16640 un->un_busy_throttle = un->un_throttle; 16641 } 16642 break; 16643 case SD_THROTTLE_QFULL: 16644 un->un_busy_throttle = 0; 16645 break; 16646 default: 16647 ASSERT(FALSE); 16648 } 16649 16650 if (un->un_ncmds_in_transport > 0) { 16651 un->un_throttle = un->un_ncmds_in_transport; 16652 } 16653 16654 } else { 16655 if (un->un_ncmds_in_transport == 0) { 16656 un->un_throttle = 1; 16657 } else { 16658 un->un_throttle = un->un_ncmds_in_transport; 16659 } 16660 } 16661 } 16662 16663 /* Reschedule the timeout if none is currently active */ 16664 if (un->un_reset_throttle_timeid == NULL) { 16665 un->un_reset_throttle_timeid = timeout(sd_restore_throttle, 16666 un, SD_THROTTLE_RESET_INTERVAL); 16667 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16668 "sd_reduce_throttle: timeout scheduled!\n"); 16669 } 16670 16671 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reduce_throttle: " 16672 "exit: un:0x%p un_throttle:%d\n", un, un->un_throttle); 16673 } 16674 16675 16676 16677 /* 16678 * Function: sd_restore_throttle 16679 * 16680 * Description: Callback function for timeout(9F). Resets the current 16681 * value of un->un_throttle to its default. 16682 * 16683 * Arguments: arg - pointer to associated softstate for the device. 16684 * 16685 * Context: May be called from interrupt context 16686 */ 16687 16688 static void 16689 sd_restore_throttle(void *arg) 16690 { 16691 struct sd_lun *un = arg; 16692 16693 ASSERT(un != NULL); 16694 ASSERT(!mutex_owned(SD_MUTEX(un))); 16695 16696 mutex_enter(SD_MUTEX(un)); 16697 16698 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_restore_throttle: " 16699 "entry: un:0x%p un_throttle:%d\n", un, un->un_throttle); 16700 16701 un->un_reset_throttle_timeid = NULL; 16702 16703 if (un->un_f_use_adaptive_throttle == TRUE) { 16704 /* 16705 * If un_busy_throttle is nonzero, then it contains the 16706 * value that un_throttle was when we got a TRAN_BUSY back 16707 * from scsi_transport(). We want to revert back to this 16708 * value. 16709 * 16710 * In the QFULL case, the throttle limit will incrementally 16711 * increase until it reaches max throttle. 16712 */ 16713 if (un->un_busy_throttle > 0) { 16714 un->un_throttle = un->un_busy_throttle; 16715 un->un_busy_throttle = 0; 16716 } else { 16717 /* 16718 * increase throttle by 10% open gate slowly, schedule 16719 * another restore if saved throttle has not been 16720 * reached 16721 */ 16722 short throttle; 16723 if (sd_qfull_throttle_enable) { 16724 throttle = un->un_throttle + 16725 max((un->un_throttle / 10), 1); 16726 un->un_throttle = 16727 (throttle < un->un_saved_throttle) ? 16728 throttle : un->un_saved_throttle; 16729 if (un->un_throttle < un->un_saved_throttle) { 16730 un->un_reset_throttle_timeid = 16731 timeout(sd_restore_throttle, 16732 un, 16733 SD_QFULL_THROTTLE_RESET_INTERVAL); 16734 } 16735 } 16736 } 16737 16738 /* 16739 * If un_throttle has fallen below the low-water mark, we 16740 * restore the maximum value here (and allow it to ratchet 16741 * down again if necessary). 16742 */ 16743 if (un->un_throttle < un->un_min_throttle) { 16744 un->un_throttle = un->un_saved_throttle; 16745 } 16746 } else { 16747 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_restore_throttle: " 16748 "restoring limit from 0x%x to 0x%x\n", 16749 un->un_throttle, un->un_saved_throttle); 16750 un->un_throttle = un->un_saved_throttle; 16751 } 16752 16753 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, 16754 "sd_restore_throttle: calling sd_start_cmds!\n"); 16755 16756 sd_start_cmds(un, NULL); 16757 16758 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, 16759 "sd_restore_throttle: exit: un:0x%p un_throttle:%d\n", 16760 un, un->un_throttle); 16761 16762 mutex_exit(SD_MUTEX(un)); 16763 16764 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sd_restore_throttle: exit\n"); 16765 } 16766 16767 /* 16768 * Function: sdrunout 16769 * 16770 * Description: Callback routine for scsi_init_pkt when a resource allocation 16771 * fails. 16772 * 16773 * Arguments: arg - a pointer to the sd_lun unit struct for the particular 16774 * soft state instance. 16775 * 16776 * Return Code: The scsi_init_pkt routine allows for the callback function to 16777 * return a 0 indicating the callback should be rescheduled or a 1 16778 * indicating not to reschedule. This routine always returns 1 16779 * because the driver always provides a callback function to 16780 * scsi_init_pkt. This results in a callback always being scheduled 16781 * (via the scsi_init_pkt callback implementation) if a resource 16782 * failure occurs. 16783 * 16784 * Context: This callback function may not block or call routines that block 16785 * 16786 * Note: Using the scsi_init_pkt callback facility can result in an I/O 16787 * request persisting at the head of the list which cannot be 16788 * satisfied even after multiple retries. In the future the driver 16789 * may implement some time of maximum runout count before failing 16790 * an I/O. 16791 */ 16792 16793 static int 16794 sdrunout(caddr_t arg) 16795 { 16796 struct sd_lun *un = (struct sd_lun *)arg; 16797 16798 ASSERT(un != NULL); 16799 ASSERT(!mutex_owned(SD_MUTEX(un))); 16800 16801 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdrunout: entry\n"); 16802 16803 mutex_enter(SD_MUTEX(un)); 16804 sd_start_cmds(un, NULL); 16805 mutex_exit(SD_MUTEX(un)); 16806 /* 16807 * This callback routine always returns 1 (i.e. do not reschedule) 16808 * because we always specify sdrunout as the callback handler for 16809 * scsi_init_pkt inside the call to sd_start_cmds. 16810 */ 16811 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdrunout: exit\n"); 16812 return (1); 16813 } 16814 16815 16816 /* 16817 * Function: sdintr 16818 * 16819 * Description: Completion callback routine for scsi_pkt(9S) structs 16820 * sent to the HBA driver via scsi_transport(9F). 16821 * 16822 * Context: Interrupt context 16823 */ 16824 16825 static void 16826 sdintr(struct scsi_pkt *pktp) 16827 { 16828 struct buf *bp; 16829 struct sd_xbuf *xp; 16830 struct sd_lun *un; 16831 size_t actual_len; 16832 sd_ssc_t *sscp; 16833 16834 ASSERT(pktp != NULL); 16835 bp = (struct buf *)pktp->pkt_private; 16836 ASSERT(bp != NULL); 16837 xp = SD_GET_XBUF(bp); 16838 ASSERT(xp != NULL); 16839 ASSERT(xp->xb_pktp != NULL); 16840 un = SD_GET_UN(bp); 16841 ASSERT(un != NULL); 16842 ASSERT(!mutex_owned(SD_MUTEX(un))); 16843 16844 #ifdef SD_FAULT_INJECTION 16845 16846 SD_INFO(SD_LOG_IOERR, un, "sdintr: sdintr calling Fault injection\n"); 16847 /* SD FaultInjection */ 16848 sd_faultinjection(pktp); 16849 16850 #endif /* SD_FAULT_INJECTION */ 16851 16852 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdintr: entry: buf:0x%p," 16853 " xp:0x%p, un:0x%p\n", bp, xp, un); 16854 16855 mutex_enter(SD_MUTEX(un)); 16856 16857 ASSERT(un->un_fm_private != NULL); 16858 sscp = &((struct sd_fm_internal *)(un->un_fm_private))->fm_ssc; 16859 ASSERT(sscp != NULL); 16860 16861 /* Reduce the count of the #commands currently in transport */ 16862 un->un_ncmds_in_transport--; 16863 ASSERT(un->un_ncmds_in_transport >= 0); 16864 16865 /* Increment counter to indicate that the callback routine is active */ 16866 un->un_in_callback++; 16867 16868 SD_UPDATE_KSTATS(un, kstat_runq_exit, bp); 16869 16870 #ifdef SDDEBUG 16871 if (bp == un->un_retry_bp) { 16872 SD_TRACE(SD_LOG_IO | SD_LOG_ERROR, un, "sdintr: " 16873 "un:0x%p: GOT retry_bp:0x%p un_ncmds_in_transport:%d\n", 16874 un, un->un_retry_bp, un->un_ncmds_in_transport); 16875 } 16876 #endif 16877 16878 /* 16879 * If pkt_reason is CMD_DEV_GONE, fail the command, and update the media 16880 * state if needed. 16881 */ 16882 if (pktp->pkt_reason == CMD_DEV_GONE) { 16883 /* Prevent multiple console messages for the same failure. */ 16884 if (un->un_last_pkt_reason != CMD_DEV_GONE) { 16885 un->un_last_pkt_reason = CMD_DEV_GONE; 16886 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 16887 "Command failed to complete...Device is gone\n"); 16888 } 16889 if (un->un_mediastate != DKIO_DEV_GONE) { 16890 un->un_mediastate = DKIO_DEV_GONE; 16891 cv_broadcast(&un->un_state_cv); 16892 } 16893 /* 16894 * If the command happens to be the REQUEST SENSE command, 16895 * free up the rqs buf and fail the original command. 16896 */ 16897 if (bp == un->un_rqs_bp) { 16898 bp = sd_mark_rqs_idle(un, xp); 16899 } 16900 sd_return_failed_command(un, bp, EIO); 16901 goto exit; 16902 } 16903 16904 if (pktp->pkt_state & STATE_XARQ_DONE) { 16905 SD_TRACE(SD_LOG_COMMON, un, 16906 "sdintr: extra sense data received. pkt=%p\n", pktp); 16907 } 16908 16909 /* 16910 * First see if the pkt has auto-request sense data with it.... 16911 * Look at the packet state first so we don't take a performance 16912 * hit looking at the arq enabled flag unless absolutely necessary. 16913 */ 16914 if ((pktp->pkt_state & STATE_ARQ_DONE) && 16915 (un->un_f_arq_enabled == TRUE)) { 16916 /* 16917 * The HBA did an auto request sense for this command so check 16918 * for FLAG_DIAGNOSE. If set this indicates a uscsi or internal 16919 * driver command that should not be retried. 16920 */ 16921 if ((pktp->pkt_flags & FLAG_DIAGNOSE) != 0) { 16922 /* 16923 * Save the relevant sense info into the xp for the 16924 * original cmd. 16925 */ 16926 struct scsi_arq_status *asp; 16927 asp = (struct scsi_arq_status *)(pktp->pkt_scbp); 16928 xp->xb_sense_status = 16929 *((uchar_t *)(&(asp->sts_rqpkt_status))); 16930 xp->xb_sense_state = asp->sts_rqpkt_state; 16931 xp->xb_sense_resid = asp->sts_rqpkt_resid; 16932 if (pktp->pkt_state & STATE_XARQ_DONE) { 16933 actual_len = MAX_SENSE_LENGTH - 16934 xp->xb_sense_resid; 16935 bcopy(&asp->sts_sensedata, xp->xb_sense_data, 16936 MAX_SENSE_LENGTH); 16937 } else { 16938 if (xp->xb_sense_resid > SENSE_LENGTH) { 16939 actual_len = MAX_SENSE_LENGTH - 16940 xp->xb_sense_resid; 16941 } else { 16942 actual_len = SENSE_LENGTH - 16943 xp->xb_sense_resid; 16944 } 16945 if (xp->xb_pkt_flags & SD_XB_USCSICMD) { 16946 if ((((struct uscsi_cmd *) 16947 (xp->xb_pktinfo))->uscsi_rqlen) > 16948 actual_len) { 16949 xp->xb_sense_resid = 16950 (((struct uscsi_cmd *) 16951 (xp->xb_pktinfo))-> 16952 uscsi_rqlen) - actual_len; 16953 } else { 16954 xp->xb_sense_resid = 0; 16955 } 16956 } 16957 bcopy(&asp->sts_sensedata, xp->xb_sense_data, 16958 SENSE_LENGTH); 16959 } 16960 16961 /* fail the command */ 16962 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16963 "sdintr: arq done and FLAG_DIAGNOSE set\n"); 16964 sd_return_failed_command(un, bp, EIO); 16965 goto exit; 16966 } 16967 16968 #if (defined(__i386) || defined(__amd64)) /* DMAFREE for x86 only */ 16969 /* 16970 * We want to either retry or fail this command, so free 16971 * the DMA resources here. If we retry the command then 16972 * the DMA resources will be reallocated in sd_start_cmds(). 16973 * Note that when PKT_DMA_PARTIAL is used, this reallocation 16974 * causes the *entire* transfer to start over again from the 16975 * beginning of the request, even for PARTIAL chunks that 16976 * have already transferred successfully. 16977 */ 16978 if ((un->un_f_is_fibre == TRUE) && 16979 ((xp->xb_pkt_flags & SD_XB_USCSICMD) == 0) && 16980 ((pktp->pkt_flags & FLAG_SENSING) == 0)) { 16981 scsi_dmafree(pktp); 16982 xp->xb_pkt_flags |= SD_XB_DMA_FREED; 16983 } 16984 #endif 16985 16986 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16987 "sdintr: arq done, sd_handle_auto_request_sense\n"); 16988 16989 sd_handle_auto_request_sense(un, bp, xp, pktp); 16990 goto exit; 16991 } 16992 16993 /* Next see if this is the REQUEST SENSE pkt for the instance */ 16994 if (pktp->pkt_flags & FLAG_SENSING) { 16995 /* This pktp is from the unit's REQUEST_SENSE command */ 16996 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 16997 "sdintr: sd_handle_request_sense\n"); 16998 sd_handle_request_sense(un, bp, xp, pktp); 16999 goto exit; 17000 } 17001 17002 /* 17003 * Check to see if the command successfully completed as requested; 17004 * this is the most common case (and also the hot performance path). 17005 * 17006 * Requirements for successful completion are: 17007 * pkt_reason is CMD_CMPLT and packet status is status good. 17008 * In addition: 17009 * - A residual of zero indicates successful completion no matter what 17010 * the command is. 17011 * - If the residual is not zero and the command is not a read or 17012 * write, then it's still defined as successful completion. In other 17013 * words, if the command is a read or write the residual must be 17014 * zero for successful completion. 17015 * - If the residual is not zero and the command is a read or 17016 * write, and it's a USCSICMD, then it's still defined as 17017 * successful completion. 17018 */ 17019 if ((pktp->pkt_reason == CMD_CMPLT) && 17020 (SD_GET_PKT_STATUS(pktp) == STATUS_GOOD)) { 17021 17022 /* 17023 * Since this command is returned with a good status, we 17024 * can reset the count for Sonoma failover. 17025 */ 17026 un->un_sonoma_failure_count = 0; 17027 17028 /* 17029 * Return all USCSI commands on good status 17030 */ 17031 if (pktp->pkt_resid == 0) { 17032 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17033 "sdintr: returning command for resid == 0\n"); 17034 } else if (((SD_GET_PKT_OPCODE(pktp) & 0x1F) != SCMD_READ) && 17035 ((SD_GET_PKT_OPCODE(pktp) & 0x1F) != SCMD_WRITE)) { 17036 SD_UPDATE_B_RESID(bp, pktp); 17037 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17038 "sdintr: returning command for resid != 0\n"); 17039 } else if (xp->xb_pkt_flags & SD_XB_USCSICMD) { 17040 SD_UPDATE_B_RESID(bp, pktp); 17041 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17042 "sdintr: returning uscsi command\n"); 17043 } else { 17044 goto not_successful; 17045 } 17046 sd_return_command(un, bp); 17047 17048 /* 17049 * Decrement counter to indicate that the callback routine 17050 * is done. 17051 */ 17052 un->un_in_callback--; 17053 ASSERT(un->un_in_callback >= 0); 17054 mutex_exit(SD_MUTEX(un)); 17055 17056 return; 17057 } 17058 17059 not_successful: 17060 17061 #if (defined(__i386) || defined(__amd64)) /* DMAFREE for x86 only */ 17062 /* 17063 * The following is based upon knowledge of the underlying transport 17064 * and its use of DMA resources. This code should be removed when 17065 * PKT_DMA_PARTIAL support is taken out of the disk driver in favor 17066 * of the new PKT_CMD_BREAKUP protocol. See also sd_initpkt_for_buf() 17067 * and sd_start_cmds(). 17068 * 17069 * Free any DMA resources associated with this command if there 17070 * is a chance it could be retried or enqueued for later retry. 17071 * If we keep the DMA binding then mpxio cannot reissue the 17072 * command on another path whenever a path failure occurs. 17073 * 17074 * Note that when PKT_DMA_PARTIAL is used, free/reallocation 17075 * causes the *entire* transfer to start over again from the 17076 * beginning of the request, even for PARTIAL chunks that 17077 * have already transferred successfully. 17078 * 17079 * This is only done for non-uscsi commands (and also skipped for the 17080 * driver's internal RQS command). Also just do this for Fibre Channel 17081 * devices as these are the only ones that support mpxio. 17082 */ 17083 if ((un->un_f_is_fibre == TRUE) && 17084 ((xp->xb_pkt_flags & SD_XB_USCSICMD) == 0) && 17085 ((pktp->pkt_flags & FLAG_SENSING) == 0)) { 17086 scsi_dmafree(pktp); 17087 xp->xb_pkt_flags |= SD_XB_DMA_FREED; 17088 } 17089 #endif 17090 17091 /* 17092 * The command did not successfully complete as requested so check 17093 * for FLAG_DIAGNOSE. If set this indicates a uscsi or internal 17094 * driver command that should not be retried so just return. If 17095 * FLAG_DIAGNOSE is not set the error will be processed below. 17096 */ 17097 if ((pktp->pkt_flags & FLAG_DIAGNOSE) != 0) { 17098 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17099 "sdintr: FLAG_DIAGNOSE: sd_return_failed_command\n"); 17100 /* 17101 * Issue a request sense if a check condition caused the error 17102 * (we handle the auto request sense case above), otherwise 17103 * just fail the command. 17104 */ 17105 if ((pktp->pkt_reason == CMD_CMPLT) && 17106 (SD_GET_PKT_STATUS(pktp) == STATUS_CHECK)) { 17107 sd_send_request_sense_command(un, bp, pktp); 17108 } else { 17109 sd_return_failed_command(un, bp, EIO); 17110 } 17111 goto exit; 17112 } 17113 17114 /* 17115 * The command did not successfully complete as requested so process 17116 * the error, retry, and/or attempt recovery. 17117 */ 17118 switch (pktp->pkt_reason) { 17119 case CMD_CMPLT: 17120 switch (SD_GET_PKT_STATUS(pktp)) { 17121 case STATUS_GOOD: 17122 /* 17123 * The command completed successfully with a non-zero 17124 * residual 17125 */ 17126 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17127 "sdintr: STATUS_GOOD \n"); 17128 sd_pkt_status_good(un, bp, xp, pktp); 17129 break; 17130 17131 case STATUS_CHECK: 17132 case STATUS_TERMINATED: 17133 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17134 "sdintr: STATUS_TERMINATED | STATUS_CHECK\n"); 17135 sd_pkt_status_check_condition(un, bp, xp, pktp); 17136 break; 17137 17138 case STATUS_BUSY: 17139 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17140 "sdintr: STATUS_BUSY\n"); 17141 sd_pkt_status_busy(un, bp, xp, pktp); 17142 break; 17143 17144 case STATUS_RESERVATION_CONFLICT: 17145 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17146 "sdintr: STATUS_RESERVATION_CONFLICT\n"); 17147 sd_pkt_status_reservation_conflict(un, bp, xp, pktp); 17148 break; 17149 17150 case STATUS_QFULL: 17151 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17152 "sdintr: STATUS_QFULL\n"); 17153 sd_pkt_status_qfull(un, bp, xp, pktp); 17154 break; 17155 17156 case STATUS_MET: 17157 case STATUS_INTERMEDIATE: 17158 case STATUS_SCSI2: 17159 case STATUS_INTERMEDIATE_MET: 17160 case STATUS_ACA_ACTIVE: 17161 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 17162 "Unexpected SCSI status received: 0x%x\n", 17163 SD_GET_PKT_STATUS(pktp)); 17164 /* 17165 * Mark the ssc_flags when detected invalid status 17166 * code for non-USCSI command. 17167 */ 17168 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) { 17169 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_STATUS, 17170 0, "stat-code"); 17171 } 17172 sd_return_failed_command(un, bp, EIO); 17173 break; 17174 17175 default: 17176 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 17177 "Invalid SCSI status received: 0x%x\n", 17178 SD_GET_PKT_STATUS(pktp)); 17179 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) { 17180 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_STATUS, 17181 0, "stat-code"); 17182 } 17183 sd_return_failed_command(un, bp, EIO); 17184 break; 17185 17186 } 17187 break; 17188 17189 case CMD_INCOMPLETE: 17190 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17191 "sdintr: CMD_INCOMPLETE\n"); 17192 sd_pkt_reason_cmd_incomplete(un, bp, xp, pktp); 17193 break; 17194 case CMD_TRAN_ERR: 17195 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17196 "sdintr: CMD_TRAN_ERR\n"); 17197 sd_pkt_reason_cmd_tran_err(un, bp, xp, pktp); 17198 break; 17199 case CMD_RESET: 17200 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17201 "sdintr: CMD_RESET \n"); 17202 sd_pkt_reason_cmd_reset(un, bp, xp, pktp); 17203 break; 17204 case CMD_ABORTED: 17205 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17206 "sdintr: CMD_ABORTED \n"); 17207 sd_pkt_reason_cmd_aborted(un, bp, xp, pktp); 17208 break; 17209 case CMD_TIMEOUT: 17210 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17211 "sdintr: CMD_TIMEOUT\n"); 17212 sd_pkt_reason_cmd_timeout(un, bp, xp, pktp); 17213 break; 17214 case CMD_UNX_BUS_FREE: 17215 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17216 "sdintr: CMD_UNX_BUS_FREE \n"); 17217 sd_pkt_reason_cmd_unx_bus_free(un, bp, xp, pktp); 17218 break; 17219 case CMD_TAG_REJECT: 17220 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17221 "sdintr: CMD_TAG_REJECT\n"); 17222 sd_pkt_reason_cmd_tag_reject(un, bp, xp, pktp); 17223 break; 17224 default: 17225 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 17226 "sdintr: default\n"); 17227 /* 17228 * Mark the ssc_flags for detecting invliad pkt_reason. 17229 */ 17230 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) { 17231 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_PKT_REASON, 17232 0, "pkt-reason"); 17233 } 17234 sd_pkt_reason_default(un, bp, xp, pktp); 17235 break; 17236 } 17237 17238 exit: 17239 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sdintr: exit\n"); 17240 17241 /* Decrement counter to indicate that the callback routine is done. */ 17242 un->un_in_callback--; 17243 ASSERT(un->un_in_callback >= 0); 17244 17245 /* 17246 * At this point, the pkt has been dispatched, ie, it is either 17247 * being re-tried or has been returned to its caller and should 17248 * not be referenced. 17249 */ 17250 17251 mutex_exit(SD_MUTEX(un)); 17252 } 17253 17254 17255 /* 17256 * Function: sd_print_incomplete_msg 17257 * 17258 * Description: Prints the error message for a CMD_INCOMPLETE error. 17259 * 17260 * Arguments: un - ptr to associated softstate for the device. 17261 * bp - ptr to the buf(9S) for the command. 17262 * arg - message string ptr 17263 * code - SD_DELAYED_RETRY_ISSUED, SD_IMMEDIATE_RETRY_ISSUED, 17264 * or SD_NO_RETRY_ISSUED. 17265 * 17266 * Context: May be called under interrupt context 17267 */ 17268 17269 static void 17270 sd_print_incomplete_msg(struct sd_lun *un, struct buf *bp, void *arg, int code) 17271 { 17272 struct scsi_pkt *pktp; 17273 char *msgp; 17274 char *cmdp = arg; 17275 17276 ASSERT(un != NULL); 17277 ASSERT(mutex_owned(SD_MUTEX(un))); 17278 ASSERT(bp != NULL); 17279 ASSERT(arg != NULL); 17280 pktp = SD_GET_PKTP(bp); 17281 ASSERT(pktp != NULL); 17282 17283 switch (code) { 17284 case SD_DELAYED_RETRY_ISSUED: 17285 case SD_IMMEDIATE_RETRY_ISSUED: 17286 msgp = "retrying"; 17287 break; 17288 case SD_NO_RETRY_ISSUED: 17289 default: 17290 msgp = "giving up"; 17291 break; 17292 } 17293 17294 if ((pktp->pkt_flags & FLAG_SILENT) == 0) { 17295 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 17296 "incomplete %s- %s\n", cmdp, msgp); 17297 } 17298 } 17299 17300 17301 17302 /* 17303 * Function: sd_pkt_status_good 17304 * 17305 * Description: Processing for a STATUS_GOOD code in pkt_status. 17306 * 17307 * Context: May be called under interrupt context 17308 */ 17309 17310 static void 17311 sd_pkt_status_good(struct sd_lun *un, struct buf *bp, 17312 struct sd_xbuf *xp, struct scsi_pkt *pktp) 17313 { 17314 char *cmdp; 17315 17316 ASSERT(un != NULL); 17317 ASSERT(mutex_owned(SD_MUTEX(un))); 17318 ASSERT(bp != NULL); 17319 ASSERT(xp != NULL); 17320 ASSERT(pktp != NULL); 17321 ASSERT(pktp->pkt_reason == CMD_CMPLT); 17322 ASSERT(SD_GET_PKT_STATUS(pktp) == STATUS_GOOD); 17323 ASSERT(pktp->pkt_resid != 0); 17324 17325 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_good: entry\n"); 17326 17327 SD_UPDATE_ERRSTATS(un, sd_harderrs); 17328 switch (SD_GET_PKT_OPCODE(pktp) & 0x1F) { 17329 case SCMD_READ: 17330 cmdp = "read"; 17331 break; 17332 case SCMD_WRITE: 17333 cmdp = "write"; 17334 break; 17335 default: 17336 SD_UPDATE_B_RESID(bp, pktp); 17337 sd_return_command(un, bp); 17338 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_good: exit\n"); 17339 return; 17340 } 17341 17342 /* 17343 * See if we can retry the read/write, preferrably immediately. 17344 * If retries are exhaused, then sd_retry_command() will update 17345 * the b_resid count. 17346 */ 17347 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_incomplete_msg, 17348 cmdp, EIO, (clock_t)0, NULL); 17349 17350 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_good: exit\n"); 17351 } 17352 17353 17354 17355 17356 17357 /* 17358 * Function: sd_handle_request_sense 17359 * 17360 * Description: Processing for non-auto Request Sense command. 17361 * 17362 * Arguments: un - ptr to associated softstate 17363 * sense_bp - ptr to buf(9S) for the RQS command 17364 * sense_xp - ptr to the sd_xbuf for the RQS command 17365 * sense_pktp - ptr to the scsi_pkt(9S) for the RQS command 17366 * 17367 * Context: May be called under interrupt context 17368 */ 17369 17370 static void 17371 sd_handle_request_sense(struct sd_lun *un, struct buf *sense_bp, 17372 struct sd_xbuf *sense_xp, struct scsi_pkt *sense_pktp) 17373 { 17374 struct buf *cmd_bp; /* buf for the original command */ 17375 struct sd_xbuf *cmd_xp; /* sd_xbuf for the original command */ 17376 struct scsi_pkt *cmd_pktp; /* pkt for the original command */ 17377 size_t actual_len; /* actual sense data length */ 17378 17379 ASSERT(un != NULL); 17380 ASSERT(mutex_owned(SD_MUTEX(un))); 17381 ASSERT(sense_bp != NULL); 17382 ASSERT(sense_xp != NULL); 17383 ASSERT(sense_pktp != NULL); 17384 17385 /* 17386 * Note the sense_bp, sense_xp, and sense_pktp here are for the 17387 * RQS command and not the original command. 17388 */ 17389 ASSERT(sense_pktp == un->un_rqs_pktp); 17390 ASSERT(sense_bp == un->un_rqs_bp); 17391 ASSERT((sense_pktp->pkt_flags & (FLAG_SENSING | FLAG_HEAD)) == 17392 (FLAG_SENSING | FLAG_HEAD)); 17393 ASSERT((((SD_GET_XBUF(sense_xp->xb_sense_bp))->xb_pktp->pkt_flags) & 17394 FLAG_SENSING) == FLAG_SENSING); 17395 17396 /* These are the bp, xp, and pktp for the original command */ 17397 cmd_bp = sense_xp->xb_sense_bp; 17398 cmd_xp = SD_GET_XBUF(cmd_bp); 17399 cmd_pktp = SD_GET_PKTP(cmd_bp); 17400 17401 if (sense_pktp->pkt_reason != CMD_CMPLT) { 17402 /* 17403 * The REQUEST SENSE command failed. Release the REQUEST 17404 * SENSE command for re-use, get back the bp for the original 17405 * command, and attempt to re-try the original command if 17406 * FLAG_DIAGNOSE is not set in the original packet. 17407 */ 17408 SD_UPDATE_ERRSTATS(un, sd_harderrs); 17409 if ((cmd_pktp->pkt_flags & FLAG_DIAGNOSE) == 0) { 17410 cmd_bp = sd_mark_rqs_idle(un, sense_xp); 17411 sd_retry_command(un, cmd_bp, SD_RETRIES_STANDARD, 17412 NULL, NULL, EIO, (clock_t)0, NULL); 17413 return; 17414 } 17415 } 17416 17417 /* 17418 * Save the relevant sense info into the xp for the original cmd. 17419 * 17420 * Note: if the request sense failed the state info will be zero 17421 * as set in sd_mark_rqs_busy() 17422 */ 17423 cmd_xp->xb_sense_status = *(sense_pktp->pkt_scbp); 17424 cmd_xp->xb_sense_state = sense_pktp->pkt_state; 17425 actual_len = MAX_SENSE_LENGTH - sense_pktp->pkt_resid; 17426 if ((cmd_xp->xb_pkt_flags & SD_XB_USCSICMD) && 17427 (((struct uscsi_cmd *)cmd_xp->xb_pktinfo)->uscsi_rqlen > 17428 SENSE_LENGTH)) { 17429 bcopy(sense_bp->b_un.b_addr, cmd_xp->xb_sense_data, 17430 MAX_SENSE_LENGTH); 17431 cmd_xp->xb_sense_resid = sense_pktp->pkt_resid; 17432 } else { 17433 bcopy(sense_bp->b_un.b_addr, cmd_xp->xb_sense_data, 17434 SENSE_LENGTH); 17435 if (actual_len < SENSE_LENGTH) { 17436 cmd_xp->xb_sense_resid = SENSE_LENGTH - actual_len; 17437 } else { 17438 cmd_xp->xb_sense_resid = 0; 17439 } 17440 } 17441 17442 /* 17443 * Free up the RQS command.... 17444 * NOTE: 17445 * Must do this BEFORE calling sd_validate_sense_data! 17446 * sd_validate_sense_data may return the original command in 17447 * which case the pkt will be freed and the flags can no 17448 * longer be touched. 17449 * SD_MUTEX is held through this process until the command 17450 * is dispatched based upon the sense data, so there are 17451 * no race conditions. 17452 */ 17453 (void) sd_mark_rqs_idle(un, sense_xp); 17454 17455 /* 17456 * For a retryable command see if we have valid sense data, if so then 17457 * turn it over to sd_decode_sense() to figure out the right course of 17458 * action. Just fail a non-retryable command. 17459 */ 17460 if ((cmd_pktp->pkt_flags & FLAG_DIAGNOSE) == 0) { 17461 if (sd_validate_sense_data(un, cmd_bp, cmd_xp, actual_len) == 17462 SD_SENSE_DATA_IS_VALID) { 17463 sd_decode_sense(un, cmd_bp, cmd_xp, cmd_pktp); 17464 } 17465 } else { 17466 SD_DUMP_MEMORY(un, SD_LOG_IO_CORE, "Failed CDB", 17467 (uchar_t *)cmd_pktp->pkt_cdbp, CDB_SIZE, SD_LOG_HEX); 17468 SD_DUMP_MEMORY(un, SD_LOG_IO_CORE, "Sense Data", 17469 (uchar_t *)cmd_xp->xb_sense_data, SENSE_LENGTH, SD_LOG_HEX); 17470 sd_return_failed_command(un, cmd_bp, EIO); 17471 } 17472 } 17473 17474 17475 17476 17477 /* 17478 * Function: sd_handle_auto_request_sense 17479 * 17480 * Description: Processing for auto-request sense information. 17481 * 17482 * Arguments: un - ptr to associated softstate 17483 * bp - ptr to buf(9S) for the command 17484 * xp - ptr to the sd_xbuf for the command 17485 * pktp - ptr to the scsi_pkt(9S) for the command 17486 * 17487 * Context: May be called under interrupt context 17488 */ 17489 17490 static void 17491 sd_handle_auto_request_sense(struct sd_lun *un, struct buf *bp, 17492 struct sd_xbuf *xp, struct scsi_pkt *pktp) 17493 { 17494 struct scsi_arq_status *asp; 17495 size_t actual_len; 17496 17497 ASSERT(un != NULL); 17498 ASSERT(mutex_owned(SD_MUTEX(un))); 17499 ASSERT(bp != NULL); 17500 ASSERT(xp != NULL); 17501 ASSERT(pktp != NULL); 17502 ASSERT(pktp != un->un_rqs_pktp); 17503 ASSERT(bp != un->un_rqs_bp); 17504 17505 /* 17506 * For auto-request sense, we get a scsi_arq_status back from 17507 * the HBA, with the sense data in the sts_sensedata member. 17508 * The pkt_scbp of the packet points to this scsi_arq_status. 17509 */ 17510 asp = (struct scsi_arq_status *)(pktp->pkt_scbp); 17511 17512 if (asp->sts_rqpkt_reason != CMD_CMPLT) { 17513 /* 17514 * The auto REQUEST SENSE failed; see if we can re-try 17515 * the original command. 17516 */ 17517 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 17518 "auto request sense failed (reason=%s)\n", 17519 scsi_rname(asp->sts_rqpkt_reason)); 17520 17521 sd_reset_target(un, pktp); 17522 17523 sd_retry_command(un, bp, SD_RETRIES_STANDARD, 17524 NULL, NULL, EIO, (clock_t)0, NULL); 17525 return; 17526 } 17527 17528 /* Save the relevant sense info into the xp for the original cmd. */ 17529 xp->xb_sense_status = *((uchar_t *)(&(asp->sts_rqpkt_status))); 17530 xp->xb_sense_state = asp->sts_rqpkt_state; 17531 xp->xb_sense_resid = asp->sts_rqpkt_resid; 17532 if (xp->xb_sense_state & STATE_XARQ_DONE) { 17533 actual_len = MAX_SENSE_LENGTH - xp->xb_sense_resid; 17534 bcopy(&asp->sts_sensedata, xp->xb_sense_data, 17535 MAX_SENSE_LENGTH); 17536 } else { 17537 if (xp->xb_sense_resid > SENSE_LENGTH) { 17538 actual_len = MAX_SENSE_LENGTH - xp->xb_sense_resid; 17539 } else { 17540 actual_len = SENSE_LENGTH - xp->xb_sense_resid; 17541 } 17542 if (xp->xb_pkt_flags & SD_XB_USCSICMD) { 17543 if ((((struct uscsi_cmd *) 17544 (xp->xb_pktinfo))->uscsi_rqlen) > actual_len) { 17545 xp->xb_sense_resid = (((struct uscsi_cmd *) 17546 (xp->xb_pktinfo))->uscsi_rqlen) - 17547 actual_len; 17548 } else { 17549 xp->xb_sense_resid = 0; 17550 } 17551 } 17552 bcopy(&asp->sts_sensedata, xp->xb_sense_data, SENSE_LENGTH); 17553 } 17554 17555 /* 17556 * See if we have valid sense data, if so then turn it over to 17557 * sd_decode_sense() to figure out the right course of action. 17558 */ 17559 if (sd_validate_sense_data(un, bp, xp, actual_len) == 17560 SD_SENSE_DATA_IS_VALID) { 17561 sd_decode_sense(un, bp, xp, pktp); 17562 } 17563 } 17564 17565 17566 /* 17567 * Function: sd_print_sense_failed_msg 17568 * 17569 * Description: Print log message when RQS has failed. 17570 * 17571 * Arguments: un - ptr to associated softstate 17572 * bp - ptr to buf(9S) for the command 17573 * arg - generic message string ptr 17574 * code - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED, 17575 * or SD_NO_RETRY_ISSUED 17576 * 17577 * Context: May be called from interrupt context 17578 */ 17579 17580 static void 17581 sd_print_sense_failed_msg(struct sd_lun *un, struct buf *bp, void *arg, 17582 int code) 17583 { 17584 char *msgp = arg; 17585 17586 ASSERT(un != NULL); 17587 ASSERT(mutex_owned(SD_MUTEX(un))); 17588 ASSERT(bp != NULL); 17589 17590 if ((code == SD_NO_RETRY_ISSUED) && (msgp != NULL)) { 17591 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, msgp); 17592 } 17593 } 17594 17595 17596 /* 17597 * Function: sd_validate_sense_data 17598 * 17599 * Description: Check the given sense data for validity. 17600 * If the sense data is not valid, the command will 17601 * be either failed or retried! 17602 * 17603 * Return Code: SD_SENSE_DATA_IS_INVALID 17604 * SD_SENSE_DATA_IS_VALID 17605 * 17606 * Context: May be called from interrupt context 17607 */ 17608 17609 static int 17610 sd_validate_sense_data(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp, 17611 size_t actual_len) 17612 { 17613 struct scsi_extended_sense *esp; 17614 struct scsi_pkt *pktp; 17615 char *msgp = NULL; 17616 sd_ssc_t *sscp; 17617 17618 ASSERT(un != NULL); 17619 ASSERT(mutex_owned(SD_MUTEX(un))); 17620 ASSERT(bp != NULL); 17621 ASSERT(bp != un->un_rqs_bp); 17622 ASSERT(xp != NULL); 17623 ASSERT(un->un_fm_private != NULL); 17624 17625 pktp = SD_GET_PKTP(bp); 17626 ASSERT(pktp != NULL); 17627 17628 sscp = &((struct sd_fm_internal *)(un->un_fm_private))->fm_ssc; 17629 ASSERT(sscp != NULL); 17630 17631 /* 17632 * Check the status of the RQS command (auto or manual). 17633 */ 17634 switch (xp->xb_sense_status & STATUS_MASK) { 17635 case STATUS_GOOD: 17636 break; 17637 17638 case STATUS_RESERVATION_CONFLICT: 17639 sd_pkt_status_reservation_conflict(un, bp, xp, pktp); 17640 return (SD_SENSE_DATA_IS_INVALID); 17641 17642 case STATUS_BUSY: 17643 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 17644 "Busy Status on REQUEST SENSE\n"); 17645 sd_retry_command(un, bp, SD_RETRIES_BUSY, NULL, 17646 NULL, EIO, un->un_busy_timeout / 500, kstat_waitq_enter); 17647 return (SD_SENSE_DATA_IS_INVALID); 17648 17649 case STATUS_QFULL: 17650 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 17651 "QFULL Status on REQUEST SENSE\n"); 17652 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, 17653 NULL, EIO, un->un_busy_timeout / 500, kstat_waitq_enter); 17654 return (SD_SENSE_DATA_IS_INVALID); 17655 17656 case STATUS_CHECK: 17657 case STATUS_TERMINATED: 17658 msgp = "Check Condition on REQUEST SENSE\n"; 17659 goto sense_failed; 17660 17661 default: 17662 msgp = "Not STATUS_GOOD on REQUEST_SENSE\n"; 17663 goto sense_failed; 17664 } 17665 17666 /* 17667 * See if we got the minimum required amount of sense data. 17668 * Note: We are assuming the returned sense data is SENSE_LENGTH bytes 17669 * or less. 17670 */ 17671 if (((xp->xb_sense_state & STATE_XFERRED_DATA) == 0) || 17672 (actual_len == 0)) { 17673 msgp = "Request Sense couldn't get sense data\n"; 17674 goto sense_failed; 17675 } 17676 17677 if (actual_len < SUN_MIN_SENSE_LENGTH) { 17678 msgp = "Not enough sense information\n"; 17679 /* Mark the ssc_flags for detecting invalid sense data */ 17680 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) { 17681 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_SENSE, 0, 17682 "sense-data"); 17683 } 17684 goto sense_failed; 17685 } 17686 17687 /* 17688 * We require the extended sense data 17689 */ 17690 esp = (struct scsi_extended_sense *)xp->xb_sense_data; 17691 if (esp->es_class != CLASS_EXTENDED_SENSE) { 17692 if ((pktp->pkt_flags & FLAG_SILENT) == 0) { 17693 static char tmp[8]; 17694 static char buf[148]; 17695 char *p = (char *)(xp->xb_sense_data); 17696 int i; 17697 17698 mutex_enter(&sd_sense_mutex); 17699 (void) strcpy(buf, "undecodable sense information:"); 17700 for (i = 0; i < actual_len; i++) { 17701 (void) sprintf(tmp, " 0x%x", *(p++)&0xff); 17702 (void) strcpy(&buf[strlen(buf)], tmp); 17703 } 17704 i = strlen(buf); 17705 (void) strcpy(&buf[i], "-(assumed fatal)\n"); 17706 17707 if (SD_FM_LOG(un) == SD_FM_LOG_NSUP) { 17708 scsi_log(SD_DEVINFO(un), sd_label, 17709 CE_WARN, buf); 17710 } 17711 mutex_exit(&sd_sense_mutex); 17712 } 17713 17714 /* Mark the ssc_flags for detecting invalid sense data */ 17715 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) { 17716 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_SENSE, 0, 17717 "sense-data"); 17718 } 17719 17720 /* Note: Legacy behavior, fail the command with no retry */ 17721 sd_return_failed_command(un, bp, EIO); 17722 return (SD_SENSE_DATA_IS_INVALID); 17723 } 17724 17725 /* 17726 * Check that es_code is valid (es_class concatenated with es_code 17727 * make up the "response code" field. es_class will always be 7, so 17728 * make sure es_code is 0, 1, 2, 3 or 0xf. es_code will indicate the 17729 * format. 17730 */ 17731 if ((esp->es_code != CODE_FMT_FIXED_CURRENT) && 17732 (esp->es_code != CODE_FMT_FIXED_DEFERRED) && 17733 (esp->es_code != CODE_FMT_DESCR_CURRENT) && 17734 (esp->es_code != CODE_FMT_DESCR_DEFERRED) && 17735 (esp->es_code != CODE_FMT_VENDOR_SPECIFIC)) { 17736 /* Mark the ssc_flags for detecting invalid sense data */ 17737 if (!(xp->xb_pkt_flags & SD_XB_USCSICMD)) { 17738 sd_ssc_set_info(sscp, SSC_FLAGS_INVALID_SENSE, 0, 17739 "sense-data"); 17740 } 17741 goto sense_failed; 17742 } 17743 17744 return (SD_SENSE_DATA_IS_VALID); 17745 17746 sense_failed: 17747 /* 17748 * If the request sense failed (for whatever reason), attempt 17749 * to retry the original command. 17750 */ 17751 #if defined(__i386) || defined(__amd64) 17752 /* 17753 * SD_RETRY_DELAY is conditionally compile (#if fibre) in 17754 * sddef.h for Sparc platform, and x86 uses 1 binary 17755 * for both SCSI/FC. 17756 * The SD_RETRY_DELAY value need to be adjusted here 17757 * when SD_RETRY_DELAY change in sddef.h 17758 */ 17759 sd_retry_command(un, bp, SD_RETRIES_STANDARD, 17760 sd_print_sense_failed_msg, msgp, EIO, 17761 un->un_f_is_fibre?drv_usectohz(100000):(clock_t)0, NULL); 17762 #else 17763 sd_retry_command(un, bp, SD_RETRIES_STANDARD, 17764 sd_print_sense_failed_msg, msgp, EIO, SD_RETRY_DELAY, NULL); 17765 #endif 17766 17767 return (SD_SENSE_DATA_IS_INVALID); 17768 } 17769 17770 /* 17771 * Function: sd_decode_sense 17772 * 17773 * Description: Take recovery action(s) when SCSI Sense Data is received. 17774 * 17775 * Context: Interrupt context. 17776 */ 17777 17778 static void 17779 sd_decode_sense(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp, 17780 struct scsi_pkt *pktp) 17781 { 17782 uint8_t sense_key; 17783 17784 ASSERT(un != NULL); 17785 ASSERT(mutex_owned(SD_MUTEX(un))); 17786 ASSERT(bp != NULL); 17787 ASSERT(bp != un->un_rqs_bp); 17788 ASSERT(xp != NULL); 17789 ASSERT(pktp != NULL); 17790 17791 sense_key = scsi_sense_key(xp->xb_sense_data); 17792 17793 switch (sense_key) { 17794 case KEY_NO_SENSE: 17795 sd_sense_key_no_sense(un, bp, xp, pktp); 17796 break; 17797 case KEY_RECOVERABLE_ERROR: 17798 sd_sense_key_recoverable_error(un, xp->xb_sense_data, 17799 bp, xp, pktp); 17800 break; 17801 case KEY_NOT_READY: 17802 sd_sense_key_not_ready(un, xp->xb_sense_data, 17803 bp, xp, pktp); 17804 break; 17805 case KEY_MEDIUM_ERROR: 17806 case KEY_HARDWARE_ERROR: 17807 sd_sense_key_medium_or_hardware_error(un, 17808 xp->xb_sense_data, bp, xp, pktp); 17809 break; 17810 case KEY_ILLEGAL_REQUEST: 17811 sd_sense_key_illegal_request(un, bp, xp, pktp); 17812 break; 17813 case KEY_UNIT_ATTENTION: 17814 sd_sense_key_unit_attention(un, xp->xb_sense_data, 17815 bp, xp, pktp); 17816 break; 17817 case KEY_WRITE_PROTECT: 17818 case KEY_VOLUME_OVERFLOW: 17819 case KEY_MISCOMPARE: 17820 sd_sense_key_fail_command(un, bp, xp, pktp); 17821 break; 17822 case KEY_BLANK_CHECK: 17823 sd_sense_key_blank_check(un, bp, xp, pktp); 17824 break; 17825 case KEY_ABORTED_COMMAND: 17826 sd_sense_key_aborted_command(un, bp, xp, pktp); 17827 break; 17828 case KEY_VENDOR_UNIQUE: 17829 case KEY_COPY_ABORTED: 17830 case KEY_EQUAL: 17831 case KEY_RESERVED: 17832 default: 17833 sd_sense_key_default(un, xp->xb_sense_data, 17834 bp, xp, pktp); 17835 break; 17836 } 17837 } 17838 17839 17840 /* 17841 * Function: sd_dump_memory 17842 * 17843 * Description: Debug logging routine to print the contents of a user provided 17844 * buffer. The output of the buffer is broken up into 256 byte 17845 * segments due to a size constraint of the scsi_log. 17846 * implementation. 17847 * 17848 * Arguments: un - ptr to softstate 17849 * comp - component mask 17850 * title - "title" string to preceed data when printed 17851 * data - ptr to data block to be printed 17852 * len - size of data block to be printed 17853 * fmt - SD_LOG_HEX (use 0x%02x format) or SD_LOG_CHAR (use %c) 17854 * 17855 * Context: May be called from interrupt context 17856 */ 17857 17858 #define SD_DUMP_MEMORY_BUF_SIZE 256 17859 17860 static char *sd_dump_format_string[] = { 17861 " 0x%02x", 17862 " %c" 17863 }; 17864 17865 static void 17866 sd_dump_memory(struct sd_lun *un, uint_t comp, char *title, uchar_t *data, 17867 int len, int fmt) 17868 { 17869 int i, j; 17870 int avail_count; 17871 int start_offset; 17872 int end_offset; 17873 size_t entry_len; 17874 char *bufp; 17875 char *local_buf; 17876 char *format_string; 17877 17878 ASSERT((fmt == SD_LOG_HEX) || (fmt == SD_LOG_CHAR)); 17879 17880 /* 17881 * In the debug version of the driver, this function is called from a 17882 * number of places which are NOPs in the release driver. 17883 * The debug driver therefore has additional methods of filtering 17884 * debug output. 17885 */ 17886 #ifdef SDDEBUG 17887 /* 17888 * In the debug version of the driver we can reduce the amount of debug 17889 * messages by setting sd_error_level to something other than 17890 * SCSI_ERR_ALL and clearing bits in sd_level_mask and 17891 * sd_component_mask. 17892 */ 17893 if (((sd_level_mask & (SD_LOGMASK_DUMP_MEM | SD_LOGMASK_DIAG)) == 0) || 17894 (sd_error_level != SCSI_ERR_ALL)) { 17895 return; 17896 } 17897 if (((sd_component_mask & comp) == 0) || 17898 (sd_error_level != SCSI_ERR_ALL)) { 17899 return; 17900 } 17901 #else 17902 if (sd_error_level != SCSI_ERR_ALL) { 17903 return; 17904 } 17905 #endif 17906 17907 local_buf = kmem_zalloc(SD_DUMP_MEMORY_BUF_SIZE, KM_SLEEP); 17908 bufp = local_buf; 17909 /* 17910 * Available length is the length of local_buf[], minus the 17911 * length of the title string, minus one for the ":", minus 17912 * one for the newline, minus one for the NULL terminator. 17913 * This gives the #bytes available for holding the printed 17914 * values from the given data buffer. 17915 */ 17916 if (fmt == SD_LOG_HEX) { 17917 format_string = sd_dump_format_string[0]; 17918 } else /* SD_LOG_CHAR */ { 17919 format_string = sd_dump_format_string[1]; 17920 } 17921 /* 17922 * Available count is the number of elements from the given 17923 * data buffer that we can fit into the available length. 17924 * This is based upon the size of the format string used. 17925 * Make one entry and find it's size. 17926 */ 17927 (void) sprintf(bufp, format_string, data[0]); 17928 entry_len = strlen(bufp); 17929 avail_count = (SD_DUMP_MEMORY_BUF_SIZE - strlen(title) - 3) / entry_len; 17930 17931 j = 0; 17932 while (j < len) { 17933 bufp = local_buf; 17934 bzero(bufp, SD_DUMP_MEMORY_BUF_SIZE); 17935 start_offset = j; 17936 17937 end_offset = start_offset + avail_count; 17938 17939 (void) sprintf(bufp, "%s:", title); 17940 bufp += strlen(bufp); 17941 for (i = start_offset; ((i < end_offset) && (j < len)); 17942 i++, j++) { 17943 (void) sprintf(bufp, format_string, data[i]); 17944 bufp += entry_len; 17945 } 17946 (void) sprintf(bufp, "\n"); 17947 17948 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE, "%s", local_buf); 17949 } 17950 kmem_free(local_buf, SD_DUMP_MEMORY_BUF_SIZE); 17951 } 17952 17953 /* 17954 * Function: sd_print_sense_msg 17955 * 17956 * Description: Log a message based upon the given sense data. 17957 * 17958 * Arguments: un - ptr to associated softstate 17959 * bp - ptr to buf(9S) for the command 17960 * arg - ptr to associate sd_sense_info struct 17961 * code - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED, 17962 * or SD_NO_RETRY_ISSUED 17963 * 17964 * Context: May be called from interrupt context 17965 */ 17966 17967 static void 17968 sd_print_sense_msg(struct sd_lun *un, struct buf *bp, void *arg, int code) 17969 { 17970 struct sd_xbuf *xp; 17971 struct scsi_pkt *pktp; 17972 uint8_t *sensep; 17973 daddr_t request_blkno; 17974 diskaddr_t err_blkno; 17975 int severity; 17976 int pfa_flag; 17977 extern struct scsi_key_strings scsi_cmds[]; 17978 17979 ASSERT(un != NULL); 17980 ASSERT(mutex_owned(SD_MUTEX(un))); 17981 ASSERT(bp != NULL); 17982 xp = SD_GET_XBUF(bp); 17983 ASSERT(xp != NULL); 17984 pktp = SD_GET_PKTP(bp); 17985 ASSERT(pktp != NULL); 17986 ASSERT(arg != NULL); 17987 17988 severity = ((struct sd_sense_info *)(arg))->ssi_severity; 17989 pfa_flag = ((struct sd_sense_info *)(arg))->ssi_pfa_flag; 17990 17991 if ((code == SD_DELAYED_RETRY_ISSUED) || 17992 (code == SD_IMMEDIATE_RETRY_ISSUED)) { 17993 severity = SCSI_ERR_RETRYABLE; 17994 } 17995 17996 /* Use absolute block number for the request block number */ 17997 request_blkno = xp->xb_blkno; 17998 17999 /* 18000 * Now try to get the error block number from the sense data 18001 */ 18002 sensep = xp->xb_sense_data; 18003 18004 if (scsi_sense_info_uint64(sensep, SENSE_LENGTH, 18005 (uint64_t *)&err_blkno)) { 18006 /* 18007 * We retrieved the error block number from the information 18008 * portion of the sense data. 18009 * 18010 * For USCSI commands we are better off using the error 18011 * block no. as the requested block no. (This is the best 18012 * we can estimate.) 18013 */ 18014 if ((SD_IS_BUFIO(xp) == FALSE) && 18015 ((pktp->pkt_flags & FLAG_SILENT) == 0)) { 18016 request_blkno = err_blkno; 18017 } 18018 } else { 18019 /* 18020 * Without the es_valid bit set (for fixed format) or an 18021 * information descriptor (for descriptor format) we cannot 18022 * be certain of the error blkno, so just use the 18023 * request_blkno. 18024 */ 18025 err_blkno = (diskaddr_t)request_blkno; 18026 } 18027 18028 /* 18029 * The following will log the buffer contents for the release driver 18030 * if the SD_LOGMASK_DIAG bit of sd_level_mask is set, or the error 18031 * level is set to verbose. 18032 */ 18033 sd_dump_memory(un, SD_LOG_IO, "Failed CDB", 18034 (uchar_t *)pktp->pkt_cdbp, CDB_SIZE, SD_LOG_HEX); 18035 sd_dump_memory(un, SD_LOG_IO, "Sense Data", 18036 (uchar_t *)sensep, SENSE_LENGTH, SD_LOG_HEX); 18037 18038 if (pfa_flag == FALSE) { 18039 /* This is normally only set for USCSI */ 18040 if ((pktp->pkt_flags & FLAG_SILENT) != 0) { 18041 return; 18042 } 18043 18044 if ((SD_IS_BUFIO(xp) == TRUE) && 18045 (((sd_level_mask & SD_LOGMASK_DIAG) == 0) && 18046 (severity < sd_error_level))) { 18047 return; 18048 } 18049 } 18050 /* 18051 * Check for Sonoma Failover and keep a count of how many failed I/O's 18052 */ 18053 if ((SD_IS_LSI(un)) && 18054 (scsi_sense_key(sensep) == KEY_ILLEGAL_REQUEST) && 18055 (scsi_sense_asc(sensep) == 0x94) && 18056 (scsi_sense_ascq(sensep) == 0x01)) { 18057 un->un_sonoma_failure_count++; 18058 if (un->un_sonoma_failure_count > 1) { 18059 return; 18060 } 18061 } 18062 18063 if (SD_FM_LOG(un) == SD_FM_LOG_NSUP || 18064 ((scsi_sense_key(sensep) == KEY_RECOVERABLE_ERROR) && 18065 (pktp->pkt_resid == 0))) { 18066 scsi_vu_errmsg(SD_SCSI_DEVP(un), pktp, sd_label, severity, 18067 request_blkno, err_blkno, scsi_cmds, 18068 (struct scsi_extended_sense *)sensep, 18069 un->un_additional_codes, NULL); 18070 } 18071 } 18072 18073 /* 18074 * Function: sd_sense_key_no_sense 18075 * 18076 * Description: Recovery action when sense data was not received. 18077 * 18078 * Context: May be called from interrupt context 18079 */ 18080 18081 static void 18082 sd_sense_key_no_sense(struct sd_lun *un, struct buf *bp, 18083 struct sd_xbuf *xp, struct scsi_pkt *pktp) 18084 { 18085 struct sd_sense_info si; 18086 18087 ASSERT(un != NULL); 18088 ASSERT(mutex_owned(SD_MUTEX(un))); 18089 ASSERT(bp != NULL); 18090 ASSERT(xp != NULL); 18091 ASSERT(pktp != NULL); 18092 18093 si.ssi_severity = SCSI_ERR_FATAL; 18094 si.ssi_pfa_flag = FALSE; 18095 18096 SD_UPDATE_ERRSTATS(un, sd_softerrs); 18097 18098 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg, 18099 &si, EIO, (clock_t)0, NULL); 18100 } 18101 18102 18103 /* 18104 * Function: sd_sense_key_recoverable_error 18105 * 18106 * Description: Recovery actions for a SCSI "Recovered Error" sense key. 18107 * 18108 * Context: May be called from interrupt context 18109 */ 18110 18111 static void 18112 sd_sense_key_recoverable_error(struct sd_lun *un, 18113 uint8_t *sense_datap, 18114 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp) 18115 { 18116 struct sd_sense_info si; 18117 uint8_t asc = scsi_sense_asc(sense_datap); 18118 uint8_t ascq = scsi_sense_ascq(sense_datap); 18119 18120 ASSERT(un != NULL); 18121 ASSERT(mutex_owned(SD_MUTEX(un))); 18122 ASSERT(bp != NULL); 18123 ASSERT(xp != NULL); 18124 ASSERT(pktp != NULL); 18125 18126 /* 18127 * 0x00, 0x1D: ATA PASSTHROUGH INFORMATION AVAILABLE 18128 */ 18129 if (asc == 0x00 && ascq == 0x1D) { 18130 sd_return_command(un, bp); 18131 return; 18132 } 18133 18134 /* 18135 * 0x5D: FAILURE PREDICTION THRESHOLD EXCEEDED 18136 */ 18137 if ((asc == 0x5D) && (sd_report_pfa != 0)) { 18138 SD_UPDATE_ERRSTATS(un, sd_rq_pfa_err); 18139 si.ssi_severity = SCSI_ERR_INFO; 18140 si.ssi_pfa_flag = TRUE; 18141 } else { 18142 SD_UPDATE_ERRSTATS(un, sd_softerrs); 18143 SD_UPDATE_ERRSTATS(un, sd_rq_recov_err); 18144 si.ssi_severity = SCSI_ERR_RECOVERED; 18145 si.ssi_pfa_flag = FALSE; 18146 } 18147 18148 if (pktp->pkt_resid == 0) { 18149 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED); 18150 sd_return_command(un, bp); 18151 return; 18152 } 18153 18154 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg, 18155 &si, EIO, (clock_t)0, NULL); 18156 } 18157 18158 18159 18160 18161 /* 18162 * Function: sd_sense_key_not_ready 18163 * 18164 * Description: Recovery actions for a SCSI "Not Ready" sense key. 18165 * 18166 * Context: May be called from interrupt context 18167 */ 18168 18169 static void 18170 sd_sense_key_not_ready(struct sd_lun *un, 18171 uint8_t *sense_datap, 18172 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp) 18173 { 18174 struct sd_sense_info si; 18175 uint8_t asc = scsi_sense_asc(sense_datap); 18176 uint8_t ascq = scsi_sense_ascq(sense_datap); 18177 18178 ASSERT(un != NULL); 18179 ASSERT(mutex_owned(SD_MUTEX(un))); 18180 ASSERT(bp != NULL); 18181 ASSERT(xp != NULL); 18182 ASSERT(pktp != NULL); 18183 18184 si.ssi_severity = SCSI_ERR_FATAL; 18185 si.ssi_pfa_flag = FALSE; 18186 18187 /* 18188 * Update error stats after first NOT READY error. Disks may have 18189 * been powered down and may need to be restarted. For CDROMs, 18190 * report NOT READY errors only if media is present. 18191 */ 18192 if ((ISCD(un) && (asc == 0x3A)) || 18193 (xp->xb_nr_retry_count > 0)) { 18194 SD_UPDATE_ERRSTATS(un, sd_harderrs); 18195 SD_UPDATE_ERRSTATS(un, sd_rq_ntrdy_err); 18196 } 18197 18198 /* 18199 * Just fail if the "not ready" retry limit has been reached. 18200 */ 18201 if (xp->xb_nr_retry_count >= un->un_notready_retry_count) { 18202 /* Special check for error message printing for removables. */ 18203 if (un->un_f_has_removable_media && (asc == 0x04) && 18204 (ascq >= 0x04)) { 18205 si.ssi_severity = SCSI_ERR_ALL; 18206 } 18207 goto fail_command; 18208 } 18209 18210 /* 18211 * Check the ASC and ASCQ in the sense data as needed, to determine 18212 * what to do. 18213 */ 18214 switch (asc) { 18215 case 0x04: /* LOGICAL UNIT NOT READY */ 18216 /* 18217 * disk drives that don't spin up result in a very long delay 18218 * in format without warning messages. We will log a message 18219 * if the error level is set to verbose. 18220 */ 18221 if (sd_error_level < SCSI_ERR_RETRYABLE) { 18222 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 18223 "logical unit not ready, resetting disk\n"); 18224 } 18225 18226 /* 18227 * There are different requirements for CDROMs and disks for 18228 * the number of retries. If a CD-ROM is giving this, it is 18229 * probably reading TOC and is in the process of getting 18230 * ready, so we should keep on trying for a long time to make 18231 * sure that all types of media are taken in account (for 18232 * some media the drive takes a long time to read TOC). For 18233 * disks we do not want to retry this too many times as this 18234 * can cause a long hang in format when the drive refuses to 18235 * spin up (a very common failure). 18236 */ 18237 switch (ascq) { 18238 case 0x00: /* LUN NOT READY, CAUSE NOT REPORTABLE */ 18239 /* 18240 * Disk drives frequently refuse to spin up which 18241 * results in a very long hang in format without 18242 * warning messages. 18243 * 18244 * Note: This code preserves the legacy behavior of 18245 * comparing xb_nr_retry_count against zero for fibre 18246 * channel targets instead of comparing against the 18247 * un_reset_retry_count value. The reason for this 18248 * discrepancy has been so utterly lost beneath the 18249 * Sands of Time that even Indiana Jones could not 18250 * find it. 18251 */ 18252 if (un->un_f_is_fibre == TRUE) { 18253 if (((sd_level_mask & SD_LOGMASK_DIAG) || 18254 (xp->xb_nr_retry_count > 0)) && 18255 (un->un_startstop_timeid == NULL)) { 18256 scsi_log(SD_DEVINFO(un), sd_label, 18257 CE_WARN, "logical unit not ready, " 18258 "resetting disk\n"); 18259 sd_reset_target(un, pktp); 18260 } 18261 } else { 18262 if (((sd_level_mask & SD_LOGMASK_DIAG) || 18263 (xp->xb_nr_retry_count > 18264 un->un_reset_retry_count)) && 18265 (un->un_startstop_timeid == NULL)) { 18266 scsi_log(SD_DEVINFO(un), sd_label, 18267 CE_WARN, "logical unit not ready, " 18268 "resetting disk\n"); 18269 sd_reset_target(un, pktp); 18270 } 18271 } 18272 break; 18273 18274 case 0x01: /* LUN IS IN PROCESS OF BECOMING READY */ 18275 /* 18276 * If the target is in the process of becoming 18277 * ready, just proceed with the retry. This can 18278 * happen with CD-ROMs that take a long time to 18279 * read TOC after a power cycle or reset. 18280 */ 18281 goto do_retry; 18282 18283 case 0x02: /* LUN NOT READY, INITITIALIZING CMD REQUIRED */ 18284 break; 18285 18286 case 0x03: /* LUN NOT READY, MANUAL INTERVENTION REQUIRED */ 18287 /* 18288 * Retries cannot help here so just fail right away. 18289 */ 18290 goto fail_command; 18291 18292 case 0x88: 18293 /* 18294 * Vendor-unique code for T3/T4: it indicates a 18295 * path problem in a mutipathed config, but as far as 18296 * the target driver is concerned it equates to a fatal 18297 * error, so we should just fail the command right away 18298 * (without printing anything to the console). If this 18299 * is not a T3/T4, fall thru to the default recovery 18300 * action. 18301 * T3/T4 is FC only, don't need to check is_fibre 18302 */ 18303 if (SD_IS_T3(un) || SD_IS_T4(un)) { 18304 sd_return_failed_command(un, bp, EIO); 18305 return; 18306 } 18307 /* FALLTHRU */ 18308 18309 case 0x04: /* LUN NOT READY, FORMAT IN PROGRESS */ 18310 case 0x05: /* LUN NOT READY, REBUILD IN PROGRESS */ 18311 case 0x06: /* LUN NOT READY, RECALCULATION IN PROGRESS */ 18312 case 0x07: /* LUN NOT READY, OPERATION IN PROGRESS */ 18313 case 0x08: /* LUN NOT READY, LONG WRITE IN PROGRESS */ 18314 default: /* Possible future codes in SCSI spec? */ 18315 /* 18316 * For removable-media devices, do not retry if 18317 * ASCQ > 2 as these result mostly from USCSI commands 18318 * on MMC devices issued to check status of an 18319 * operation initiated in immediate mode. Also for 18320 * ASCQ >= 4 do not print console messages as these 18321 * mainly represent a user-initiated operation 18322 * instead of a system failure. 18323 */ 18324 if (un->un_f_has_removable_media) { 18325 si.ssi_severity = SCSI_ERR_ALL; 18326 goto fail_command; 18327 } 18328 break; 18329 } 18330 18331 /* 18332 * As part of our recovery attempt for the NOT READY 18333 * condition, we issue a START STOP UNIT command. However 18334 * we want to wait for a short delay before attempting this 18335 * as there may still be more commands coming back from the 18336 * target with the check condition. To do this we use 18337 * timeout(9F) to call sd_start_stop_unit_callback() after 18338 * the delay interval expires. (sd_start_stop_unit_callback() 18339 * dispatches sd_start_stop_unit_task(), which will issue 18340 * the actual START STOP UNIT command. The delay interval 18341 * is one-half of the delay that we will use to retry the 18342 * command that generated the NOT READY condition. 18343 * 18344 * Note that we could just dispatch sd_start_stop_unit_task() 18345 * from here and allow it to sleep for the delay interval, 18346 * but then we would be tying up the taskq thread 18347 * uncesessarily for the duration of the delay. 18348 * 18349 * Do not issue the START STOP UNIT if the current command 18350 * is already a START STOP UNIT. 18351 */ 18352 if (pktp->pkt_cdbp[0] == SCMD_START_STOP) { 18353 break; 18354 } 18355 18356 /* 18357 * Do not schedule the timeout if one is already pending. 18358 */ 18359 if (un->un_startstop_timeid != NULL) { 18360 SD_INFO(SD_LOG_ERROR, un, 18361 "sd_sense_key_not_ready: restart already issued to" 18362 " %s%d\n", ddi_driver_name(SD_DEVINFO(un)), 18363 ddi_get_instance(SD_DEVINFO(un))); 18364 break; 18365 } 18366 18367 /* 18368 * Schedule the START STOP UNIT command, then queue the command 18369 * for a retry. 18370 * 18371 * Note: A timeout is not scheduled for this retry because we 18372 * want the retry to be serial with the START_STOP_UNIT. The 18373 * retry will be started when the START_STOP_UNIT is completed 18374 * in sd_start_stop_unit_task. 18375 */ 18376 un->un_startstop_timeid = timeout(sd_start_stop_unit_callback, 18377 un, un->un_busy_timeout / 2); 18378 xp->xb_nr_retry_count++; 18379 sd_set_retry_bp(un, bp, 0, kstat_waitq_enter); 18380 return; 18381 18382 case 0x05: /* LOGICAL UNIT DOES NOT RESPOND TO SELECTION */ 18383 if (sd_error_level < SCSI_ERR_RETRYABLE) { 18384 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 18385 "unit does not respond to selection\n"); 18386 } 18387 break; 18388 18389 case 0x3A: /* MEDIUM NOT PRESENT */ 18390 if (sd_error_level >= SCSI_ERR_FATAL) { 18391 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 18392 "Caddy not inserted in drive\n"); 18393 } 18394 18395 sr_ejected(un); 18396 un->un_mediastate = DKIO_EJECTED; 18397 /* The state has changed, inform the media watch routines */ 18398 cv_broadcast(&un->un_state_cv); 18399 /* Just fail if no media is present in the drive. */ 18400 goto fail_command; 18401 18402 default: 18403 if (sd_error_level < SCSI_ERR_RETRYABLE) { 18404 scsi_log(SD_DEVINFO(un), sd_label, CE_NOTE, 18405 "Unit not Ready. Additional sense code 0x%x\n", 18406 asc); 18407 } 18408 break; 18409 } 18410 18411 do_retry: 18412 18413 /* 18414 * Retry the command, as some targets may report NOT READY for 18415 * several seconds after being reset. 18416 */ 18417 xp->xb_nr_retry_count++; 18418 si.ssi_severity = SCSI_ERR_RETRYABLE; 18419 sd_retry_command(un, bp, SD_RETRIES_NOCHECK, sd_print_sense_msg, 18420 &si, EIO, un->un_busy_timeout, NULL); 18421 18422 return; 18423 18424 fail_command: 18425 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED); 18426 sd_return_failed_command(un, bp, EIO); 18427 } 18428 18429 18430 18431 /* 18432 * Function: sd_sense_key_medium_or_hardware_error 18433 * 18434 * Description: Recovery actions for a SCSI "Medium Error" or "Hardware Error" 18435 * sense key. 18436 * 18437 * Context: May be called from interrupt context 18438 */ 18439 18440 static void 18441 sd_sense_key_medium_or_hardware_error(struct sd_lun *un, 18442 uint8_t *sense_datap, 18443 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp) 18444 { 18445 struct sd_sense_info si; 18446 uint8_t sense_key = scsi_sense_key(sense_datap); 18447 uint8_t asc = scsi_sense_asc(sense_datap); 18448 18449 ASSERT(un != NULL); 18450 ASSERT(mutex_owned(SD_MUTEX(un))); 18451 ASSERT(bp != NULL); 18452 ASSERT(xp != NULL); 18453 ASSERT(pktp != NULL); 18454 18455 si.ssi_severity = SCSI_ERR_FATAL; 18456 si.ssi_pfa_flag = FALSE; 18457 18458 if (sense_key == KEY_MEDIUM_ERROR) { 18459 SD_UPDATE_ERRSTATS(un, sd_rq_media_err); 18460 } 18461 18462 SD_UPDATE_ERRSTATS(un, sd_harderrs); 18463 18464 if ((un->un_reset_retry_count != 0) && 18465 (xp->xb_retry_count == un->un_reset_retry_count)) { 18466 mutex_exit(SD_MUTEX(un)); 18467 /* Do NOT do a RESET_ALL here: too intrusive. (4112858) */ 18468 if (un->un_f_allow_bus_device_reset == TRUE) { 18469 18470 boolean_t try_resetting_target = B_TRUE; 18471 18472 /* 18473 * We need to be able to handle specific ASC when we are 18474 * handling a KEY_HARDWARE_ERROR. In particular 18475 * taking the default action of resetting the target may 18476 * not be the appropriate way to attempt recovery. 18477 * Resetting a target because of a single LUN failure 18478 * victimizes all LUNs on that target. 18479 * 18480 * This is true for the LSI arrays, if an LSI 18481 * array controller returns an ASC of 0x84 (LUN Dead) we 18482 * should trust it. 18483 */ 18484 18485 if (sense_key == KEY_HARDWARE_ERROR) { 18486 switch (asc) { 18487 case 0x84: 18488 if (SD_IS_LSI(un)) { 18489 try_resetting_target = B_FALSE; 18490 } 18491 break; 18492 default: 18493 break; 18494 } 18495 } 18496 18497 if (try_resetting_target == B_TRUE) { 18498 int reset_retval = 0; 18499 if (un->un_f_lun_reset_enabled == TRUE) { 18500 SD_TRACE(SD_LOG_IO_CORE, un, 18501 "sd_sense_key_medium_or_hardware_" 18502 "error: issuing RESET_LUN\n"); 18503 reset_retval = 18504 scsi_reset(SD_ADDRESS(un), 18505 RESET_LUN); 18506 } 18507 if (reset_retval == 0) { 18508 SD_TRACE(SD_LOG_IO_CORE, un, 18509 "sd_sense_key_medium_or_hardware_" 18510 "error: issuing RESET_TARGET\n"); 18511 (void) scsi_reset(SD_ADDRESS(un), 18512 RESET_TARGET); 18513 } 18514 } 18515 } 18516 mutex_enter(SD_MUTEX(un)); 18517 } 18518 18519 /* 18520 * This really ought to be a fatal error, but we will retry anyway 18521 * as some drives report this as a spurious error. 18522 */ 18523 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg, 18524 &si, EIO, (clock_t)0, NULL); 18525 } 18526 18527 18528 18529 /* 18530 * Function: sd_sense_key_illegal_request 18531 * 18532 * Description: Recovery actions for a SCSI "Illegal Request" sense key. 18533 * 18534 * Context: May be called from interrupt context 18535 */ 18536 18537 static void 18538 sd_sense_key_illegal_request(struct sd_lun *un, struct buf *bp, 18539 struct sd_xbuf *xp, struct scsi_pkt *pktp) 18540 { 18541 struct sd_sense_info si; 18542 18543 ASSERT(un != NULL); 18544 ASSERT(mutex_owned(SD_MUTEX(un))); 18545 ASSERT(bp != NULL); 18546 ASSERT(xp != NULL); 18547 ASSERT(pktp != NULL); 18548 18549 SD_UPDATE_ERRSTATS(un, sd_rq_illrq_err); 18550 18551 si.ssi_severity = SCSI_ERR_INFO; 18552 si.ssi_pfa_flag = FALSE; 18553 18554 /* Pointless to retry if the target thinks it's an illegal request */ 18555 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED); 18556 sd_return_failed_command(un, bp, EIO); 18557 } 18558 18559 18560 18561 18562 /* 18563 * Function: sd_sense_key_unit_attention 18564 * 18565 * Description: Recovery actions for a SCSI "Unit Attention" sense key. 18566 * 18567 * Context: May be called from interrupt context 18568 */ 18569 18570 static void 18571 sd_sense_key_unit_attention(struct sd_lun *un, 18572 uint8_t *sense_datap, 18573 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp) 18574 { 18575 /* 18576 * For UNIT ATTENTION we allow retries for one minute. Devices 18577 * like Sonoma can return UNIT ATTENTION close to a minute 18578 * under certain conditions. 18579 */ 18580 int retry_check_flag = SD_RETRIES_UA; 18581 boolean_t kstat_updated = B_FALSE; 18582 struct sd_sense_info si; 18583 uint8_t asc = scsi_sense_asc(sense_datap); 18584 uint8_t ascq = scsi_sense_ascq(sense_datap); 18585 18586 ASSERT(un != NULL); 18587 ASSERT(mutex_owned(SD_MUTEX(un))); 18588 ASSERT(bp != NULL); 18589 ASSERT(xp != NULL); 18590 ASSERT(pktp != NULL); 18591 18592 si.ssi_severity = SCSI_ERR_INFO; 18593 si.ssi_pfa_flag = FALSE; 18594 18595 18596 switch (asc) { 18597 case 0x5D: /* FAILURE PREDICTION THRESHOLD EXCEEDED */ 18598 if (sd_report_pfa != 0) { 18599 SD_UPDATE_ERRSTATS(un, sd_rq_pfa_err); 18600 si.ssi_pfa_flag = TRUE; 18601 retry_check_flag = SD_RETRIES_STANDARD; 18602 goto do_retry; 18603 } 18604 18605 break; 18606 18607 case 0x29: /* POWER ON, RESET, OR BUS DEVICE RESET OCCURRED */ 18608 if ((un->un_resvd_status & SD_RESERVE) == SD_RESERVE) { 18609 un->un_resvd_status |= 18610 (SD_LOST_RESERVE | SD_WANT_RESERVE); 18611 } 18612 #ifdef _LP64 18613 if (un->un_blockcount + 1 > SD_GROUP1_MAX_ADDRESS) { 18614 if (taskq_dispatch(sd_tq, sd_reenable_dsense_task, 18615 un, KM_NOSLEEP) == 0) { 18616 /* 18617 * If we can't dispatch the task we'll just 18618 * live without descriptor sense. We can 18619 * try again on the next "unit attention" 18620 */ 18621 SD_ERROR(SD_LOG_ERROR, un, 18622 "sd_sense_key_unit_attention: " 18623 "Could not dispatch " 18624 "sd_reenable_dsense_task\n"); 18625 } 18626 } 18627 #endif /* _LP64 */ 18628 /* FALLTHRU */ 18629 18630 case 0x28: /* NOT READY TO READY CHANGE, MEDIUM MAY HAVE CHANGED */ 18631 if (!un->un_f_has_removable_media) { 18632 break; 18633 } 18634 18635 /* 18636 * When we get a unit attention from a removable-media device, 18637 * it may be in a state that will take a long time to recover 18638 * (e.g., from a reset). Since we are executing in interrupt 18639 * context here, we cannot wait around for the device to come 18640 * back. So hand this command off to sd_media_change_task() 18641 * for deferred processing under taskq thread context. (Note 18642 * that the command still may be failed if a problem is 18643 * encountered at a later time.) 18644 */ 18645 if (taskq_dispatch(sd_tq, sd_media_change_task, pktp, 18646 KM_NOSLEEP) == 0) { 18647 /* 18648 * Cannot dispatch the request so fail the command. 18649 */ 18650 SD_UPDATE_ERRSTATS(un, sd_harderrs); 18651 SD_UPDATE_ERRSTATS(un, sd_rq_nodev_err); 18652 si.ssi_severity = SCSI_ERR_FATAL; 18653 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED); 18654 sd_return_failed_command(un, bp, EIO); 18655 } 18656 18657 /* 18658 * If failed to dispatch sd_media_change_task(), we already 18659 * updated kstat. If succeed to dispatch sd_media_change_task(), 18660 * we should update kstat later if it encounters an error. So, 18661 * we update kstat_updated flag here. 18662 */ 18663 kstat_updated = B_TRUE; 18664 18665 /* 18666 * Either the command has been successfully dispatched to a 18667 * task Q for retrying, or the dispatch failed. In either case 18668 * do NOT retry again by calling sd_retry_command. This sets up 18669 * two retries of the same command and when one completes and 18670 * frees the resources the other will access freed memory, 18671 * a bad thing. 18672 */ 18673 return; 18674 18675 default: 18676 break; 18677 } 18678 18679 /* 18680 * ASC ASCQ 18681 * 2A 09 Capacity data has changed 18682 * 2A 01 Mode parameters changed 18683 * 3F 0E Reported luns data has changed 18684 * Arrays that support logical unit expansion should report 18685 * capacity changes(2Ah/09). Mode parameters changed and 18686 * reported luns data has changed are the approximation. 18687 */ 18688 if (((asc == 0x2a) && (ascq == 0x09)) || 18689 ((asc == 0x2a) && (ascq == 0x01)) || 18690 ((asc == 0x3f) && (ascq == 0x0e))) { 18691 if (taskq_dispatch(sd_tq, sd_target_change_task, un, 18692 KM_NOSLEEP) == 0) { 18693 SD_ERROR(SD_LOG_ERROR, un, 18694 "sd_sense_key_unit_attention: " 18695 "Could not dispatch sd_target_change_task\n"); 18696 } 18697 } 18698 18699 /* 18700 * Update kstat if we haven't done that. 18701 */ 18702 if (!kstat_updated) { 18703 SD_UPDATE_ERRSTATS(un, sd_harderrs); 18704 SD_UPDATE_ERRSTATS(un, sd_rq_nodev_err); 18705 } 18706 18707 do_retry: 18708 sd_retry_command(un, bp, retry_check_flag, sd_print_sense_msg, &si, 18709 EIO, SD_UA_RETRY_DELAY, NULL); 18710 } 18711 18712 18713 18714 /* 18715 * Function: sd_sense_key_fail_command 18716 * 18717 * Description: Use to fail a command when we don't like the sense key that 18718 * was returned. 18719 * 18720 * Context: May be called from interrupt context 18721 */ 18722 18723 static void 18724 sd_sense_key_fail_command(struct sd_lun *un, struct buf *bp, 18725 struct sd_xbuf *xp, struct scsi_pkt *pktp) 18726 { 18727 struct sd_sense_info si; 18728 18729 ASSERT(un != NULL); 18730 ASSERT(mutex_owned(SD_MUTEX(un))); 18731 ASSERT(bp != NULL); 18732 ASSERT(xp != NULL); 18733 ASSERT(pktp != NULL); 18734 18735 si.ssi_severity = SCSI_ERR_FATAL; 18736 si.ssi_pfa_flag = FALSE; 18737 18738 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED); 18739 sd_return_failed_command(un, bp, EIO); 18740 } 18741 18742 18743 18744 /* 18745 * Function: sd_sense_key_blank_check 18746 * 18747 * Description: Recovery actions for a SCSI "Blank Check" sense key. 18748 * Has no monetary connotation. 18749 * 18750 * Context: May be called from interrupt context 18751 */ 18752 18753 static void 18754 sd_sense_key_blank_check(struct sd_lun *un, struct buf *bp, 18755 struct sd_xbuf *xp, struct scsi_pkt *pktp) 18756 { 18757 struct sd_sense_info si; 18758 18759 ASSERT(un != NULL); 18760 ASSERT(mutex_owned(SD_MUTEX(un))); 18761 ASSERT(bp != NULL); 18762 ASSERT(xp != NULL); 18763 ASSERT(pktp != NULL); 18764 18765 /* 18766 * Blank check is not fatal for removable devices, therefore 18767 * it does not require a console message. 18768 */ 18769 si.ssi_severity = (un->un_f_has_removable_media) ? SCSI_ERR_ALL : 18770 SCSI_ERR_FATAL; 18771 si.ssi_pfa_flag = FALSE; 18772 18773 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED); 18774 sd_return_failed_command(un, bp, EIO); 18775 } 18776 18777 18778 18779 18780 /* 18781 * Function: sd_sense_key_aborted_command 18782 * 18783 * Description: Recovery actions for a SCSI "Aborted Command" sense key. 18784 * 18785 * Context: May be called from interrupt context 18786 */ 18787 18788 static void 18789 sd_sense_key_aborted_command(struct sd_lun *un, struct buf *bp, 18790 struct sd_xbuf *xp, struct scsi_pkt *pktp) 18791 { 18792 struct sd_sense_info si; 18793 18794 ASSERT(un != NULL); 18795 ASSERT(mutex_owned(SD_MUTEX(un))); 18796 ASSERT(bp != NULL); 18797 ASSERT(xp != NULL); 18798 ASSERT(pktp != NULL); 18799 18800 si.ssi_severity = SCSI_ERR_FATAL; 18801 si.ssi_pfa_flag = FALSE; 18802 18803 SD_UPDATE_ERRSTATS(un, sd_harderrs); 18804 18805 /* 18806 * This really ought to be a fatal error, but we will retry anyway 18807 * as some drives report this as a spurious error. 18808 */ 18809 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg, 18810 &si, EIO, drv_usectohz(100000), NULL); 18811 } 18812 18813 18814 18815 /* 18816 * Function: sd_sense_key_default 18817 * 18818 * Description: Default recovery action for several SCSI sense keys (basically 18819 * attempts a retry). 18820 * 18821 * Context: May be called from interrupt context 18822 */ 18823 18824 static void 18825 sd_sense_key_default(struct sd_lun *un, 18826 uint8_t *sense_datap, 18827 struct buf *bp, struct sd_xbuf *xp, struct scsi_pkt *pktp) 18828 { 18829 struct sd_sense_info si; 18830 uint8_t sense_key = scsi_sense_key(sense_datap); 18831 18832 ASSERT(un != NULL); 18833 ASSERT(mutex_owned(SD_MUTEX(un))); 18834 ASSERT(bp != NULL); 18835 ASSERT(xp != NULL); 18836 ASSERT(pktp != NULL); 18837 18838 SD_UPDATE_ERRSTATS(un, sd_harderrs); 18839 18840 /* 18841 * Undecoded sense key. Attempt retries and hope that will fix 18842 * the problem. Otherwise, we're dead. 18843 */ 18844 if ((pktp->pkt_flags & FLAG_SILENT) == 0) { 18845 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 18846 "Unhandled Sense Key '%s'\n", sense_keys[sense_key]); 18847 } 18848 18849 si.ssi_severity = SCSI_ERR_FATAL; 18850 si.ssi_pfa_flag = FALSE; 18851 18852 sd_retry_command(un, bp, SD_RETRIES_STANDARD, sd_print_sense_msg, 18853 &si, EIO, (clock_t)0, NULL); 18854 } 18855 18856 18857 18858 /* 18859 * Function: sd_print_retry_msg 18860 * 18861 * Description: Print a message indicating the retry action being taken. 18862 * 18863 * Arguments: un - ptr to associated softstate 18864 * bp - ptr to buf(9S) for the command 18865 * arg - not used. 18866 * flag - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED, 18867 * or SD_NO_RETRY_ISSUED 18868 * 18869 * Context: May be called from interrupt context 18870 */ 18871 /* ARGSUSED */ 18872 static void 18873 sd_print_retry_msg(struct sd_lun *un, struct buf *bp, void *arg, int flag) 18874 { 18875 struct sd_xbuf *xp; 18876 struct scsi_pkt *pktp; 18877 char *reasonp; 18878 char *msgp; 18879 18880 ASSERT(un != NULL); 18881 ASSERT(mutex_owned(SD_MUTEX(un))); 18882 ASSERT(bp != NULL); 18883 pktp = SD_GET_PKTP(bp); 18884 ASSERT(pktp != NULL); 18885 xp = SD_GET_XBUF(bp); 18886 ASSERT(xp != NULL); 18887 18888 ASSERT(!mutex_owned(&un->un_pm_mutex)); 18889 mutex_enter(&un->un_pm_mutex); 18890 if ((un->un_state == SD_STATE_SUSPENDED) || 18891 (SD_DEVICE_IS_IN_LOW_POWER(un)) || 18892 (pktp->pkt_flags & FLAG_SILENT)) { 18893 mutex_exit(&un->un_pm_mutex); 18894 goto update_pkt_reason; 18895 } 18896 mutex_exit(&un->un_pm_mutex); 18897 18898 /* 18899 * Suppress messages if they are all the same pkt_reason; with 18900 * TQ, many (up to 256) are returned with the same pkt_reason. 18901 * If we are in panic, then suppress the retry messages. 18902 */ 18903 switch (flag) { 18904 case SD_NO_RETRY_ISSUED: 18905 msgp = "giving up"; 18906 break; 18907 case SD_IMMEDIATE_RETRY_ISSUED: 18908 case SD_DELAYED_RETRY_ISSUED: 18909 if (ddi_in_panic() || (un->un_state == SD_STATE_OFFLINE) || 18910 ((pktp->pkt_reason == un->un_last_pkt_reason) && 18911 (sd_error_level != SCSI_ERR_ALL))) { 18912 return; 18913 } 18914 msgp = "retrying command"; 18915 break; 18916 default: 18917 goto update_pkt_reason; 18918 } 18919 18920 reasonp = (((pktp->pkt_statistics & STAT_PERR) != 0) ? "parity error" : 18921 scsi_rname(pktp->pkt_reason)); 18922 18923 if (SD_FM_LOG(un) == SD_FM_LOG_NSUP) { 18924 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 18925 "SCSI transport failed: reason '%s': %s\n", reasonp, msgp); 18926 } 18927 18928 update_pkt_reason: 18929 /* 18930 * Update un->un_last_pkt_reason with the value in pktp->pkt_reason. 18931 * This is to prevent multiple console messages for the same failure 18932 * condition. Note that un->un_last_pkt_reason is NOT restored if & 18933 * when the command is retried successfully because there still may be 18934 * more commands coming back with the same value of pktp->pkt_reason. 18935 */ 18936 if ((pktp->pkt_reason != CMD_CMPLT) || (xp->xb_retry_count == 0)) { 18937 un->un_last_pkt_reason = pktp->pkt_reason; 18938 } 18939 } 18940 18941 18942 /* 18943 * Function: sd_print_cmd_incomplete_msg 18944 * 18945 * Description: Message logging fn. for a SCSA "CMD_INCOMPLETE" pkt_reason. 18946 * 18947 * Arguments: un - ptr to associated softstate 18948 * bp - ptr to buf(9S) for the command 18949 * arg - passed to sd_print_retry_msg() 18950 * code - SD_IMMEDIATE_RETRY_ISSUED, SD_DELAYED_RETRY_ISSUED, 18951 * or SD_NO_RETRY_ISSUED 18952 * 18953 * Context: May be called from interrupt context 18954 */ 18955 18956 static void 18957 sd_print_cmd_incomplete_msg(struct sd_lun *un, struct buf *bp, void *arg, 18958 int code) 18959 { 18960 dev_info_t *dip; 18961 18962 ASSERT(un != NULL); 18963 ASSERT(mutex_owned(SD_MUTEX(un))); 18964 ASSERT(bp != NULL); 18965 18966 switch (code) { 18967 case SD_NO_RETRY_ISSUED: 18968 /* Command was failed. Someone turned off this target? */ 18969 if (un->un_state != SD_STATE_OFFLINE) { 18970 /* 18971 * Suppress message if we are detaching and 18972 * device has been disconnected 18973 * Note that DEVI_IS_DEVICE_REMOVED is a consolidation 18974 * private interface and not part of the DDI 18975 */ 18976 dip = un->un_sd->sd_dev; 18977 if (!(DEVI_IS_DETACHING(dip) && 18978 DEVI_IS_DEVICE_REMOVED(dip))) { 18979 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 18980 "disk not responding to selection\n"); 18981 } 18982 New_state(un, SD_STATE_OFFLINE); 18983 } 18984 break; 18985 18986 case SD_DELAYED_RETRY_ISSUED: 18987 case SD_IMMEDIATE_RETRY_ISSUED: 18988 default: 18989 /* Command was successfully queued for retry */ 18990 sd_print_retry_msg(un, bp, arg, code); 18991 break; 18992 } 18993 } 18994 18995 18996 /* 18997 * Function: sd_pkt_reason_cmd_incomplete 18998 * 18999 * Description: Recovery actions for a SCSA "CMD_INCOMPLETE" pkt_reason. 19000 * 19001 * Context: May be called from interrupt context 19002 */ 19003 19004 static void 19005 sd_pkt_reason_cmd_incomplete(struct sd_lun *un, struct buf *bp, 19006 struct sd_xbuf *xp, struct scsi_pkt *pktp) 19007 { 19008 int flag = SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE; 19009 19010 ASSERT(un != NULL); 19011 ASSERT(mutex_owned(SD_MUTEX(un))); 19012 ASSERT(bp != NULL); 19013 ASSERT(xp != NULL); 19014 ASSERT(pktp != NULL); 19015 19016 /* Do not do a reset if selection did not complete */ 19017 /* Note: Should this not just check the bit? */ 19018 if (pktp->pkt_state != STATE_GOT_BUS) { 19019 SD_UPDATE_ERRSTATS(un, sd_transerrs); 19020 sd_reset_target(un, pktp); 19021 } 19022 19023 /* 19024 * If the target was not successfully selected, then set 19025 * SD_RETRIES_FAILFAST to indicate that we lost communication 19026 * with the target, and further retries and/or commands are 19027 * likely to take a long time. 19028 */ 19029 if ((pktp->pkt_state & STATE_GOT_TARGET) == 0) { 19030 flag |= SD_RETRIES_FAILFAST; 19031 } 19032 19033 SD_UPDATE_RESERVATION_STATUS(un, pktp); 19034 19035 sd_retry_command(un, bp, flag, 19036 sd_print_cmd_incomplete_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL); 19037 } 19038 19039 19040 19041 /* 19042 * Function: sd_pkt_reason_cmd_tran_err 19043 * 19044 * Description: Recovery actions for a SCSA "CMD_TRAN_ERR" pkt_reason. 19045 * 19046 * Context: May be called from interrupt context 19047 */ 19048 19049 static void 19050 sd_pkt_reason_cmd_tran_err(struct sd_lun *un, struct buf *bp, 19051 struct sd_xbuf *xp, struct scsi_pkt *pktp) 19052 { 19053 ASSERT(un != NULL); 19054 ASSERT(mutex_owned(SD_MUTEX(un))); 19055 ASSERT(bp != NULL); 19056 ASSERT(xp != NULL); 19057 ASSERT(pktp != NULL); 19058 19059 /* 19060 * Do not reset if we got a parity error, or if 19061 * selection did not complete. 19062 */ 19063 SD_UPDATE_ERRSTATS(un, sd_harderrs); 19064 /* Note: Should this not just check the bit for pkt_state? */ 19065 if (((pktp->pkt_statistics & STAT_PERR) == 0) && 19066 (pktp->pkt_state != STATE_GOT_BUS)) { 19067 SD_UPDATE_ERRSTATS(un, sd_transerrs); 19068 sd_reset_target(un, pktp); 19069 } 19070 19071 SD_UPDATE_RESERVATION_STATUS(un, pktp); 19072 19073 sd_retry_command(un, bp, (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE), 19074 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL); 19075 } 19076 19077 19078 19079 /* 19080 * Function: sd_pkt_reason_cmd_reset 19081 * 19082 * Description: Recovery actions for a SCSA "CMD_RESET" pkt_reason. 19083 * 19084 * Context: May be called from interrupt context 19085 */ 19086 19087 static void 19088 sd_pkt_reason_cmd_reset(struct sd_lun *un, struct buf *bp, 19089 struct sd_xbuf *xp, struct scsi_pkt *pktp) 19090 { 19091 ASSERT(un != NULL); 19092 ASSERT(mutex_owned(SD_MUTEX(un))); 19093 ASSERT(bp != NULL); 19094 ASSERT(xp != NULL); 19095 ASSERT(pktp != NULL); 19096 19097 /* The target may still be running the command, so try to reset. */ 19098 SD_UPDATE_ERRSTATS(un, sd_transerrs); 19099 sd_reset_target(un, pktp); 19100 19101 SD_UPDATE_RESERVATION_STATUS(un, pktp); 19102 19103 /* 19104 * If pkt_reason is CMD_RESET chances are that this pkt got 19105 * reset because another target on this bus caused it. The target 19106 * that caused it should get CMD_TIMEOUT with pkt_statistics 19107 * of STAT_TIMEOUT/STAT_DEV_RESET. 19108 */ 19109 19110 sd_retry_command(un, bp, (SD_RETRIES_VICTIM | SD_RETRIES_ISOLATE), 19111 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL); 19112 } 19113 19114 19115 19116 19117 /* 19118 * Function: sd_pkt_reason_cmd_aborted 19119 * 19120 * Description: Recovery actions for a SCSA "CMD_ABORTED" pkt_reason. 19121 * 19122 * Context: May be called from interrupt context 19123 */ 19124 19125 static void 19126 sd_pkt_reason_cmd_aborted(struct sd_lun *un, struct buf *bp, 19127 struct sd_xbuf *xp, struct scsi_pkt *pktp) 19128 { 19129 ASSERT(un != NULL); 19130 ASSERT(mutex_owned(SD_MUTEX(un))); 19131 ASSERT(bp != NULL); 19132 ASSERT(xp != NULL); 19133 ASSERT(pktp != NULL); 19134 19135 /* The target may still be running the command, so try to reset. */ 19136 SD_UPDATE_ERRSTATS(un, sd_transerrs); 19137 sd_reset_target(un, pktp); 19138 19139 SD_UPDATE_RESERVATION_STATUS(un, pktp); 19140 19141 /* 19142 * If pkt_reason is CMD_ABORTED chances are that this pkt got 19143 * aborted because another target on this bus caused it. The target 19144 * that caused it should get CMD_TIMEOUT with pkt_statistics 19145 * of STAT_TIMEOUT/STAT_DEV_RESET. 19146 */ 19147 19148 sd_retry_command(un, bp, (SD_RETRIES_VICTIM | SD_RETRIES_ISOLATE), 19149 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL); 19150 } 19151 19152 19153 19154 /* 19155 * Function: sd_pkt_reason_cmd_timeout 19156 * 19157 * Description: Recovery actions for a SCSA "CMD_TIMEOUT" pkt_reason. 19158 * 19159 * Context: May be called from interrupt context 19160 */ 19161 19162 static void 19163 sd_pkt_reason_cmd_timeout(struct sd_lun *un, struct buf *bp, 19164 struct sd_xbuf *xp, struct scsi_pkt *pktp) 19165 { 19166 ASSERT(un != NULL); 19167 ASSERT(mutex_owned(SD_MUTEX(un))); 19168 ASSERT(bp != NULL); 19169 ASSERT(xp != NULL); 19170 ASSERT(pktp != NULL); 19171 19172 19173 SD_UPDATE_ERRSTATS(un, sd_transerrs); 19174 sd_reset_target(un, pktp); 19175 19176 SD_UPDATE_RESERVATION_STATUS(un, pktp); 19177 19178 /* 19179 * A command timeout indicates that we could not establish 19180 * communication with the target, so set SD_RETRIES_FAILFAST 19181 * as further retries/commands are likely to take a long time. 19182 */ 19183 sd_retry_command(un, bp, 19184 (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE | SD_RETRIES_FAILFAST), 19185 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL); 19186 } 19187 19188 19189 19190 /* 19191 * Function: sd_pkt_reason_cmd_unx_bus_free 19192 * 19193 * Description: Recovery actions for a SCSA "CMD_UNX_BUS_FREE" pkt_reason. 19194 * 19195 * Context: May be called from interrupt context 19196 */ 19197 19198 static void 19199 sd_pkt_reason_cmd_unx_bus_free(struct sd_lun *un, struct buf *bp, 19200 struct sd_xbuf *xp, struct scsi_pkt *pktp) 19201 { 19202 void (*funcp)(struct sd_lun *un, struct buf *bp, void *arg, int code); 19203 19204 ASSERT(un != NULL); 19205 ASSERT(mutex_owned(SD_MUTEX(un))); 19206 ASSERT(bp != NULL); 19207 ASSERT(xp != NULL); 19208 ASSERT(pktp != NULL); 19209 19210 SD_UPDATE_ERRSTATS(un, sd_harderrs); 19211 SD_UPDATE_RESERVATION_STATUS(un, pktp); 19212 19213 funcp = ((pktp->pkt_statistics & STAT_PERR) == 0) ? 19214 sd_print_retry_msg : NULL; 19215 19216 sd_retry_command(un, bp, (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE), 19217 funcp, NULL, EIO, SD_RESTART_TIMEOUT, NULL); 19218 } 19219 19220 19221 /* 19222 * Function: sd_pkt_reason_cmd_tag_reject 19223 * 19224 * Description: Recovery actions for a SCSA "CMD_TAG_REJECT" pkt_reason. 19225 * 19226 * Context: May be called from interrupt context 19227 */ 19228 19229 static void 19230 sd_pkt_reason_cmd_tag_reject(struct sd_lun *un, struct buf *bp, 19231 struct sd_xbuf *xp, struct scsi_pkt *pktp) 19232 { 19233 ASSERT(un != NULL); 19234 ASSERT(mutex_owned(SD_MUTEX(un))); 19235 ASSERT(bp != NULL); 19236 ASSERT(xp != NULL); 19237 ASSERT(pktp != NULL); 19238 19239 SD_UPDATE_ERRSTATS(un, sd_harderrs); 19240 pktp->pkt_flags = 0; 19241 un->un_tagflags = 0; 19242 if (un->un_f_opt_queueing == TRUE) { 19243 un->un_throttle = min(un->un_throttle, 3); 19244 } else { 19245 un->un_throttle = 1; 19246 } 19247 mutex_exit(SD_MUTEX(un)); 19248 (void) scsi_ifsetcap(SD_ADDRESS(un), "tagged-qing", 0, 1); 19249 mutex_enter(SD_MUTEX(un)); 19250 19251 SD_UPDATE_RESERVATION_STATUS(un, pktp); 19252 19253 /* Legacy behavior not to check retry counts here. */ 19254 sd_retry_command(un, bp, (SD_RETRIES_NOCHECK | SD_RETRIES_ISOLATE), 19255 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL); 19256 } 19257 19258 19259 /* 19260 * Function: sd_pkt_reason_default 19261 * 19262 * Description: Default recovery actions for SCSA pkt_reason values that 19263 * do not have more explicit recovery actions. 19264 * 19265 * Context: May be called from interrupt context 19266 */ 19267 19268 static void 19269 sd_pkt_reason_default(struct sd_lun *un, struct buf *bp, 19270 struct sd_xbuf *xp, struct scsi_pkt *pktp) 19271 { 19272 ASSERT(un != NULL); 19273 ASSERT(mutex_owned(SD_MUTEX(un))); 19274 ASSERT(bp != NULL); 19275 ASSERT(xp != NULL); 19276 ASSERT(pktp != NULL); 19277 19278 SD_UPDATE_ERRSTATS(un, sd_transerrs); 19279 sd_reset_target(un, pktp); 19280 19281 SD_UPDATE_RESERVATION_STATUS(un, pktp); 19282 19283 sd_retry_command(un, bp, (SD_RETRIES_STANDARD | SD_RETRIES_ISOLATE), 19284 sd_print_retry_msg, NULL, EIO, SD_RESTART_TIMEOUT, NULL); 19285 } 19286 19287 19288 19289 /* 19290 * Function: sd_pkt_status_check_condition 19291 * 19292 * Description: Recovery actions for a "STATUS_CHECK" SCSI command status. 19293 * 19294 * Context: May be called from interrupt context 19295 */ 19296 19297 static void 19298 sd_pkt_status_check_condition(struct sd_lun *un, struct buf *bp, 19299 struct sd_xbuf *xp, struct scsi_pkt *pktp) 19300 { 19301 ASSERT(un != NULL); 19302 ASSERT(mutex_owned(SD_MUTEX(un))); 19303 ASSERT(bp != NULL); 19304 ASSERT(xp != NULL); 19305 ASSERT(pktp != NULL); 19306 19307 SD_TRACE(SD_LOG_IO, un, "sd_pkt_status_check_condition: " 19308 "entry: buf:0x%p xp:0x%p\n", bp, xp); 19309 19310 /* 19311 * If ARQ is NOT enabled, then issue a REQUEST SENSE command (the 19312 * command will be retried after the request sense). Otherwise, retry 19313 * the command. Note: we are issuing the request sense even though the 19314 * retry limit may have been reached for the failed command. 19315 */ 19316 if (un->un_f_arq_enabled == FALSE) { 19317 SD_INFO(SD_LOG_IO_CORE, un, "sd_pkt_status_check_condition: " 19318 "no ARQ, sending request sense command\n"); 19319 sd_send_request_sense_command(un, bp, pktp); 19320 } else { 19321 SD_INFO(SD_LOG_IO_CORE, un, "sd_pkt_status_check_condition: " 19322 "ARQ,retrying request sense command\n"); 19323 #if defined(__i386) || defined(__amd64) 19324 /* 19325 * The SD_RETRY_DELAY value need to be adjusted here 19326 * when SD_RETRY_DELAY change in sddef.h 19327 */ 19328 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, NULL, EIO, 19329 un->un_f_is_fibre?drv_usectohz(100000):(clock_t)0, 19330 NULL); 19331 #else 19332 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, NULL, 19333 EIO, SD_RETRY_DELAY, NULL); 19334 #endif 19335 } 19336 19337 SD_TRACE(SD_LOG_IO_CORE, un, "sd_pkt_status_check_condition: exit\n"); 19338 } 19339 19340 19341 /* 19342 * Function: sd_pkt_status_busy 19343 * 19344 * Description: Recovery actions for a "STATUS_BUSY" SCSI command status. 19345 * 19346 * Context: May be called from interrupt context 19347 */ 19348 19349 static void 19350 sd_pkt_status_busy(struct sd_lun *un, struct buf *bp, struct sd_xbuf *xp, 19351 struct scsi_pkt *pktp) 19352 { 19353 ASSERT(un != NULL); 19354 ASSERT(mutex_owned(SD_MUTEX(un))); 19355 ASSERT(bp != NULL); 19356 ASSERT(xp != NULL); 19357 ASSERT(pktp != NULL); 19358 19359 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 19360 "sd_pkt_status_busy: entry\n"); 19361 19362 /* If retries are exhausted, just fail the command. */ 19363 if (xp->xb_retry_count >= un->un_busy_retry_count) { 19364 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 19365 "device busy too long\n"); 19366 sd_return_failed_command(un, bp, EIO); 19367 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 19368 "sd_pkt_status_busy: exit\n"); 19369 return; 19370 } 19371 xp->xb_retry_count++; 19372 19373 /* 19374 * Try to reset the target. However, we do not want to perform 19375 * more than one reset if the device continues to fail. The reset 19376 * will be performed when the retry count reaches the reset 19377 * threshold. This threshold should be set such that at least 19378 * one retry is issued before the reset is performed. 19379 */ 19380 if (xp->xb_retry_count == 19381 ((un->un_reset_retry_count < 2) ? 2 : un->un_reset_retry_count)) { 19382 int rval = 0; 19383 mutex_exit(SD_MUTEX(un)); 19384 if (un->un_f_allow_bus_device_reset == TRUE) { 19385 /* 19386 * First try to reset the LUN; if we cannot then 19387 * try to reset the target. 19388 */ 19389 if (un->un_f_lun_reset_enabled == TRUE) { 19390 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 19391 "sd_pkt_status_busy: RESET_LUN\n"); 19392 rval = scsi_reset(SD_ADDRESS(un), RESET_LUN); 19393 } 19394 if (rval == 0) { 19395 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 19396 "sd_pkt_status_busy: RESET_TARGET\n"); 19397 rval = scsi_reset(SD_ADDRESS(un), RESET_TARGET); 19398 } 19399 } 19400 if (rval == 0) { 19401 /* 19402 * If the RESET_LUN and/or RESET_TARGET failed, 19403 * try RESET_ALL 19404 */ 19405 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 19406 "sd_pkt_status_busy: RESET_ALL\n"); 19407 rval = scsi_reset(SD_ADDRESS(un), RESET_ALL); 19408 } 19409 mutex_enter(SD_MUTEX(un)); 19410 if (rval == 0) { 19411 /* 19412 * The RESET_LUN, RESET_TARGET, and/or RESET_ALL failed. 19413 * At this point we give up & fail the command. 19414 */ 19415 sd_return_failed_command(un, bp, EIO); 19416 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 19417 "sd_pkt_status_busy: exit (failed cmd)\n"); 19418 return; 19419 } 19420 } 19421 19422 /* 19423 * Retry the command. Be sure to specify SD_RETRIES_NOCHECK as 19424 * we have already checked the retry counts above. 19425 */ 19426 sd_retry_command(un, bp, SD_RETRIES_NOCHECK, NULL, NULL, 19427 EIO, un->un_busy_timeout, NULL); 19428 19429 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 19430 "sd_pkt_status_busy: exit\n"); 19431 } 19432 19433 19434 /* 19435 * Function: sd_pkt_status_reservation_conflict 19436 * 19437 * Description: Recovery actions for a "STATUS_RESERVATION_CONFLICT" SCSI 19438 * command status. 19439 * 19440 * Context: May be called from interrupt context 19441 */ 19442 19443 static void 19444 sd_pkt_status_reservation_conflict(struct sd_lun *un, struct buf *bp, 19445 struct sd_xbuf *xp, struct scsi_pkt *pktp) 19446 { 19447 ASSERT(un != NULL); 19448 ASSERT(mutex_owned(SD_MUTEX(un))); 19449 ASSERT(bp != NULL); 19450 ASSERT(xp != NULL); 19451 ASSERT(pktp != NULL); 19452 19453 /* 19454 * If the command was PERSISTENT_RESERVATION_[IN|OUT] then reservation 19455 * conflict could be due to various reasons like incorrect keys, not 19456 * registered or not reserved etc. So, we return EACCES to the caller. 19457 */ 19458 if (un->un_reservation_type == SD_SCSI3_RESERVATION) { 19459 int cmd = SD_GET_PKT_OPCODE(pktp); 19460 if ((cmd == SCMD_PERSISTENT_RESERVE_IN) || 19461 (cmd == SCMD_PERSISTENT_RESERVE_OUT)) { 19462 sd_return_failed_command(un, bp, EACCES); 19463 return; 19464 } 19465 } 19466 19467 un->un_resvd_status |= SD_RESERVATION_CONFLICT; 19468 19469 if ((un->un_resvd_status & SD_FAILFAST) != 0) { 19470 if (sd_failfast_enable != 0) { 19471 /* By definition, we must panic here.... */ 19472 sd_panic_for_res_conflict(un); 19473 /*NOTREACHED*/ 19474 } 19475 SD_ERROR(SD_LOG_IO, un, 19476 "sd_handle_resv_conflict: Disk Reserved\n"); 19477 sd_return_failed_command(un, bp, EACCES); 19478 return; 19479 } 19480 19481 /* 19482 * 1147670: retry only if sd_retry_on_reservation_conflict 19483 * property is set (default is 1). Retries will not succeed 19484 * on a disk reserved by another initiator. HA systems 19485 * may reset this via sd.conf to avoid these retries. 19486 * 19487 * Note: The legacy return code for this failure is EIO, however EACCES 19488 * seems more appropriate for a reservation conflict. 19489 */ 19490 if (sd_retry_on_reservation_conflict == 0) { 19491 SD_ERROR(SD_LOG_IO, un, 19492 "sd_handle_resv_conflict: Device Reserved\n"); 19493 sd_return_failed_command(un, bp, EIO); 19494 return; 19495 } 19496 19497 /* 19498 * Retry the command if we can. 19499 * 19500 * Note: The legacy return code for this failure is EIO, however EACCES 19501 * seems more appropriate for a reservation conflict. 19502 */ 19503 sd_retry_command(un, bp, SD_RETRIES_STANDARD, NULL, NULL, EIO, 19504 (clock_t)2, NULL); 19505 } 19506 19507 19508 19509 /* 19510 * Function: sd_pkt_status_qfull 19511 * 19512 * Description: Handle a QUEUE FULL condition from the target. This can 19513 * occur if the HBA does not handle the queue full condition. 19514 * (Basically this means third-party HBAs as Sun HBAs will 19515 * handle the queue full condition.) Note that if there are 19516 * some commands already in the transport, then the queue full 19517 * has occurred because the queue for this nexus is actually 19518 * full. If there are no commands in the transport, then the 19519 * queue full is resulting from some other initiator or lun 19520 * consuming all the resources at the target. 19521 * 19522 * Context: May be called from interrupt context 19523 */ 19524 19525 static void 19526 sd_pkt_status_qfull(struct sd_lun *un, struct buf *bp, 19527 struct sd_xbuf *xp, struct scsi_pkt *pktp) 19528 { 19529 ASSERT(un != NULL); 19530 ASSERT(mutex_owned(SD_MUTEX(un))); 19531 ASSERT(bp != NULL); 19532 ASSERT(xp != NULL); 19533 ASSERT(pktp != NULL); 19534 19535 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 19536 "sd_pkt_status_qfull: entry\n"); 19537 19538 /* 19539 * Just lower the QFULL throttle and retry the command. Note that 19540 * we do not limit the number of retries here. 19541 */ 19542 sd_reduce_throttle(un, SD_THROTTLE_QFULL); 19543 sd_retry_command(un, bp, SD_RETRIES_NOCHECK, NULL, NULL, 0, 19544 SD_RESTART_TIMEOUT, NULL); 19545 19546 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 19547 "sd_pkt_status_qfull: exit\n"); 19548 } 19549 19550 19551 /* 19552 * Function: sd_reset_target 19553 * 19554 * Description: Issue a scsi_reset(9F), with either RESET_LUN, 19555 * RESET_TARGET, or RESET_ALL. 19556 * 19557 * Context: May be called under interrupt context. 19558 */ 19559 19560 static void 19561 sd_reset_target(struct sd_lun *un, struct scsi_pkt *pktp) 19562 { 19563 int rval = 0; 19564 19565 ASSERT(un != NULL); 19566 ASSERT(mutex_owned(SD_MUTEX(un))); 19567 ASSERT(pktp != NULL); 19568 19569 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reset_target: entry\n"); 19570 19571 /* 19572 * No need to reset if the transport layer has already done so. 19573 */ 19574 if ((pktp->pkt_statistics & 19575 (STAT_BUS_RESET | STAT_DEV_RESET | STAT_ABORTED)) != 0) { 19576 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 19577 "sd_reset_target: no reset\n"); 19578 return; 19579 } 19580 19581 mutex_exit(SD_MUTEX(un)); 19582 19583 if (un->un_f_allow_bus_device_reset == TRUE) { 19584 if (un->un_f_lun_reset_enabled == TRUE) { 19585 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 19586 "sd_reset_target: RESET_LUN\n"); 19587 rval = scsi_reset(SD_ADDRESS(un), RESET_LUN); 19588 } 19589 if (rval == 0) { 19590 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 19591 "sd_reset_target: RESET_TARGET\n"); 19592 rval = scsi_reset(SD_ADDRESS(un), RESET_TARGET); 19593 } 19594 } 19595 19596 if (rval == 0) { 19597 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 19598 "sd_reset_target: RESET_ALL\n"); 19599 (void) scsi_reset(SD_ADDRESS(un), RESET_ALL); 19600 } 19601 19602 mutex_enter(SD_MUTEX(un)); 19603 19604 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, "sd_reset_target: exit\n"); 19605 } 19606 19607 /* 19608 * Function: sd_target_change_task 19609 * 19610 * Description: Handle dynamic target change 19611 * 19612 * Context: Executes in a taskq() thread context 19613 */ 19614 static void 19615 sd_target_change_task(void *arg) 19616 { 19617 struct sd_lun *un = arg; 19618 uint64_t capacity; 19619 diskaddr_t label_cap; 19620 uint_t lbasize; 19621 sd_ssc_t *ssc; 19622 19623 ASSERT(un != NULL); 19624 ASSERT(!mutex_owned(SD_MUTEX(un))); 19625 19626 if ((un->un_f_blockcount_is_valid == FALSE) || 19627 (un->un_f_tgt_blocksize_is_valid == FALSE)) { 19628 return; 19629 } 19630 19631 ssc = sd_ssc_init(un); 19632 19633 if (sd_send_scsi_READ_CAPACITY(ssc, &capacity, 19634 &lbasize, SD_PATH_DIRECT) != 0) { 19635 SD_ERROR(SD_LOG_ERROR, un, 19636 "sd_target_change_task: fail to read capacity\n"); 19637 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 19638 goto task_exit; 19639 } 19640 19641 mutex_enter(SD_MUTEX(un)); 19642 if (capacity <= un->un_blockcount) { 19643 mutex_exit(SD_MUTEX(un)); 19644 goto task_exit; 19645 } 19646 19647 sd_update_block_info(un, lbasize, capacity); 19648 mutex_exit(SD_MUTEX(un)); 19649 19650 /* 19651 * If lun is EFI labeled and lun capacity is greater than the 19652 * capacity contained in the label, log a sys event. 19653 */ 19654 if (cmlb_efi_label_capacity(un->un_cmlbhandle, &label_cap, 19655 (void*)SD_PATH_DIRECT) == 0) { 19656 mutex_enter(SD_MUTEX(un)); 19657 if (un->un_f_blockcount_is_valid && 19658 un->un_blockcount > label_cap) { 19659 mutex_exit(SD_MUTEX(un)); 19660 sd_log_lun_expansion_event(un, KM_SLEEP); 19661 } else { 19662 mutex_exit(SD_MUTEX(un)); 19663 } 19664 } 19665 19666 task_exit: 19667 sd_ssc_fini(ssc); 19668 } 19669 19670 19671 /* 19672 * Function: sd_log_dev_status_event 19673 * 19674 * Description: Log EC_dev_status sysevent 19675 * 19676 * Context: Never called from interrupt context 19677 */ 19678 static void 19679 sd_log_dev_status_event(struct sd_lun *un, char *esc, int km_flag) 19680 { 19681 int err; 19682 char *path; 19683 nvlist_t *attr_list; 19684 19685 /* Allocate and build sysevent attribute list */ 19686 err = nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, km_flag); 19687 if (err != 0) { 19688 SD_ERROR(SD_LOG_ERROR, un, 19689 "sd_log_dev_status_event: fail to allocate space\n"); 19690 return; 19691 } 19692 19693 path = kmem_alloc(MAXPATHLEN, km_flag); 19694 if (path == NULL) { 19695 nvlist_free(attr_list); 19696 SD_ERROR(SD_LOG_ERROR, un, 19697 "sd_log_dev_status_event: fail to allocate space\n"); 19698 return; 19699 } 19700 /* 19701 * Add path attribute to identify the lun. 19702 * We are using minor node 'a' as the sysevent attribute. 19703 */ 19704 (void) snprintf(path, MAXPATHLEN, "/devices"); 19705 (void) ddi_pathname(SD_DEVINFO(un), path + strlen(path)); 19706 (void) snprintf(path + strlen(path), MAXPATHLEN - strlen(path), 19707 ":a"); 19708 19709 err = nvlist_add_string(attr_list, DEV_PHYS_PATH, path); 19710 if (err != 0) { 19711 nvlist_free(attr_list); 19712 kmem_free(path, MAXPATHLEN); 19713 SD_ERROR(SD_LOG_ERROR, un, 19714 "sd_log_dev_status_event: fail to add attribute\n"); 19715 return; 19716 } 19717 19718 /* Log dynamic lun expansion sysevent */ 19719 err = ddi_log_sysevent(SD_DEVINFO(un), SUNW_VENDOR, EC_DEV_STATUS, 19720 esc, attr_list, NULL, km_flag); 19721 if (err != DDI_SUCCESS) { 19722 SD_ERROR(SD_LOG_ERROR, un, 19723 "sd_log_dev_status_event: fail to log sysevent\n"); 19724 } 19725 19726 nvlist_free(attr_list); 19727 kmem_free(path, MAXPATHLEN); 19728 } 19729 19730 19731 /* 19732 * Function: sd_log_lun_expansion_event 19733 * 19734 * Description: Log lun expansion sys event 19735 * 19736 * Context: Never called from interrupt context 19737 */ 19738 static void 19739 sd_log_lun_expansion_event(struct sd_lun *un, int km_flag) 19740 { 19741 sd_log_dev_status_event(un, ESC_DEV_DLE, km_flag); 19742 } 19743 19744 19745 /* 19746 * Function: sd_log_eject_request_event 19747 * 19748 * Description: Log eject request sysevent 19749 * 19750 * Context: Never called from interrupt context 19751 */ 19752 static void 19753 sd_log_eject_request_event(struct sd_lun *un, int km_flag) 19754 { 19755 sd_log_dev_status_event(un, ESC_DEV_EJECT_REQUEST, km_flag); 19756 } 19757 19758 19759 /* 19760 * Function: sd_media_change_task 19761 * 19762 * Description: Recovery action for CDROM to become available. 19763 * 19764 * Context: Executes in a taskq() thread context 19765 */ 19766 19767 static void 19768 sd_media_change_task(void *arg) 19769 { 19770 struct scsi_pkt *pktp = arg; 19771 struct sd_lun *un; 19772 struct buf *bp; 19773 struct sd_xbuf *xp; 19774 int err = 0; 19775 int retry_count = 0; 19776 int retry_limit = SD_UNIT_ATTENTION_RETRY/10; 19777 struct sd_sense_info si; 19778 19779 ASSERT(pktp != NULL); 19780 bp = (struct buf *)pktp->pkt_private; 19781 ASSERT(bp != NULL); 19782 xp = SD_GET_XBUF(bp); 19783 ASSERT(xp != NULL); 19784 un = SD_GET_UN(bp); 19785 ASSERT(un != NULL); 19786 ASSERT(!mutex_owned(SD_MUTEX(un))); 19787 ASSERT(un->un_f_monitor_media_state); 19788 19789 si.ssi_severity = SCSI_ERR_INFO; 19790 si.ssi_pfa_flag = FALSE; 19791 19792 /* 19793 * When a reset is issued on a CDROM, it takes a long time to 19794 * recover. First few attempts to read capacity and other things 19795 * related to handling unit attention fail (with a ASC 0x4 and 19796 * ASCQ 0x1). In that case we want to do enough retries and we want 19797 * to limit the retries in other cases of genuine failures like 19798 * no media in drive. 19799 */ 19800 while (retry_count++ < retry_limit) { 19801 if ((err = sd_handle_mchange(un)) == 0) { 19802 break; 19803 } 19804 if (err == EAGAIN) { 19805 retry_limit = SD_UNIT_ATTENTION_RETRY; 19806 } 19807 /* Sleep for 0.5 sec. & try again */ 19808 delay(drv_usectohz(500000)); 19809 } 19810 19811 /* 19812 * Dispatch (retry or fail) the original command here, 19813 * along with appropriate console messages.... 19814 * 19815 * Must grab the mutex before calling sd_retry_command, 19816 * sd_print_sense_msg and sd_return_failed_command. 19817 */ 19818 mutex_enter(SD_MUTEX(un)); 19819 if (err != SD_CMD_SUCCESS) { 19820 SD_UPDATE_ERRSTATS(un, sd_harderrs); 19821 SD_UPDATE_ERRSTATS(un, sd_rq_nodev_err); 19822 si.ssi_severity = SCSI_ERR_FATAL; 19823 sd_print_sense_msg(un, bp, &si, SD_NO_RETRY_ISSUED); 19824 sd_return_failed_command(un, bp, EIO); 19825 } else { 19826 sd_retry_command(un, bp, SD_RETRIES_UA, sd_print_sense_msg, 19827 &si, EIO, (clock_t)0, NULL); 19828 } 19829 mutex_exit(SD_MUTEX(un)); 19830 } 19831 19832 19833 19834 /* 19835 * Function: sd_handle_mchange 19836 * 19837 * Description: Perform geometry validation & other recovery when CDROM 19838 * has been removed from drive. 19839 * 19840 * Return Code: 0 for success 19841 * errno-type return code of either sd_send_scsi_DOORLOCK() or 19842 * sd_send_scsi_READ_CAPACITY() 19843 * 19844 * Context: Executes in a taskq() thread context 19845 */ 19846 19847 static int 19848 sd_handle_mchange(struct sd_lun *un) 19849 { 19850 uint64_t capacity; 19851 uint32_t lbasize; 19852 int rval; 19853 sd_ssc_t *ssc; 19854 19855 ASSERT(!mutex_owned(SD_MUTEX(un))); 19856 ASSERT(un->un_f_monitor_media_state); 19857 19858 ssc = sd_ssc_init(un); 19859 rval = sd_send_scsi_READ_CAPACITY(ssc, &capacity, &lbasize, 19860 SD_PATH_DIRECT_PRIORITY); 19861 19862 if (rval != 0) 19863 goto failed; 19864 19865 mutex_enter(SD_MUTEX(un)); 19866 sd_update_block_info(un, lbasize, capacity); 19867 19868 if (un->un_errstats != NULL) { 19869 struct sd_errstats *stp = 19870 (struct sd_errstats *)un->un_errstats->ks_data; 19871 stp->sd_capacity.value.ui64 = (uint64_t) 19872 ((uint64_t)un->un_blockcount * 19873 (uint64_t)un->un_tgt_blocksize); 19874 } 19875 19876 /* 19877 * Check if the media in the device is writable or not 19878 */ 19879 if (ISCD(un)) { 19880 sd_check_for_writable_cd(ssc, SD_PATH_DIRECT_PRIORITY); 19881 } 19882 19883 /* 19884 * Note: Maybe let the strategy/partitioning chain worry about getting 19885 * valid geometry. 19886 */ 19887 mutex_exit(SD_MUTEX(un)); 19888 cmlb_invalidate(un->un_cmlbhandle, (void *)SD_PATH_DIRECT_PRIORITY); 19889 19890 19891 if (cmlb_validate(un->un_cmlbhandle, 0, 19892 (void *)SD_PATH_DIRECT_PRIORITY) != 0) { 19893 sd_ssc_fini(ssc); 19894 return (EIO); 19895 } else { 19896 if (un->un_f_pkstats_enabled) { 19897 sd_set_pstats(un); 19898 SD_TRACE(SD_LOG_IO_PARTITION, un, 19899 "sd_handle_mchange: un:0x%p pstats created and " 19900 "set\n", un); 19901 } 19902 } 19903 19904 /* 19905 * Try to lock the door 19906 */ 19907 rval = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_PREVENT, 19908 SD_PATH_DIRECT_PRIORITY); 19909 failed: 19910 if (rval != 0) 19911 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 19912 sd_ssc_fini(ssc); 19913 return (rval); 19914 } 19915 19916 19917 /* 19918 * Function: sd_send_scsi_DOORLOCK 19919 * 19920 * Description: Issue the scsi DOOR LOCK command 19921 * 19922 * Arguments: ssc - ssc contains pointer to driver soft state (unit) 19923 * structure for this target. 19924 * flag - SD_REMOVAL_ALLOW 19925 * SD_REMOVAL_PREVENT 19926 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and 19927 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY 19928 * to use the USCSI "direct" chain and bypass the normal 19929 * command waitq. SD_PATH_DIRECT_PRIORITY is used when this 19930 * command is issued as part of an error recovery action. 19931 * 19932 * Return Code: 0 - Success 19933 * errno return code from sd_ssc_send() 19934 * 19935 * Context: Can sleep. 19936 */ 19937 19938 static int 19939 sd_send_scsi_DOORLOCK(sd_ssc_t *ssc, int flag, int path_flag) 19940 { 19941 struct scsi_extended_sense sense_buf; 19942 union scsi_cdb cdb; 19943 struct uscsi_cmd ucmd_buf; 19944 int status; 19945 struct sd_lun *un; 19946 19947 ASSERT(ssc != NULL); 19948 un = ssc->ssc_un; 19949 ASSERT(un != NULL); 19950 ASSERT(!mutex_owned(SD_MUTEX(un))); 19951 19952 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_DOORLOCK: entry: un:0x%p\n", un); 19953 19954 /* already determined doorlock is not supported, fake success */ 19955 if (un->un_f_doorlock_supported == FALSE) { 19956 return (0); 19957 } 19958 19959 /* 19960 * If we are ejecting and see an SD_REMOVAL_PREVENT 19961 * ignore the command so we can complete the eject 19962 * operation. 19963 */ 19964 if (flag == SD_REMOVAL_PREVENT) { 19965 mutex_enter(SD_MUTEX(un)); 19966 if (un->un_f_ejecting == TRUE) { 19967 mutex_exit(SD_MUTEX(un)); 19968 return (EAGAIN); 19969 } 19970 mutex_exit(SD_MUTEX(un)); 19971 } 19972 19973 bzero(&cdb, sizeof (cdb)); 19974 bzero(&ucmd_buf, sizeof (ucmd_buf)); 19975 19976 cdb.scc_cmd = SCMD_DOORLOCK; 19977 cdb.cdb_opaque[4] = (uchar_t)flag; 19978 19979 ucmd_buf.uscsi_cdb = (char *)&cdb; 19980 ucmd_buf.uscsi_cdblen = CDB_GROUP0; 19981 ucmd_buf.uscsi_bufaddr = NULL; 19982 ucmd_buf.uscsi_buflen = 0; 19983 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf; 19984 ucmd_buf.uscsi_rqlen = sizeof (sense_buf); 19985 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_SILENT; 19986 ucmd_buf.uscsi_timeout = 15; 19987 19988 SD_TRACE(SD_LOG_IO, un, 19989 "sd_send_scsi_DOORLOCK: returning sd_ssc_send\n"); 19990 19991 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL, 19992 UIO_SYSSPACE, path_flag); 19993 19994 if (status == 0) 19995 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 19996 19997 if ((status == EIO) && (ucmd_buf.uscsi_status == STATUS_CHECK) && 19998 (ucmd_buf.uscsi_rqstatus == STATUS_GOOD) && 19999 (scsi_sense_key((uint8_t *)&sense_buf) == KEY_ILLEGAL_REQUEST)) { 20000 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 20001 20002 /* fake success and skip subsequent doorlock commands */ 20003 un->un_f_doorlock_supported = FALSE; 20004 return (0); 20005 } 20006 20007 return (status); 20008 } 20009 20010 /* 20011 * Function: sd_send_scsi_READ_CAPACITY 20012 * 20013 * Description: This routine uses the scsi READ CAPACITY command to determine 20014 * the device capacity in number of blocks and the device native 20015 * block size. If this function returns a failure, then the 20016 * values in *capp and *lbap are undefined. If the capacity 20017 * returned is 0xffffffff then the lun is too large for a 20018 * normal READ CAPACITY command and the results of a 20019 * READ CAPACITY 16 will be used instead. 20020 * 20021 * Arguments: ssc - ssc contains ptr to soft state struct for the target 20022 * capp - ptr to unsigned 64-bit variable to receive the 20023 * capacity value from the command. 20024 * lbap - ptr to unsigned 32-bit varaible to receive the 20025 * block size value from the command 20026 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and 20027 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY 20028 * to use the USCSI "direct" chain and bypass the normal 20029 * command waitq. SD_PATH_DIRECT_PRIORITY is used when this 20030 * command is issued as part of an error recovery action. 20031 * 20032 * Return Code: 0 - Success 20033 * EIO - IO error 20034 * EACCES - Reservation conflict detected 20035 * EAGAIN - Device is becoming ready 20036 * errno return code from sd_ssc_send() 20037 * 20038 * Context: Can sleep. Blocks until command completes. 20039 */ 20040 20041 #define SD_CAPACITY_SIZE sizeof (struct scsi_capacity) 20042 20043 static int 20044 sd_send_scsi_READ_CAPACITY(sd_ssc_t *ssc, uint64_t *capp, uint32_t *lbap, 20045 int path_flag) 20046 { 20047 struct scsi_extended_sense sense_buf; 20048 struct uscsi_cmd ucmd_buf; 20049 union scsi_cdb cdb; 20050 uint32_t *capacity_buf; 20051 uint64_t capacity; 20052 uint32_t lbasize; 20053 uint32_t pbsize; 20054 int status; 20055 struct sd_lun *un; 20056 20057 ASSERT(ssc != NULL); 20058 20059 un = ssc->ssc_un; 20060 ASSERT(un != NULL); 20061 ASSERT(!mutex_owned(SD_MUTEX(un))); 20062 ASSERT(capp != NULL); 20063 ASSERT(lbap != NULL); 20064 20065 SD_TRACE(SD_LOG_IO, un, 20066 "sd_send_scsi_READ_CAPACITY: entry: un:0x%p\n", un); 20067 20068 /* 20069 * First send a READ_CAPACITY command to the target. 20070 * (This command is mandatory under SCSI-2.) 20071 * 20072 * Set up the CDB for the READ_CAPACITY command. The Partial 20073 * Medium Indicator bit is cleared. The address field must be 20074 * zero if the PMI bit is zero. 20075 */ 20076 bzero(&cdb, sizeof (cdb)); 20077 bzero(&ucmd_buf, sizeof (ucmd_buf)); 20078 20079 capacity_buf = kmem_zalloc(SD_CAPACITY_SIZE, KM_SLEEP); 20080 20081 cdb.scc_cmd = SCMD_READ_CAPACITY; 20082 20083 ucmd_buf.uscsi_cdb = (char *)&cdb; 20084 ucmd_buf.uscsi_cdblen = CDB_GROUP1; 20085 ucmd_buf.uscsi_bufaddr = (caddr_t)capacity_buf; 20086 ucmd_buf.uscsi_buflen = SD_CAPACITY_SIZE; 20087 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf; 20088 ucmd_buf.uscsi_rqlen = sizeof (sense_buf); 20089 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT; 20090 ucmd_buf.uscsi_timeout = 60; 20091 20092 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL, 20093 UIO_SYSSPACE, path_flag); 20094 20095 switch (status) { 20096 case 0: 20097 /* Return failure if we did not get valid capacity data. */ 20098 if (ucmd_buf.uscsi_resid != 0) { 20099 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1, 20100 "sd_send_scsi_READ_CAPACITY received invalid " 20101 "capacity data"); 20102 kmem_free(capacity_buf, SD_CAPACITY_SIZE); 20103 return (EIO); 20104 } 20105 /* 20106 * Read capacity and block size from the READ CAPACITY 10 data. 20107 * This data may be adjusted later due to device specific 20108 * issues. 20109 * 20110 * According to the SCSI spec, the READ CAPACITY 10 20111 * command returns the following: 20112 * 20113 * bytes 0-3: Maximum logical block address available. 20114 * (MSB in byte:0 & LSB in byte:3) 20115 * 20116 * bytes 4-7: Block length in bytes 20117 * (MSB in byte:4 & LSB in byte:7) 20118 * 20119 */ 20120 capacity = BE_32(capacity_buf[0]); 20121 lbasize = BE_32(capacity_buf[1]); 20122 20123 /* 20124 * Done with capacity_buf 20125 */ 20126 kmem_free(capacity_buf, SD_CAPACITY_SIZE); 20127 20128 /* 20129 * if the reported capacity is set to all 0xf's, then 20130 * this disk is too large and requires SBC-2 commands. 20131 * Reissue the request using READ CAPACITY 16. 20132 */ 20133 if (capacity == 0xffffffff) { 20134 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 20135 status = sd_send_scsi_READ_CAPACITY_16(ssc, &capacity, 20136 &lbasize, &pbsize, path_flag); 20137 if (status != 0) { 20138 return (status); 20139 } else { 20140 goto rc16_done; 20141 } 20142 } 20143 break; /* Success! */ 20144 case EIO: 20145 switch (ucmd_buf.uscsi_status) { 20146 case STATUS_RESERVATION_CONFLICT: 20147 status = EACCES; 20148 break; 20149 case STATUS_CHECK: 20150 /* 20151 * Check condition; look for ASC/ASCQ of 0x04/0x01 20152 * (LOGICAL UNIT IS IN PROCESS OF BECOMING READY) 20153 */ 20154 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) && 20155 (scsi_sense_asc((uint8_t *)&sense_buf) == 0x04) && 20156 (scsi_sense_ascq((uint8_t *)&sense_buf) == 0x01)) { 20157 kmem_free(capacity_buf, SD_CAPACITY_SIZE); 20158 return (EAGAIN); 20159 } 20160 break; 20161 default: 20162 break; 20163 } 20164 /* FALLTHRU */ 20165 default: 20166 kmem_free(capacity_buf, SD_CAPACITY_SIZE); 20167 return (status); 20168 } 20169 20170 /* 20171 * Some ATAPI CD-ROM drives report inaccurate LBA size values 20172 * (2352 and 0 are common) so for these devices always force the value 20173 * to 2048 as required by the ATAPI specs. 20174 */ 20175 if ((un->un_f_cfg_is_atapi == TRUE) && (ISCD(un))) { 20176 lbasize = 2048; 20177 } 20178 20179 /* 20180 * Get the maximum LBA value from the READ CAPACITY data. 20181 * Here we assume that the Partial Medium Indicator (PMI) bit 20182 * was cleared when issuing the command. This means that the LBA 20183 * returned from the device is the LBA of the last logical block 20184 * on the logical unit. The actual logical block count will be 20185 * this value plus one. 20186 */ 20187 capacity += 1; 20188 20189 /* 20190 * Currently, for removable media, the capacity is saved in terms 20191 * of un->un_sys_blocksize, so scale the capacity value to reflect this. 20192 */ 20193 if (un->un_f_has_removable_media) 20194 capacity *= (lbasize / un->un_sys_blocksize); 20195 20196 rc16_done: 20197 20198 /* 20199 * Copy the values from the READ CAPACITY command into the space 20200 * provided by the caller. 20201 */ 20202 *capp = capacity; 20203 *lbap = lbasize; 20204 20205 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_READ_CAPACITY: " 20206 "capacity:0x%llx lbasize:0x%x\n", capacity, lbasize); 20207 20208 /* 20209 * Both the lbasize and capacity from the device must be nonzero, 20210 * otherwise we assume that the values are not valid and return 20211 * failure to the caller. (4203735) 20212 */ 20213 if ((capacity == 0) || (lbasize == 0)) { 20214 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1, 20215 "sd_send_scsi_READ_CAPACITY received invalid value " 20216 "capacity %llu lbasize %d", capacity, lbasize); 20217 return (EIO); 20218 } 20219 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 20220 return (0); 20221 } 20222 20223 /* 20224 * Function: sd_send_scsi_READ_CAPACITY_16 20225 * 20226 * Description: This routine uses the scsi READ CAPACITY 16 command to 20227 * determine the device capacity in number of blocks and the 20228 * device native block size. If this function returns a failure, 20229 * then the values in *capp and *lbap are undefined. 20230 * This routine should be called by sd_send_scsi_READ_CAPACITY 20231 * which will apply any device specific adjustments to capacity 20232 * and lbasize. One exception is it is also called by 20233 * sd_get_media_info_ext. In that function, there is no need to 20234 * adjust the capacity and lbasize. 20235 * 20236 * Arguments: ssc - ssc contains ptr to soft state struct for the target 20237 * capp - ptr to unsigned 64-bit variable to receive the 20238 * capacity value from the command. 20239 * lbap - ptr to unsigned 32-bit varaible to receive the 20240 * block size value from the command 20241 * psp - ptr to unsigned 32-bit variable to receive the 20242 * physical block size value from the command 20243 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and 20244 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY 20245 * to use the USCSI "direct" chain and bypass the normal 20246 * command waitq. SD_PATH_DIRECT_PRIORITY is used when 20247 * this command is issued as part of an error recovery 20248 * action. 20249 * 20250 * Return Code: 0 - Success 20251 * EIO - IO error 20252 * EACCES - Reservation conflict detected 20253 * EAGAIN - Device is becoming ready 20254 * errno return code from sd_ssc_send() 20255 * 20256 * Context: Can sleep. Blocks until command completes. 20257 */ 20258 20259 #define SD_CAPACITY_16_SIZE sizeof (struct scsi_capacity_16) 20260 20261 static int 20262 sd_send_scsi_READ_CAPACITY_16(sd_ssc_t *ssc, uint64_t *capp, 20263 uint32_t *lbap, uint32_t *psp, int path_flag) 20264 { 20265 struct scsi_extended_sense sense_buf; 20266 struct uscsi_cmd ucmd_buf; 20267 union scsi_cdb cdb; 20268 uint64_t *capacity16_buf; 20269 uint64_t capacity; 20270 uint32_t lbasize; 20271 uint32_t pbsize; 20272 uint32_t lbpb_exp; 20273 int status; 20274 struct sd_lun *un; 20275 20276 ASSERT(ssc != NULL); 20277 20278 un = ssc->ssc_un; 20279 ASSERT(un != NULL); 20280 ASSERT(!mutex_owned(SD_MUTEX(un))); 20281 ASSERT(capp != NULL); 20282 ASSERT(lbap != NULL); 20283 20284 SD_TRACE(SD_LOG_IO, un, 20285 "sd_send_scsi_READ_CAPACITY: entry: un:0x%p\n", un); 20286 20287 /* 20288 * First send a READ_CAPACITY_16 command to the target. 20289 * 20290 * Set up the CDB for the READ_CAPACITY_16 command. The Partial 20291 * Medium Indicator bit is cleared. The address field must be 20292 * zero if the PMI bit is zero. 20293 */ 20294 bzero(&cdb, sizeof (cdb)); 20295 bzero(&ucmd_buf, sizeof (ucmd_buf)); 20296 20297 capacity16_buf = kmem_zalloc(SD_CAPACITY_16_SIZE, KM_SLEEP); 20298 20299 ucmd_buf.uscsi_cdb = (char *)&cdb; 20300 ucmd_buf.uscsi_cdblen = CDB_GROUP4; 20301 ucmd_buf.uscsi_bufaddr = (caddr_t)capacity16_buf; 20302 ucmd_buf.uscsi_buflen = SD_CAPACITY_16_SIZE; 20303 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf; 20304 ucmd_buf.uscsi_rqlen = sizeof (sense_buf); 20305 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT; 20306 ucmd_buf.uscsi_timeout = 60; 20307 20308 /* 20309 * Read Capacity (16) is a Service Action In command. One 20310 * command byte (0x9E) is overloaded for multiple operations, 20311 * with the second CDB byte specifying the desired operation 20312 */ 20313 cdb.scc_cmd = SCMD_SVC_ACTION_IN_G4; 20314 cdb.cdb_opaque[1] = SSVC_ACTION_READ_CAPACITY_G4; 20315 20316 /* 20317 * Fill in allocation length field 20318 */ 20319 FORMG4COUNT(&cdb, ucmd_buf.uscsi_buflen); 20320 20321 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL, 20322 UIO_SYSSPACE, path_flag); 20323 20324 switch (status) { 20325 case 0: 20326 /* Return failure if we did not get valid capacity data. */ 20327 if (ucmd_buf.uscsi_resid > 20) { 20328 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1, 20329 "sd_send_scsi_READ_CAPACITY_16 received invalid " 20330 "capacity data"); 20331 kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE); 20332 return (EIO); 20333 } 20334 20335 /* 20336 * Read capacity and block size from the READ CAPACITY 16 data. 20337 * This data may be adjusted later due to device specific 20338 * issues. 20339 * 20340 * According to the SCSI spec, the READ CAPACITY 16 20341 * command returns the following: 20342 * 20343 * bytes 0-7: Maximum logical block address available. 20344 * (MSB in byte:0 & LSB in byte:7) 20345 * 20346 * bytes 8-11: Block length in bytes 20347 * (MSB in byte:8 & LSB in byte:11) 20348 * 20349 * byte 13: LOGICAL BLOCKS PER PHYSICAL BLOCK EXPONENT 20350 */ 20351 capacity = BE_64(capacity16_buf[0]); 20352 lbasize = BE_32(*(uint32_t *)&capacity16_buf[1]); 20353 lbpb_exp = (BE_64(capacity16_buf[1]) >> 16) & 0x0f; 20354 20355 pbsize = lbasize << lbpb_exp; 20356 20357 /* 20358 * Done with capacity16_buf 20359 */ 20360 kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE); 20361 20362 /* 20363 * if the reported capacity is set to all 0xf's, then 20364 * this disk is too large. This could only happen with 20365 * a device that supports LBAs larger than 64 bits which 20366 * are not defined by any current T10 standards. 20367 */ 20368 if (capacity == 0xffffffffffffffff) { 20369 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1, 20370 "disk is too large"); 20371 return (EIO); 20372 } 20373 break; /* Success! */ 20374 case EIO: 20375 switch (ucmd_buf.uscsi_status) { 20376 case STATUS_RESERVATION_CONFLICT: 20377 status = EACCES; 20378 break; 20379 case STATUS_CHECK: 20380 /* 20381 * Check condition; look for ASC/ASCQ of 0x04/0x01 20382 * (LOGICAL UNIT IS IN PROCESS OF BECOMING READY) 20383 */ 20384 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) && 20385 (scsi_sense_asc((uint8_t *)&sense_buf) == 0x04) && 20386 (scsi_sense_ascq((uint8_t *)&sense_buf) == 0x01)) { 20387 kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE); 20388 return (EAGAIN); 20389 } 20390 break; 20391 default: 20392 break; 20393 } 20394 /* FALLTHRU */ 20395 default: 20396 kmem_free(capacity16_buf, SD_CAPACITY_16_SIZE); 20397 return (status); 20398 } 20399 20400 /* 20401 * Some ATAPI CD-ROM drives report inaccurate LBA size values 20402 * (2352 and 0 are common) so for these devices always force the value 20403 * to 2048 as required by the ATAPI specs. 20404 */ 20405 if ((un->un_f_cfg_is_atapi == TRUE) && (ISCD(un))) { 20406 lbasize = 2048; 20407 } 20408 20409 /* 20410 * Get the maximum LBA value from the READ CAPACITY 16 data. 20411 * Here we assume that the Partial Medium Indicator (PMI) bit 20412 * was cleared when issuing the command. This means that the LBA 20413 * returned from the device is the LBA of the last logical block 20414 * on the logical unit. The actual logical block count will be 20415 * this value plus one. 20416 */ 20417 capacity += 1; 20418 20419 /* 20420 * Currently, for removable media, the capacity is saved in terms 20421 * of un->un_sys_blocksize, so scale the capacity value to reflect this. 20422 */ 20423 if (un->un_f_has_removable_media) 20424 capacity *= (lbasize / un->un_sys_blocksize); 20425 20426 *capp = capacity; 20427 *lbap = lbasize; 20428 *psp = pbsize; 20429 20430 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_READ_CAPACITY_16: " 20431 "capacity:0x%llx lbasize:0x%x, pbsize: 0x%x\n", 20432 capacity, lbasize, pbsize); 20433 20434 if ((capacity == 0) || (lbasize == 0) || (pbsize == 0)) { 20435 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1, 20436 "sd_send_scsi_READ_CAPACITY_16 received invalid value " 20437 "capacity %llu lbasize %d pbsize %d", capacity, lbasize); 20438 return (EIO); 20439 } 20440 20441 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 20442 return (0); 20443 } 20444 20445 20446 /* 20447 * Function: sd_send_scsi_START_STOP_UNIT 20448 * 20449 * Description: Issue a scsi START STOP UNIT command to the target. 20450 * 20451 * Arguments: ssc - ssc contatins pointer to driver soft state (unit) 20452 * structure for this target. 20453 * pc_flag - SD_POWER_CONDITION 20454 * SD_START_STOP 20455 * flag - SD_TARGET_START 20456 * SD_TARGET_STOP 20457 * SD_TARGET_EJECT 20458 * SD_TARGET_CLOSE 20459 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and 20460 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY 20461 * to use the USCSI "direct" chain and bypass the normal 20462 * command waitq. SD_PATH_DIRECT_PRIORITY is used when this 20463 * command is issued as part of an error recovery action. 20464 * 20465 * Return Code: 0 - Success 20466 * EIO - IO error 20467 * EACCES - Reservation conflict detected 20468 * ENXIO - Not Ready, medium not present 20469 * errno return code from sd_ssc_send() 20470 * 20471 * Context: Can sleep. 20472 */ 20473 20474 static int 20475 sd_send_scsi_START_STOP_UNIT(sd_ssc_t *ssc, int pc_flag, int flag, 20476 int path_flag) 20477 { 20478 struct scsi_extended_sense sense_buf; 20479 union scsi_cdb cdb; 20480 struct uscsi_cmd ucmd_buf; 20481 int status; 20482 struct sd_lun *un; 20483 20484 ASSERT(ssc != NULL); 20485 un = ssc->ssc_un; 20486 ASSERT(un != NULL); 20487 ASSERT(!mutex_owned(SD_MUTEX(un))); 20488 20489 SD_TRACE(SD_LOG_IO, un, 20490 "sd_send_scsi_START_STOP_UNIT: entry: un:0x%p\n", un); 20491 20492 if (un->un_f_check_start_stop && 20493 (pc_flag == SD_START_STOP) && 20494 ((flag == SD_TARGET_START) || (flag == SD_TARGET_STOP)) && 20495 (un->un_f_start_stop_supported != TRUE)) { 20496 return (0); 20497 } 20498 20499 /* 20500 * If we are performing an eject operation and 20501 * we receive any command other than SD_TARGET_EJECT 20502 * we should immediately return. 20503 */ 20504 if (flag != SD_TARGET_EJECT) { 20505 mutex_enter(SD_MUTEX(un)); 20506 if (un->un_f_ejecting == TRUE) { 20507 mutex_exit(SD_MUTEX(un)); 20508 return (EAGAIN); 20509 } 20510 mutex_exit(SD_MUTEX(un)); 20511 } 20512 20513 bzero(&cdb, sizeof (cdb)); 20514 bzero(&ucmd_buf, sizeof (ucmd_buf)); 20515 bzero(&sense_buf, sizeof (struct scsi_extended_sense)); 20516 20517 cdb.scc_cmd = SCMD_START_STOP; 20518 cdb.cdb_opaque[4] = (pc_flag == SD_POWER_CONDITION) ? 20519 (uchar_t)(flag << 4) : (uchar_t)flag; 20520 20521 ucmd_buf.uscsi_cdb = (char *)&cdb; 20522 ucmd_buf.uscsi_cdblen = CDB_GROUP0; 20523 ucmd_buf.uscsi_bufaddr = NULL; 20524 ucmd_buf.uscsi_buflen = 0; 20525 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf; 20526 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense); 20527 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_SILENT; 20528 ucmd_buf.uscsi_timeout = 200; 20529 20530 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL, 20531 UIO_SYSSPACE, path_flag); 20532 20533 switch (status) { 20534 case 0: 20535 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 20536 break; /* Success! */ 20537 case EIO: 20538 switch (ucmd_buf.uscsi_status) { 20539 case STATUS_RESERVATION_CONFLICT: 20540 status = EACCES; 20541 break; 20542 case STATUS_CHECK: 20543 if (ucmd_buf.uscsi_rqstatus == STATUS_GOOD) { 20544 switch (scsi_sense_key( 20545 (uint8_t *)&sense_buf)) { 20546 case KEY_ILLEGAL_REQUEST: 20547 status = ENOTSUP; 20548 break; 20549 case KEY_NOT_READY: 20550 if (scsi_sense_asc( 20551 (uint8_t *)&sense_buf) 20552 == 0x3A) { 20553 status = ENXIO; 20554 } 20555 break; 20556 default: 20557 break; 20558 } 20559 } 20560 break; 20561 default: 20562 break; 20563 } 20564 break; 20565 default: 20566 break; 20567 } 20568 20569 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_START_STOP_UNIT: exit\n"); 20570 20571 return (status); 20572 } 20573 20574 20575 /* 20576 * Function: sd_start_stop_unit_callback 20577 * 20578 * Description: timeout(9F) callback to begin recovery process for a 20579 * device that has spun down. 20580 * 20581 * Arguments: arg - pointer to associated softstate struct. 20582 * 20583 * Context: Executes in a timeout(9F) thread context 20584 */ 20585 20586 static void 20587 sd_start_stop_unit_callback(void *arg) 20588 { 20589 struct sd_lun *un = arg; 20590 ASSERT(un != NULL); 20591 ASSERT(!mutex_owned(SD_MUTEX(un))); 20592 20593 SD_TRACE(SD_LOG_IO, un, "sd_start_stop_unit_callback: entry\n"); 20594 20595 (void) taskq_dispatch(sd_tq, sd_start_stop_unit_task, un, KM_NOSLEEP); 20596 } 20597 20598 20599 /* 20600 * Function: sd_start_stop_unit_task 20601 * 20602 * Description: Recovery procedure when a drive is spun down. 20603 * 20604 * Arguments: arg - pointer to associated softstate struct. 20605 * 20606 * Context: Executes in a taskq() thread context 20607 */ 20608 20609 static void 20610 sd_start_stop_unit_task(void *arg) 20611 { 20612 struct sd_lun *un = arg; 20613 sd_ssc_t *ssc; 20614 int power_level; 20615 int rval; 20616 20617 ASSERT(un != NULL); 20618 ASSERT(!mutex_owned(SD_MUTEX(un))); 20619 20620 SD_TRACE(SD_LOG_IO, un, "sd_start_stop_unit_task: entry\n"); 20621 20622 /* 20623 * Some unformatted drives report not ready error, no need to 20624 * restart if format has been initiated. 20625 */ 20626 mutex_enter(SD_MUTEX(un)); 20627 if (un->un_f_format_in_progress == TRUE) { 20628 mutex_exit(SD_MUTEX(un)); 20629 return; 20630 } 20631 mutex_exit(SD_MUTEX(un)); 20632 20633 ssc = sd_ssc_init(un); 20634 /* 20635 * When a START STOP command is issued from here, it is part of a 20636 * failure recovery operation and must be issued before any other 20637 * commands, including any pending retries. Thus it must be sent 20638 * using SD_PATH_DIRECT_PRIORITY. It doesn't matter if the spin up 20639 * succeeds or not, we will start I/O after the attempt. 20640 * If power condition is supported and the current power level 20641 * is capable of performing I/O, we should set the power condition 20642 * to that level. Otherwise, set the power condition to ACTIVE. 20643 */ 20644 if (un->un_f_power_condition_supported) { 20645 mutex_enter(SD_MUTEX(un)); 20646 ASSERT(SD_PM_IS_LEVEL_VALID(un, un->un_power_level)); 20647 power_level = sd_pwr_pc.ran_perf[un->un_power_level] 20648 > 0 ? un->un_power_level : SD_SPINDLE_ACTIVE; 20649 mutex_exit(SD_MUTEX(un)); 20650 rval = sd_send_scsi_START_STOP_UNIT(ssc, SD_POWER_CONDITION, 20651 sd_pl2pc[power_level], SD_PATH_DIRECT_PRIORITY); 20652 } else { 20653 rval = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP, 20654 SD_TARGET_START, SD_PATH_DIRECT_PRIORITY); 20655 } 20656 20657 if (rval != 0) 20658 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 20659 sd_ssc_fini(ssc); 20660 /* 20661 * The above call blocks until the START_STOP_UNIT command completes. 20662 * Now that it has completed, we must re-try the original IO that 20663 * received the NOT READY condition in the first place. There are 20664 * three possible conditions here: 20665 * 20666 * (1) The original IO is on un_retry_bp. 20667 * (2) The original IO is on the regular wait queue, and un_retry_bp 20668 * is NULL. 20669 * (3) The original IO is on the regular wait queue, and un_retry_bp 20670 * points to some other, unrelated bp. 20671 * 20672 * For each case, we must call sd_start_cmds() with un_retry_bp 20673 * as the argument. If un_retry_bp is NULL, this will initiate 20674 * processing of the regular wait queue. If un_retry_bp is not NULL, 20675 * then this will process the bp on un_retry_bp. That may or may not 20676 * be the original IO, but that does not matter: the important thing 20677 * is to keep the IO processing going at this point. 20678 * 20679 * Note: This is a very specific error recovery sequence associated 20680 * with a drive that is not spun up. We attempt a START_STOP_UNIT and 20681 * serialize the I/O with completion of the spin-up. 20682 */ 20683 mutex_enter(SD_MUTEX(un)); 20684 SD_TRACE(SD_LOG_IO_CORE | SD_LOG_ERROR, un, 20685 "sd_start_stop_unit_task: un:0x%p starting bp:0x%p\n", 20686 un, un->un_retry_bp); 20687 un->un_startstop_timeid = NULL; /* Timeout is no longer pending */ 20688 sd_start_cmds(un, un->un_retry_bp); 20689 mutex_exit(SD_MUTEX(un)); 20690 20691 SD_TRACE(SD_LOG_IO, un, "sd_start_stop_unit_task: exit\n"); 20692 } 20693 20694 20695 /* 20696 * Function: sd_send_scsi_INQUIRY 20697 * 20698 * Description: Issue the scsi INQUIRY command. 20699 * 20700 * Arguments: ssc - ssc contains pointer to driver soft state (unit) 20701 * structure for this target. 20702 * bufaddr 20703 * buflen 20704 * evpd 20705 * page_code 20706 * page_length 20707 * 20708 * Return Code: 0 - Success 20709 * errno return code from sd_ssc_send() 20710 * 20711 * Context: Can sleep. Does not return until command is completed. 20712 */ 20713 20714 static int 20715 sd_send_scsi_INQUIRY(sd_ssc_t *ssc, uchar_t *bufaddr, size_t buflen, 20716 uchar_t evpd, uchar_t page_code, size_t *residp) 20717 { 20718 union scsi_cdb cdb; 20719 struct uscsi_cmd ucmd_buf; 20720 int status; 20721 struct sd_lun *un; 20722 20723 ASSERT(ssc != NULL); 20724 un = ssc->ssc_un; 20725 ASSERT(un != NULL); 20726 ASSERT(!mutex_owned(SD_MUTEX(un))); 20727 ASSERT(bufaddr != NULL); 20728 20729 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_INQUIRY: entry: un:0x%p\n", un); 20730 20731 bzero(&cdb, sizeof (cdb)); 20732 bzero(&ucmd_buf, sizeof (ucmd_buf)); 20733 bzero(bufaddr, buflen); 20734 20735 cdb.scc_cmd = SCMD_INQUIRY; 20736 cdb.cdb_opaque[1] = evpd; 20737 cdb.cdb_opaque[2] = page_code; 20738 FORMG0COUNT(&cdb, buflen); 20739 20740 ucmd_buf.uscsi_cdb = (char *)&cdb; 20741 ucmd_buf.uscsi_cdblen = CDB_GROUP0; 20742 ucmd_buf.uscsi_bufaddr = (caddr_t)bufaddr; 20743 ucmd_buf.uscsi_buflen = buflen; 20744 ucmd_buf.uscsi_rqbuf = NULL; 20745 ucmd_buf.uscsi_rqlen = 0; 20746 ucmd_buf.uscsi_flags = USCSI_READ | USCSI_SILENT; 20747 ucmd_buf.uscsi_timeout = 200; /* Excessive legacy value */ 20748 20749 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL, 20750 UIO_SYSSPACE, SD_PATH_DIRECT); 20751 20752 /* 20753 * Only handle status == 0, the upper-level caller 20754 * will put different assessment based on the context. 20755 */ 20756 if (status == 0) 20757 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 20758 20759 if ((status == 0) && (residp != NULL)) { 20760 *residp = ucmd_buf.uscsi_resid; 20761 } 20762 20763 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_INQUIRY: exit\n"); 20764 20765 return (status); 20766 } 20767 20768 20769 /* 20770 * Function: sd_send_scsi_TEST_UNIT_READY 20771 * 20772 * Description: Issue the scsi TEST UNIT READY command. 20773 * This routine can be told to set the flag USCSI_DIAGNOSE to 20774 * prevent retrying failed commands. Use this when the intent 20775 * is either to check for device readiness, to clear a Unit 20776 * Attention, or to clear any outstanding sense data. 20777 * However under specific conditions the expected behavior 20778 * is for retries to bring a device ready, so use the flag 20779 * with caution. 20780 * 20781 * Arguments: ssc - ssc contains pointer to driver soft state (unit) 20782 * structure for this target. 20783 * flag: SD_CHECK_FOR_MEDIA: return ENXIO if no media present 20784 * SD_DONT_RETRY_TUR: include uscsi flag USCSI_DIAGNOSE. 20785 * 0: dont check for media present, do retries on cmd. 20786 * 20787 * Return Code: 0 - Success 20788 * EIO - IO error 20789 * EACCES - Reservation conflict detected 20790 * ENXIO - Not Ready, medium not present 20791 * errno return code from sd_ssc_send() 20792 * 20793 * Context: Can sleep. Does not return until command is completed. 20794 */ 20795 20796 static int 20797 sd_send_scsi_TEST_UNIT_READY(sd_ssc_t *ssc, int flag) 20798 { 20799 struct scsi_extended_sense sense_buf; 20800 union scsi_cdb cdb; 20801 struct uscsi_cmd ucmd_buf; 20802 int status; 20803 struct sd_lun *un; 20804 20805 ASSERT(ssc != NULL); 20806 un = ssc->ssc_un; 20807 ASSERT(un != NULL); 20808 ASSERT(!mutex_owned(SD_MUTEX(un))); 20809 20810 SD_TRACE(SD_LOG_IO, un, 20811 "sd_send_scsi_TEST_UNIT_READY: entry: un:0x%p\n", un); 20812 20813 /* 20814 * Some Seagate elite1 TQ devices get hung with disconnect/reconnect 20815 * timeouts when they receive a TUR and the queue is not empty. Check 20816 * the configuration flag set during attach (indicating the drive has 20817 * this firmware bug) and un_ncmds_in_transport before issuing the 20818 * TUR. If there are 20819 * pending commands return success, this is a bit arbitrary but is ok 20820 * for non-removables (i.e. the eliteI disks) and non-clustering 20821 * configurations. 20822 */ 20823 if (un->un_f_cfg_tur_check == TRUE) { 20824 mutex_enter(SD_MUTEX(un)); 20825 if (un->un_ncmds_in_transport != 0) { 20826 mutex_exit(SD_MUTEX(un)); 20827 return (0); 20828 } 20829 mutex_exit(SD_MUTEX(un)); 20830 } 20831 20832 bzero(&cdb, sizeof (cdb)); 20833 bzero(&ucmd_buf, sizeof (ucmd_buf)); 20834 bzero(&sense_buf, sizeof (struct scsi_extended_sense)); 20835 20836 cdb.scc_cmd = SCMD_TEST_UNIT_READY; 20837 20838 ucmd_buf.uscsi_cdb = (char *)&cdb; 20839 ucmd_buf.uscsi_cdblen = CDB_GROUP0; 20840 ucmd_buf.uscsi_bufaddr = NULL; 20841 ucmd_buf.uscsi_buflen = 0; 20842 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf; 20843 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense); 20844 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_SILENT; 20845 20846 /* Use flag USCSI_DIAGNOSE to prevent retries if it fails. */ 20847 if ((flag & SD_DONT_RETRY_TUR) != 0) { 20848 ucmd_buf.uscsi_flags |= USCSI_DIAGNOSE; 20849 } 20850 ucmd_buf.uscsi_timeout = 60; 20851 20852 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL, 20853 UIO_SYSSPACE, ((flag & SD_BYPASS_PM) ? SD_PATH_DIRECT : 20854 SD_PATH_STANDARD)); 20855 20856 switch (status) { 20857 case 0: 20858 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 20859 break; /* Success! */ 20860 case EIO: 20861 switch (ucmd_buf.uscsi_status) { 20862 case STATUS_RESERVATION_CONFLICT: 20863 status = EACCES; 20864 break; 20865 case STATUS_CHECK: 20866 if ((flag & SD_CHECK_FOR_MEDIA) == 0) { 20867 break; 20868 } 20869 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) && 20870 (scsi_sense_key((uint8_t *)&sense_buf) == 20871 KEY_NOT_READY) && 20872 (scsi_sense_asc((uint8_t *)&sense_buf) == 0x3A)) { 20873 status = ENXIO; 20874 } 20875 break; 20876 default: 20877 break; 20878 } 20879 break; 20880 default: 20881 break; 20882 } 20883 20884 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_TEST_UNIT_READY: exit\n"); 20885 20886 return (status); 20887 } 20888 20889 /* 20890 * Function: sd_send_scsi_PERSISTENT_RESERVE_IN 20891 * 20892 * Description: Issue the scsi PERSISTENT RESERVE IN command. 20893 * 20894 * Arguments: ssc - ssc contains pointer to driver soft state (unit) 20895 * structure for this target. 20896 * 20897 * Return Code: 0 - Success 20898 * EACCES 20899 * ENOTSUP 20900 * errno return code from sd_ssc_send() 20901 * 20902 * Context: Can sleep. Does not return until command is completed. 20903 */ 20904 20905 static int 20906 sd_send_scsi_PERSISTENT_RESERVE_IN(sd_ssc_t *ssc, uchar_t usr_cmd, 20907 uint16_t data_len, uchar_t *data_bufp) 20908 { 20909 struct scsi_extended_sense sense_buf; 20910 union scsi_cdb cdb; 20911 struct uscsi_cmd ucmd_buf; 20912 int status; 20913 int no_caller_buf = FALSE; 20914 struct sd_lun *un; 20915 20916 ASSERT(ssc != NULL); 20917 un = ssc->ssc_un; 20918 ASSERT(un != NULL); 20919 ASSERT(!mutex_owned(SD_MUTEX(un))); 20920 ASSERT((usr_cmd == SD_READ_KEYS) || (usr_cmd == SD_READ_RESV)); 20921 20922 SD_TRACE(SD_LOG_IO, un, 20923 "sd_send_scsi_PERSISTENT_RESERVE_IN: entry: un:0x%p\n", un); 20924 20925 bzero(&cdb, sizeof (cdb)); 20926 bzero(&ucmd_buf, sizeof (ucmd_buf)); 20927 bzero(&sense_buf, sizeof (struct scsi_extended_sense)); 20928 if (data_bufp == NULL) { 20929 /* Allocate a default buf if the caller did not give one */ 20930 ASSERT(data_len == 0); 20931 data_len = MHIOC_RESV_KEY_SIZE; 20932 data_bufp = kmem_zalloc(MHIOC_RESV_KEY_SIZE, KM_SLEEP); 20933 no_caller_buf = TRUE; 20934 } 20935 20936 cdb.scc_cmd = SCMD_PERSISTENT_RESERVE_IN; 20937 cdb.cdb_opaque[1] = usr_cmd; 20938 FORMG1COUNT(&cdb, data_len); 20939 20940 ucmd_buf.uscsi_cdb = (char *)&cdb; 20941 ucmd_buf.uscsi_cdblen = CDB_GROUP1; 20942 ucmd_buf.uscsi_bufaddr = (caddr_t)data_bufp; 20943 ucmd_buf.uscsi_buflen = data_len; 20944 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf; 20945 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense); 20946 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT; 20947 ucmd_buf.uscsi_timeout = 60; 20948 20949 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL, 20950 UIO_SYSSPACE, SD_PATH_STANDARD); 20951 20952 switch (status) { 20953 case 0: 20954 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 20955 20956 break; /* Success! */ 20957 case EIO: 20958 switch (ucmd_buf.uscsi_status) { 20959 case STATUS_RESERVATION_CONFLICT: 20960 status = EACCES; 20961 break; 20962 case STATUS_CHECK: 20963 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) && 20964 (scsi_sense_key((uint8_t *)&sense_buf) == 20965 KEY_ILLEGAL_REQUEST)) { 20966 status = ENOTSUP; 20967 } 20968 break; 20969 default: 20970 break; 20971 } 20972 break; 20973 default: 20974 break; 20975 } 20976 20977 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_PERSISTENT_RESERVE_IN: exit\n"); 20978 20979 if (no_caller_buf == TRUE) { 20980 kmem_free(data_bufp, data_len); 20981 } 20982 20983 return (status); 20984 } 20985 20986 20987 /* 20988 * Function: sd_send_scsi_PERSISTENT_RESERVE_OUT 20989 * 20990 * Description: This routine is the driver entry point for handling CD-ROM 20991 * multi-host persistent reservation requests (MHIOCGRP_INKEYS, 20992 * MHIOCGRP_INRESV) by sending the SCSI-3 PROUT commands to the 20993 * device. 20994 * 20995 * Arguments: ssc - ssc contains un - pointer to soft state struct 20996 * for the target. 20997 * usr_cmd SCSI-3 reservation facility command (one of 20998 * SD_SCSI3_REGISTER, SD_SCSI3_RESERVE, SD_SCSI3_RELEASE, 20999 * SD_SCSI3_PREEMPTANDABORT, SD_SCSI3_CLEAR) 21000 * usr_bufp - user provided pointer register, reserve descriptor or 21001 * preempt and abort structure (mhioc_register_t, 21002 * mhioc_resv_desc_t, mhioc_preemptandabort_t) 21003 * 21004 * Return Code: 0 - Success 21005 * EACCES 21006 * ENOTSUP 21007 * errno return code from sd_ssc_send() 21008 * 21009 * Context: Can sleep. Does not return until command is completed. 21010 */ 21011 21012 static int 21013 sd_send_scsi_PERSISTENT_RESERVE_OUT(sd_ssc_t *ssc, uchar_t usr_cmd, 21014 uchar_t *usr_bufp) 21015 { 21016 struct scsi_extended_sense sense_buf; 21017 union scsi_cdb cdb; 21018 struct uscsi_cmd ucmd_buf; 21019 int status; 21020 uchar_t data_len = sizeof (sd_prout_t); 21021 sd_prout_t *prp; 21022 struct sd_lun *un; 21023 21024 ASSERT(ssc != NULL); 21025 un = ssc->ssc_un; 21026 ASSERT(un != NULL); 21027 ASSERT(!mutex_owned(SD_MUTEX(un))); 21028 ASSERT(data_len == 24); /* required by scsi spec */ 21029 21030 SD_TRACE(SD_LOG_IO, un, 21031 "sd_send_scsi_PERSISTENT_RESERVE_OUT: entry: un:0x%p\n", un); 21032 21033 if (usr_bufp == NULL) { 21034 return (EINVAL); 21035 } 21036 21037 bzero(&cdb, sizeof (cdb)); 21038 bzero(&ucmd_buf, sizeof (ucmd_buf)); 21039 bzero(&sense_buf, sizeof (struct scsi_extended_sense)); 21040 prp = kmem_zalloc(data_len, KM_SLEEP); 21041 21042 cdb.scc_cmd = SCMD_PERSISTENT_RESERVE_OUT; 21043 cdb.cdb_opaque[1] = usr_cmd; 21044 FORMG1COUNT(&cdb, data_len); 21045 21046 ucmd_buf.uscsi_cdb = (char *)&cdb; 21047 ucmd_buf.uscsi_cdblen = CDB_GROUP1; 21048 ucmd_buf.uscsi_bufaddr = (caddr_t)prp; 21049 ucmd_buf.uscsi_buflen = data_len; 21050 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf; 21051 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense); 21052 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_WRITE | USCSI_SILENT; 21053 ucmd_buf.uscsi_timeout = 60; 21054 21055 switch (usr_cmd) { 21056 case SD_SCSI3_REGISTER: { 21057 mhioc_register_t *ptr = (mhioc_register_t *)usr_bufp; 21058 21059 bcopy(ptr->oldkey.key, prp->res_key, MHIOC_RESV_KEY_SIZE); 21060 bcopy(ptr->newkey.key, prp->service_key, 21061 MHIOC_RESV_KEY_SIZE); 21062 prp->aptpl = ptr->aptpl; 21063 break; 21064 } 21065 case SD_SCSI3_CLEAR: { 21066 mhioc_resv_desc_t *ptr = (mhioc_resv_desc_t *)usr_bufp; 21067 21068 bcopy(ptr->key.key, prp->res_key, MHIOC_RESV_KEY_SIZE); 21069 break; 21070 } 21071 case SD_SCSI3_RESERVE: 21072 case SD_SCSI3_RELEASE: { 21073 mhioc_resv_desc_t *ptr = (mhioc_resv_desc_t *)usr_bufp; 21074 21075 bcopy(ptr->key.key, prp->res_key, MHIOC_RESV_KEY_SIZE); 21076 prp->scope_address = BE_32(ptr->scope_specific_addr); 21077 cdb.cdb_opaque[2] = ptr->type; 21078 break; 21079 } 21080 case SD_SCSI3_PREEMPTANDABORT: { 21081 mhioc_preemptandabort_t *ptr = 21082 (mhioc_preemptandabort_t *)usr_bufp; 21083 21084 bcopy(ptr->resvdesc.key.key, prp->res_key, MHIOC_RESV_KEY_SIZE); 21085 bcopy(ptr->victim_key.key, prp->service_key, 21086 MHIOC_RESV_KEY_SIZE); 21087 prp->scope_address = BE_32(ptr->resvdesc.scope_specific_addr); 21088 cdb.cdb_opaque[2] = ptr->resvdesc.type; 21089 ucmd_buf.uscsi_flags |= USCSI_HEAD; 21090 break; 21091 } 21092 case SD_SCSI3_REGISTERANDIGNOREKEY: 21093 { 21094 mhioc_registerandignorekey_t *ptr; 21095 ptr = (mhioc_registerandignorekey_t *)usr_bufp; 21096 bcopy(ptr->newkey.key, 21097 prp->service_key, MHIOC_RESV_KEY_SIZE); 21098 prp->aptpl = ptr->aptpl; 21099 break; 21100 } 21101 default: 21102 ASSERT(FALSE); 21103 break; 21104 } 21105 21106 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL, 21107 UIO_SYSSPACE, SD_PATH_STANDARD); 21108 21109 switch (status) { 21110 case 0: 21111 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 21112 break; /* Success! */ 21113 case EIO: 21114 switch (ucmd_buf.uscsi_status) { 21115 case STATUS_RESERVATION_CONFLICT: 21116 status = EACCES; 21117 break; 21118 case STATUS_CHECK: 21119 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) && 21120 (scsi_sense_key((uint8_t *)&sense_buf) == 21121 KEY_ILLEGAL_REQUEST)) { 21122 status = ENOTSUP; 21123 } 21124 break; 21125 default: 21126 break; 21127 } 21128 break; 21129 default: 21130 break; 21131 } 21132 21133 kmem_free(prp, data_len); 21134 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_PERSISTENT_RESERVE_OUT: exit\n"); 21135 return (status); 21136 } 21137 21138 21139 /* 21140 * Function: sd_send_scsi_SYNCHRONIZE_CACHE 21141 * 21142 * Description: Issues a scsi SYNCHRONIZE CACHE command to the target 21143 * 21144 * Arguments: un - pointer to the target's soft state struct 21145 * dkc - pointer to the callback structure 21146 * 21147 * Return Code: 0 - success 21148 * errno-type error code 21149 * 21150 * Context: kernel thread context only. 21151 * 21152 * _______________________________________________________________ 21153 * | dkc_flag & | dkc_callback | DKIOCFLUSHWRITECACHE | 21154 * |FLUSH_VOLATILE| | operation | 21155 * |______________|______________|_________________________________| 21156 * | 0 | NULL | Synchronous flush on both | 21157 * | | | volatile and non-volatile cache | 21158 * |______________|______________|_________________________________| 21159 * | 1 | NULL | Synchronous flush on volatile | 21160 * | | | cache; disk drivers may suppress| 21161 * | | | flush if disk table indicates | 21162 * | | | non-volatile cache | 21163 * |______________|______________|_________________________________| 21164 * | 0 | !NULL | Asynchronous flush on both | 21165 * | | | volatile and non-volatile cache;| 21166 * |______________|______________|_________________________________| 21167 * | 1 | !NULL | Asynchronous flush on volatile | 21168 * | | | cache; disk drivers may suppress| 21169 * | | | flush if disk table indicates | 21170 * | | | non-volatile cache | 21171 * |______________|______________|_________________________________| 21172 * 21173 */ 21174 21175 static int 21176 sd_send_scsi_SYNCHRONIZE_CACHE(struct sd_lun *un, struct dk_callback *dkc) 21177 { 21178 struct sd_uscsi_info *uip; 21179 struct uscsi_cmd *uscmd; 21180 union scsi_cdb *cdb; 21181 struct buf *bp; 21182 int rval = 0; 21183 int is_async; 21184 21185 SD_TRACE(SD_LOG_IO, un, 21186 "sd_send_scsi_SYNCHRONIZE_CACHE: entry: un:0x%p\n", un); 21187 21188 ASSERT(un != NULL); 21189 ASSERT(!mutex_owned(SD_MUTEX(un))); 21190 21191 if (dkc == NULL || dkc->dkc_callback == NULL) { 21192 is_async = FALSE; 21193 } else { 21194 is_async = TRUE; 21195 } 21196 21197 mutex_enter(SD_MUTEX(un)); 21198 /* check whether cache flush should be suppressed */ 21199 if (un->un_f_suppress_cache_flush == TRUE) { 21200 mutex_exit(SD_MUTEX(un)); 21201 /* 21202 * suppress the cache flush if the device is told to do 21203 * so by sd.conf or disk table 21204 */ 21205 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_SYNCHRONIZE_CACHE: \ 21206 skip the cache flush since suppress_cache_flush is %d!\n", 21207 un->un_f_suppress_cache_flush); 21208 21209 if (is_async == TRUE) { 21210 /* invoke callback for asynchronous flush */ 21211 (*dkc->dkc_callback)(dkc->dkc_cookie, 0); 21212 } 21213 return (rval); 21214 } 21215 mutex_exit(SD_MUTEX(un)); 21216 21217 /* 21218 * check dkc_flag & FLUSH_VOLATILE so SYNC_NV bit can be 21219 * set properly 21220 */ 21221 cdb = kmem_zalloc(CDB_GROUP1, KM_SLEEP); 21222 cdb->scc_cmd = SCMD_SYNCHRONIZE_CACHE; 21223 21224 mutex_enter(SD_MUTEX(un)); 21225 if (dkc != NULL && un->un_f_sync_nv_supported && 21226 (dkc->dkc_flag & FLUSH_VOLATILE)) { 21227 /* 21228 * if the device supports SYNC_NV bit, turn on 21229 * the SYNC_NV bit to only flush volatile cache 21230 */ 21231 cdb->cdb_un.tag |= SD_SYNC_NV_BIT; 21232 } 21233 mutex_exit(SD_MUTEX(un)); 21234 21235 /* 21236 * First get some memory for the uscsi_cmd struct and cdb 21237 * and initialize for SYNCHRONIZE_CACHE cmd. 21238 */ 21239 uscmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 21240 uscmd->uscsi_cdblen = CDB_GROUP1; 21241 uscmd->uscsi_cdb = (caddr_t)cdb; 21242 uscmd->uscsi_bufaddr = NULL; 21243 uscmd->uscsi_buflen = 0; 21244 uscmd->uscsi_rqbuf = kmem_zalloc(SENSE_LENGTH, KM_SLEEP); 21245 uscmd->uscsi_rqlen = SENSE_LENGTH; 21246 uscmd->uscsi_rqresid = SENSE_LENGTH; 21247 uscmd->uscsi_flags = USCSI_RQENABLE | USCSI_SILENT; 21248 uscmd->uscsi_timeout = sd_io_time; 21249 21250 /* 21251 * Allocate an sd_uscsi_info struct and fill it with the info 21252 * needed by sd_initpkt_for_uscsi(). Then put the pointer into 21253 * b_private in the buf for sd_initpkt_for_uscsi(). Note that 21254 * since we allocate the buf here in this function, we do not 21255 * need to preserve the prior contents of b_private. 21256 * The sd_uscsi_info struct is also used by sd_uscsi_strategy() 21257 */ 21258 uip = kmem_zalloc(sizeof (struct sd_uscsi_info), KM_SLEEP); 21259 uip->ui_flags = SD_PATH_DIRECT; 21260 uip->ui_cmdp = uscmd; 21261 21262 bp = getrbuf(KM_SLEEP); 21263 bp->b_private = uip; 21264 21265 /* 21266 * Setup buffer to carry uscsi request. 21267 */ 21268 bp->b_flags = B_BUSY; 21269 bp->b_bcount = 0; 21270 bp->b_blkno = 0; 21271 21272 if (is_async == TRUE) { 21273 bp->b_iodone = sd_send_scsi_SYNCHRONIZE_CACHE_biodone; 21274 uip->ui_dkc = *dkc; 21275 } 21276 21277 bp->b_edev = SD_GET_DEV(un); 21278 bp->b_dev = cmpdev(bp->b_edev); /* maybe unnecessary? */ 21279 21280 /* 21281 * Unset un_f_sync_cache_required flag 21282 */ 21283 mutex_enter(SD_MUTEX(un)); 21284 un->un_f_sync_cache_required = FALSE; 21285 mutex_exit(SD_MUTEX(un)); 21286 21287 (void) sd_uscsi_strategy(bp); 21288 21289 /* 21290 * If synchronous request, wait for completion 21291 * If async just return and let b_iodone callback 21292 * cleanup. 21293 * NOTE: On return, u_ncmds_in_driver will be decremented, 21294 * but it was also incremented in sd_uscsi_strategy(), so 21295 * we should be ok. 21296 */ 21297 if (is_async == FALSE) { 21298 (void) biowait(bp); 21299 rval = sd_send_scsi_SYNCHRONIZE_CACHE_biodone(bp); 21300 } 21301 21302 return (rval); 21303 } 21304 21305 21306 static int 21307 sd_send_scsi_SYNCHRONIZE_CACHE_biodone(struct buf *bp) 21308 { 21309 struct sd_uscsi_info *uip; 21310 struct uscsi_cmd *uscmd; 21311 uint8_t *sense_buf; 21312 struct sd_lun *un; 21313 int status; 21314 union scsi_cdb *cdb; 21315 21316 uip = (struct sd_uscsi_info *)(bp->b_private); 21317 ASSERT(uip != NULL); 21318 21319 uscmd = uip->ui_cmdp; 21320 ASSERT(uscmd != NULL); 21321 21322 sense_buf = (uint8_t *)uscmd->uscsi_rqbuf; 21323 ASSERT(sense_buf != NULL); 21324 21325 un = ddi_get_soft_state(sd_state, SD_GET_INSTANCE_FROM_BUF(bp)); 21326 ASSERT(un != NULL); 21327 21328 cdb = (union scsi_cdb *)uscmd->uscsi_cdb; 21329 21330 status = geterror(bp); 21331 switch (status) { 21332 case 0: 21333 break; /* Success! */ 21334 case EIO: 21335 switch (uscmd->uscsi_status) { 21336 case STATUS_RESERVATION_CONFLICT: 21337 /* Ignore reservation conflict */ 21338 status = 0; 21339 goto done; 21340 21341 case STATUS_CHECK: 21342 if ((uscmd->uscsi_rqstatus == STATUS_GOOD) && 21343 (scsi_sense_key(sense_buf) == 21344 KEY_ILLEGAL_REQUEST)) { 21345 /* Ignore Illegal Request error */ 21346 if (cdb->cdb_un.tag&SD_SYNC_NV_BIT) { 21347 mutex_enter(SD_MUTEX(un)); 21348 un->un_f_sync_nv_supported = FALSE; 21349 mutex_exit(SD_MUTEX(un)); 21350 status = 0; 21351 SD_TRACE(SD_LOG_IO, un, 21352 "un_f_sync_nv_supported \ 21353 is set to false.\n"); 21354 goto done; 21355 } 21356 21357 mutex_enter(SD_MUTEX(un)); 21358 un->un_f_sync_cache_supported = FALSE; 21359 mutex_exit(SD_MUTEX(un)); 21360 SD_TRACE(SD_LOG_IO, un, 21361 "sd_send_scsi_SYNCHRONIZE_CACHE_biodone: \ 21362 un_f_sync_cache_supported set to false \ 21363 with asc = %x, ascq = %x\n", 21364 scsi_sense_asc(sense_buf), 21365 scsi_sense_ascq(sense_buf)); 21366 status = ENOTSUP; 21367 goto done; 21368 } 21369 break; 21370 default: 21371 break; 21372 } 21373 /* FALLTHRU */ 21374 default: 21375 /* 21376 * Turn on the un_f_sync_cache_required flag 21377 * since the SYNC CACHE command failed 21378 */ 21379 mutex_enter(SD_MUTEX(un)); 21380 un->un_f_sync_cache_required = TRUE; 21381 mutex_exit(SD_MUTEX(un)); 21382 21383 /* 21384 * Don't log an error message if this device 21385 * has removable media. 21386 */ 21387 if (!un->un_f_has_removable_media) { 21388 scsi_log(SD_DEVINFO(un), sd_label, CE_WARN, 21389 "SYNCHRONIZE CACHE command failed (%d)\n", status); 21390 } 21391 break; 21392 } 21393 21394 done: 21395 if (uip->ui_dkc.dkc_callback != NULL) { 21396 (*uip->ui_dkc.dkc_callback)(uip->ui_dkc.dkc_cookie, status); 21397 } 21398 21399 ASSERT((bp->b_flags & B_REMAPPED) == 0); 21400 freerbuf(bp); 21401 kmem_free(uip, sizeof (struct sd_uscsi_info)); 21402 kmem_free(uscmd->uscsi_rqbuf, SENSE_LENGTH); 21403 kmem_free(uscmd->uscsi_cdb, (size_t)uscmd->uscsi_cdblen); 21404 kmem_free(uscmd, sizeof (struct uscsi_cmd)); 21405 21406 return (status); 21407 } 21408 21409 21410 /* 21411 * Function: sd_send_scsi_GET_CONFIGURATION 21412 * 21413 * Description: Issues the get configuration command to the device. 21414 * Called from sd_check_for_writable_cd & sd_get_media_info 21415 * caller needs to ensure that buflen = SD_PROFILE_HEADER_LEN 21416 * Arguments: ssc 21417 * ucmdbuf 21418 * rqbuf 21419 * rqbuflen 21420 * bufaddr 21421 * buflen 21422 * path_flag 21423 * 21424 * Return Code: 0 - Success 21425 * errno return code from sd_ssc_send() 21426 * 21427 * Context: Can sleep. Does not return until command is completed. 21428 * 21429 */ 21430 21431 static int 21432 sd_send_scsi_GET_CONFIGURATION(sd_ssc_t *ssc, struct uscsi_cmd *ucmdbuf, 21433 uchar_t *rqbuf, uint_t rqbuflen, uchar_t *bufaddr, uint_t buflen, 21434 int path_flag) 21435 { 21436 char cdb[CDB_GROUP1]; 21437 int status; 21438 struct sd_lun *un; 21439 21440 ASSERT(ssc != NULL); 21441 un = ssc->ssc_un; 21442 ASSERT(un != NULL); 21443 ASSERT(!mutex_owned(SD_MUTEX(un))); 21444 ASSERT(bufaddr != NULL); 21445 ASSERT(ucmdbuf != NULL); 21446 ASSERT(rqbuf != NULL); 21447 21448 SD_TRACE(SD_LOG_IO, un, 21449 "sd_send_scsi_GET_CONFIGURATION: entry: un:0x%p\n", un); 21450 21451 bzero(cdb, sizeof (cdb)); 21452 bzero(ucmdbuf, sizeof (struct uscsi_cmd)); 21453 bzero(rqbuf, rqbuflen); 21454 bzero(bufaddr, buflen); 21455 21456 /* 21457 * Set up cdb field for the get configuration command. 21458 */ 21459 cdb[0] = SCMD_GET_CONFIGURATION; 21460 cdb[1] = 0x02; /* Requested Type */ 21461 cdb[8] = SD_PROFILE_HEADER_LEN; 21462 ucmdbuf->uscsi_cdb = cdb; 21463 ucmdbuf->uscsi_cdblen = CDB_GROUP1; 21464 ucmdbuf->uscsi_bufaddr = (caddr_t)bufaddr; 21465 ucmdbuf->uscsi_buflen = buflen; 21466 ucmdbuf->uscsi_timeout = sd_io_time; 21467 ucmdbuf->uscsi_rqbuf = (caddr_t)rqbuf; 21468 ucmdbuf->uscsi_rqlen = rqbuflen; 21469 ucmdbuf->uscsi_flags = USCSI_RQENABLE|USCSI_SILENT|USCSI_READ; 21470 21471 status = sd_ssc_send(ssc, ucmdbuf, FKIOCTL, 21472 UIO_SYSSPACE, path_flag); 21473 21474 switch (status) { 21475 case 0: 21476 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 21477 break; /* Success! */ 21478 case EIO: 21479 switch (ucmdbuf->uscsi_status) { 21480 case STATUS_RESERVATION_CONFLICT: 21481 status = EACCES; 21482 break; 21483 default: 21484 break; 21485 } 21486 break; 21487 default: 21488 break; 21489 } 21490 21491 if (status == 0) { 21492 SD_DUMP_MEMORY(un, SD_LOG_IO, 21493 "sd_send_scsi_GET_CONFIGURATION: data", 21494 (uchar_t *)bufaddr, SD_PROFILE_HEADER_LEN, SD_LOG_HEX); 21495 } 21496 21497 SD_TRACE(SD_LOG_IO, un, 21498 "sd_send_scsi_GET_CONFIGURATION: exit\n"); 21499 21500 return (status); 21501 } 21502 21503 /* 21504 * Function: sd_send_scsi_feature_GET_CONFIGURATION 21505 * 21506 * Description: Issues the get configuration command to the device to 21507 * retrieve a specific feature. Called from 21508 * sd_check_for_writable_cd & sd_set_mmc_caps. 21509 * Arguments: ssc 21510 * ucmdbuf 21511 * rqbuf 21512 * rqbuflen 21513 * bufaddr 21514 * buflen 21515 * feature 21516 * 21517 * Return Code: 0 - Success 21518 * errno return code from sd_ssc_send() 21519 * 21520 * Context: Can sleep. Does not return until command is completed. 21521 * 21522 */ 21523 static int 21524 sd_send_scsi_feature_GET_CONFIGURATION(sd_ssc_t *ssc, 21525 struct uscsi_cmd *ucmdbuf, uchar_t *rqbuf, uint_t rqbuflen, 21526 uchar_t *bufaddr, uint_t buflen, char feature, int path_flag) 21527 { 21528 char cdb[CDB_GROUP1]; 21529 int status; 21530 struct sd_lun *un; 21531 21532 ASSERT(ssc != NULL); 21533 un = ssc->ssc_un; 21534 ASSERT(un != NULL); 21535 ASSERT(!mutex_owned(SD_MUTEX(un))); 21536 ASSERT(bufaddr != NULL); 21537 ASSERT(ucmdbuf != NULL); 21538 ASSERT(rqbuf != NULL); 21539 21540 SD_TRACE(SD_LOG_IO, un, 21541 "sd_send_scsi_feature_GET_CONFIGURATION: entry: un:0x%p\n", un); 21542 21543 bzero(cdb, sizeof (cdb)); 21544 bzero(ucmdbuf, sizeof (struct uscsi_cmd)); 21545 bzero(rqbuf, rqbuflen); 21546 bzero(bufaddr, buflen); 21547 21548 /* 21549 * Set up cdb field for the get configuration command. 21550 */ 21551 cdb[0] = SCMD_GET_CONFIGURATION; 21552 cdb[1] = 0x02; /* Requested Type */ 21553 cdb[3] = feature; 21554 cdb[8] = buflen; 21555 ucmdbuf->uscsi_cdb = cdb; 21556 ucmdbuf->uscsi_cdblen = CDB_GROUP1; 21557 ucmdbuf->uscsi_bufaddr = (caddr_t)bufaddr; 21558 ucmdbuf->uscsi_buflen = buflen; 21559 ucmdbuf->uscsi_timeout = sd_io_time; 21560 ucmdbuf->uscsi_rqbuf = (caddr_t)rqbuf; 21561 ucmdbuf->uscsi_rqlen = rqbuflen; 21562 ucmdbuf->uscsi_flags = USCSI_RQENABLE|USCSI_SILENT|USCSI_READ; 21563 21564 status = sd_ssc_send(ssc, ucmdbuf, FKIOCTL, 21565 UIO_SYSSPACE, path_flag); 21566 21567 switch (status) { 21568 case 0: 21569 21570 break; /* Success! */ 21571 case EIO: 21572 switch (ucmdbuf->uscsi_status) { 21573 case STATUS_RESERVATION_CONFLICT: 21574 status = EACCES; 21575 break; 21576 default: 21577 break; 21578 } 21579 break; 21580 default: 21581 break; 21582 } 21583 21584 if (status == 0) { 21585 SD_DUMP_MEMORY(un, SD_LOG_IO, 21586 "sd_send_scsi_feature_GET_CONFIGURATION: data", 21587 (uchar_t *)bufaddr, SD_PROFILE_HEADER_LEN, SD_LOG_HEX); 21588 } 21589 21590 SD_TRACE(SD_LOG_IO, un, 21591 "sd_send_scsi_feature_GET_CONFIGURATION: exit\n"); 21592 21593 return (status); 21594 } 21595 21596 21597 /* 21598 * Function: sd_send_scsi_MODE_SENSE 21599 * 21600 * Description: Utility function for issuing a scsi MODE SENSE command. 21601 * Note: This routine uses a consistent implementation for Group0, 21602 * Group1, and Group2 commands across all platforms. ATAPI devices 21603 * use Group 1 Read/Write commands and Group 2 Mode Sense/Select 21604 * 21605 * Arguments: ssc - ssc contains pointer to driver soft state (unit) 21606 * structure for this target. 21607 * cdbsize - size CDB to be used (CDB_GROUP0 (6 byte), or 21608 * CDB_GROUP[1|2] (10 byte). 21609 * bufaddr - buffer for page data retrieved from the target. 21610 * buflen - size of page to be retrieved. 21611 * page_code - page code of data to be retrieved from the target. 21612 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and 21613 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY 21614 * to use the USCSI "direct" chain and bypass the normal 21615 * command waitq. 21616 * 21617 * Return Code: 0 - Success 21618 * errno return code from sd_ssc_send() 21619 * 21620 * Context: Can sleep. Does not return until command is completed. 21621 */ 21622 21623 static int 21624 sd_send_scsi_MODE_SENSE(sd_ssc_t *ssc, int cdbsize, uchar_t *bufaddr, 21625 size_t buflen, uchar_t page_code, int path_flag) 21626 { 21627 struct scsi_extended_sense sense_buf; 21628 union scsi_cdb cdb; 21629 struct uscsi_cmd ucmd_buf; 21630 int status; 21631 int headlen; 21632 struct sd_lun *un; 21633 21634 ASSERT(ssc != NULL); 21635 un = ssc->ssc_un; 21636 ASSERT(un != NULL); 21637 ASSERT(!mutex_owned(SD_MUTEX(un))); 21638 ASSERT(bufaddr != NULL); 21639 ASSERT((cdbsize == CDB_GROUP0) || (cdbsize == CDB_GROUP1) || 21640 (cdbsize == CDB_GROUP2)); 21641 21642 SD_TRACE(SD_LOG_IO, un, 21643 "sd_send_scsi_MODE_SENSE: entry: un:0x%p\n", un); 21644 21645 bzero(&cdb, sizeof (cdb)); 21646 bzero(&ucmd_buf, sizeof (ucmd_buf)); 21647 bzero(&sense_buf, sizeof (struct scsi_extended_sense)); 21648 bzero(bufaddr, buflen); 21649 21650 if (cdbsize == CDB_GROUP0) { 21651 cdb.scc_cmd = SCMD_MODE_SENSE; 21652 cdb.cdb_opaque[2] = page_code; 21653 FORMG0COUNT(&cdb, buflen); 21654 headlen = MODE_HEADER_LENGTH; 21655 } else { 21656 cdb.scc_cmd = SCMD_MODE_SENSE_G1; 21657 cdb.cdb_opaque[2] = page_code; 21658 FORMG1COUNT(&cdb, buflen); 21659 headlen = MODE_HEADER_LENGTH_GRP2; 21660 } 21661 21662 ASSERT(headlen <= buflen); 21663 SD_FILL_SCSI1_LUN_CDB(un, &cdb); 21664 21665 ucmd_buf.uscsi_cdb = (char *)&cdb; 21666 ucmd_buf.uscsi_cdblen = (uchar_t)cdbsize; 21667 ucmd_buf.uscsi_bufaddr = (caddr_t)bufaddr; 21668 ucmd_buf.uscsi_buflen = buflen; 21669 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf; 21670 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense); 21671 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT; 21672 ucmd_buf.uscsi_timeout = 60; 21673 21674 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL, 21675 UIO_SYSSPACE, path_flag); 21676 21677 switch (status) { 21678 case 0: 21679 /* 21680 * sr_check_wp() uses 0x3f page code and check the header of 21681 * mode page to determine if target device is write-protected. 21682 * But some USB devices return 0 bytes for 0x3f page code. For 21683 * this case, make sure that mode page header is returned at 21684 * least. 21685 */ 21686 if (buflen - ucmd_buf.uscsi_resid < headlen) { 21687 status = EIO; 21688 sd_ssc_set_info(ssc, SSC_FLAGS_INVALID_DATA, -1, 21689 "mode page header is not returned"); 21690 } 21691 break; /* Success! */ 21692 case EIO: 21693 switch (ucmd_buf.uscsi_status) { 21694 case STATUS_RESERVATION_CONFLICT: 21695 status = EACCES; 21696 break; 21697 default: 21698 break; 21699 } 21700 break; 21701 default: 21702 break; 21703 } 21704 21705 if (status == 0) { 21706 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_MODE_SENSE: data", 21707 (uchar_t *)bufaddr, buflen, SD_LOG_HEX); 21708 } 21709 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_MODE_SENSE: exit\n"); 21710 21711 return (status); 21712 } 21713 21714 21715 /* 21716 * Function: sd_send_scsi_MODE_SELECT 21717 * 21718 * Description: Utility function for issuing a scsi MODE SELECT command. 21719 * Note: This routine uses a consistent implementation for Group0, 21720 * Group1, and Group2 commands across all platforms. ATAPI devices 21721 * use Group 1 Read/Write commands and Group 2 Mode Sense/Select 21722 * 21723 * Arguments: ssc - ssc contains pointer to driver soft state (unit) 21724 * structure for this target. 21725 * cdbsize - size CDB to be used (CDB_GROUP0 (6 byte), or 21726 * CDB_GROUP[1|2] (10 byte). 21727 * bufaddr - buffer for page data retrieved from the target. 21728 * buflen - size of page to be retrieved. 21729 * save_page - boolean to determin if SP bit should be set. 21730 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and 21731 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY 21732 * to use the USCSI "direct" chain and bypass the normal 21733 * command waitq. 21734 * 21735 * Return Code: 0 - Success 21736 * errno return code from sd_ssc_send() 21737 * 21738 * Context: Can sleep. Does not return until command is completed. 21739 */ 21740 21741 static int 21742 sd_send_scsi_MODE_SELECT(sd_ssc_t *ssc, int cdbsize, uchar_t *bufaddr, 21743 size_t buflen, uchar_t save_page, int path_flag) 21744 { 21745 struct scsi_extended_sense sense_buf; 21746 union scsi_cdb cdb; 21747 struct uscsi_cmd ucmd_buf; 21748 int status; 21749 struct sd_lun *un; 21750 21751 ASSERT(ssc != NULL); 21752 un = ssc->ssc_un; 21753 ASSERT(un != NULL); 21754 ASSERT(!mutex_owned(SD_MUTEX(un))); 21755 ASSERT(bufaddr != NULL); 21756 ASSERT((cdbsize == CDB_GROUP0) || (cdbsize == CDB_GROUP1) || 21757 (cdbsize == CDB_GROUP2)); 21758 21759 SD_TRACE(SD_LOG_IO, un, 21760 "sd_send_scsi_MODE_SELECT: entry: un:0x%p\n", un); 21761 21762 bzero(&cdb, sizeof (cdb)); 21763 bzero(&ucmd_buf, sizeof (ucmd_buf)); 21764 bzero(&sense_buf, sizeof (struct scsi_extended_sense)); 21765 21766 /* Set the PF bit for many third party drives */ 21767 cdb.cdb_opaque[1] = 0x10; 21768 21769 /* Set the savepage(SP) bit if given */ 21770 if (save_page == SD_SAVE_PAGE) { 21771 cdb.cdb_opaque[1] |= 0x01; 21772 } 21773 21774 if (cdbsize == CDB_GROUP0) { 21775 cdb.scc_cmd = SCMD_MODE_SELECT; 21776 FORMG0COUNT(&cdb, buflen); 21777 } else { 21778 cdb.scc_cmd = SCMD_MODE_SELECT_G1; 21779 FORMG1COUNT(&cdb, buflen); 21780 } 21781 21782 SD_FILL_SCSI1_LUN_CDB(un, &cdb); 21783 21784 ucmd_buf.uscsi_cdb = (char *)&cdb; 21785 ucmd_buf.uscsi_cdblen = (uchar_t)cdbsize; 21786 ucmd_buf.uscsi_bufaddr = (caddr_t)bufaddr; 21787 ucmd_buf.uscsi_buflen = buflen; 21788 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf; 21789 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense); 21790 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_WRITE | USCSI_SILENT; 21791 ucmd_buf.uscsi_timeout = 60; 21792 21793 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL, 21794 UIO_SYSSPACE, path_flag); 21795 21796 switch (status) { 21797 case 0: 21798 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 21799 break; /* Success! */ 21800 case EIO: 21801 switch (ucmd_buf.uscsi_status) { 21802 case STATUS_RESERVATION_CONFLICT: 21803 status = EACCES; 21804 break; 21805 default: 21806 break; 21807 } 21808 break; 21809 default: 21810 break; 21811 } 21812 21813 if (status == 0) { 21814 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_MODE_SELECT: data", 21815 (uchar_t *)bufaddr, buflen, SD_LOG_HEX); 21816 } 21817 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_MODE_SELECT: exit\n"); 21818 21819 return (status); 21820 } 21821 21822 21823 /* 21824 * Function: sd_send_scsi_RDWR 21825 * 21826 * Description: Issue a scsi READ or WRITE command with the given parameters. 21827 * 21828 * Arguments: ssc - ssc contains pointer to driver soft state (unit) 21829 * structure for this target. 21830 * cmd: SCMD_READ or SCMD_WRITE 21831 * bufaddr: Address of caller's buffer to receive the RDWR data 21832 * buflen: Length of caller's buffer receive the RDWR data. 21833 * start_block: Block number for the start of the RDWR operation. 21834 * (Assumes target-native block size.) 21835 * residp: Pointer to variable to receive the redisual of the 21836 * RDWR operation (may be NULL of no residual requested). 21837 * path_flag - SD_PATH_DIRECT to use the USCSI "direct" chain and 21838 * the normal command waitq, or SD_PATH_DIRECT_PRIORITY 21839 * to use the USCSI "direct" chain and bypass the normal 21840 * command waitq. 21841 * 21842 * Return Code: 0 - Success 21843 * errno return code from sd_ssc_send() 21844 * 21845 * Context: Can sleep. Does not return until command is completed. 21846 */ 21847 21848 static int 21849 sd_send_scsi_RDWR(sd_ssc_t *ssc, uchar_t cmd, void *bufaddr, 21850 size_t buflen, daddr_t start_block, int path_flag) 21851 { 21852 struct scsi_extended_sense sense_buf; 21853 union scsi_cdb cdb; 21854 struct uscsi_cmd ucmd_buf; 21855 uint32_t block_count; 21856 int status; 21857 int cdbsize; 21858 uchar_t flag; 21859 struct sd_lun *un; 21860 21861 ASSERT(ssc != NULL); 21862 un = ssc->ssc_un; 21863 ASSERT(un != NULL); 21864 ASSERT(!mutex_owned(SD_MUTEX(un))); 21865 ASSERT(bufaddr != NULL); 21866 ASSERT((cmd == SCMD_READ) || (cmd == SCMD_WRITE)); 21867 21868 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_RDWR: entry: un:0x%p\n", un); 21869 21870 if (un->un_f_tgt_blocksize_is_valid != TRUE) { 21871 return (EINVAL); 21872 } 21873 21874 mutex_enter(SD_MUTEX(un)); 21875 block_count = SD_BYTES2TGTBLOCKS(un, buflen); 21876 mutex_exit(SD_MUTEX(un)); 21877 21878 flag = (cmd == SCMD_READ) ? USCSI_READ : USCSI_WRITE; 21879 21880 SD_INFO(SD_LOG_IO, un, "sd_send_scsi_RDWR: " 21881 "bufaddr:0x%p buflen:0x%x start_block:0x%p block_count:0x%x\n", 21882 bufaddr, buflen, start_block, block_count); 21883 21884 bzero(&cdb, sizeof (cdb)); 21885 bzero(&ucmd_buf, sizeof (ucmd_buf)); 21886 bzero(&sense_buf, sizeof (struct scsi_extended_sense)); 21887 21888 /* Compute CDB size to use */ 21889 if (start_block > 0xffffffff) 21890 cdbsize = CDB_GROUP4; 21891 else if ((start_block & 0xFFE00000) || 21892 (un->un_f_cfg_is_atapi == TRUE)) 21893 cdbsize = CDB_GROUP1; 21894 else 21895 cdbsize = CDB_GROUP0; 21896 21897 switch (cdbsize) { 21898 case CDB_GROUP0: /* 6-byte CDBs */ 21899 cdb.scc_cmd = cmd; 21900 FORMG0ADDR(&cdb, start_block); 21901 FORMG0COUNT(&cdb, block_count); 21902 break; 21903 case CDB_GROUP1: /* 10-byte CDBs */ 21904 cdb.scc_cmd = cmd | SCMD_GROUP1; 21905 FORMG1ADDR(&cdb, start_block); 21906 FORMG1COUNT(&cdb, block_count); 21907 break; 21908 case CDB_GROUP4: /* 16-byte CDBs */ 21909 cdb.scc_cmd = cmd | SCMD_GROUP4; 21910 FORMG4LONGADDR(&cdb, (uint64_t)start_block); 21911 FORMG4COUNT(&cdb, block_count); 21912 break; 21913 case CDB_GROUP5: /* 12-byte CDBs (currently unsupported) */ 21914 default: 21915 /* All others reserved */ 21916 return (EINVAL); 21917 } 21918 21919 /* Set LUN bit(s) in CDB if this is a SCSI-1 device */ 21920 SD_FILL_SCSI1_LUN_CDB(un, &cdb); 21921 21922 ucmd_buf.uscsi_cdb = (char *)&cdb; 21923 ucmd_buf.uscsi_cdblen = (uchar_t)cdbsize; 21924 ucmd_buf.uscsi_bufaddr = bufaddr; 21925 ucmd_buf.uscsi_buflen = buflen; 21926 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf; 21927 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense); 21928 ucmd_buf.uscsi_flags = flag | USCSI_RQENABLE | USCSI_SILENT; 21929 ucmd_buf.uscsi_timeout = 60; 21930 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL, 21931 UIO_SYSSPACE, path_flag); 21932 21933 switch (status) { 21934 case 0: 21935 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 21936 break; /* Success! */ 21937 case EIO: 21938 switch (ucmd_buf.uscsi_status) { 21939 case STATUS_RESERVATION_CONFLICT: 21940 status = EACCES; 21941 break; 21942 default: 21943 break; 21944 } 21945 break; 21946 default: 21947 break; 21948 } 21949 21950 if (status == 0) { 21951 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_RDWR: data", 21952 (uchar_t *)bufaddr, buflen, SD_LOG_HEX); 21953 } 21954 21955 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_RDWR: exit\n"); 21956 21957 return (status); 21958 } 21959 21960 21961 /* 21962 * Function: sd_send_scsi_LOG_SENSE 21963 * 21964 * Description: Issue a scsi LOG_SENSE command with the given parameters. 21965 * 21966 * Arguments: ssc - ssc contains pointer to driver soft state (unit) 21967 * structure for this target. 21968 * 21969 * Return Code: 0 - Success 21970 * errno return code from sd_ssc_send() 21971 * 21972 * Context: Can sleep. Does not return until command is completed. 21973 */ 21974 21975 static int 21976 sd_send_scsi_LOG_SENSE(sd_ssc_t *ssc, uchar_t *bufaddr, uint16_t buflen, 21977 uchar_t page_code, uchar_t page_control, uint16_t param_ptr, 21978 int path_flag) 21979 21980 { 21981 struct scsi_extended_sense sense_buf; 21982 union scsi_cdb cdb; 21983 struct uscsi_cmd ucmd_buf; 21984 int status; 21985 struct sd_lun *un; 21986 21987 ASSERT(ssc != NULL); 21988 un = ssc->ssc_un; 21989 ASSERT(un != NULL); 21990 ASSERT(!mutex_owned(SD_MUTEX(un))); 21991 21992 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_LOG_SENSE: entry: un:0x%p\n", un); 21993 21994 bzero(&cdb, sizeof (cdb)); 21995 bzero(&ucmd_buf, sizeof (ucmd_buf)); 21996 bzero(&sense_buf, sizeof (struct scsi_extended_sense)); 21997 21998 cdb.scc_cmd = SCMD_LOG_SENSE_G1; 21999 cdb.cdb_opaque[2] = (page_control << 6) | page_code; 22000 cdb.cdb_opaque[5] = (uchar_t)((param_ptr & 0xFF00) >> 8); 22001 cdb.cdb_opaque[6] = (uchar_t)(param_ptr & 0x00FF); 22002 FORMG1COUNT(&cdb, buflen); 22003 22004 ucmd_buf.uscsi_cdb = (char *)&cdb; 22005 ucmd_buf.uscsi_cdblen = CDB_GROUP1; 22006 ucmd_buf.uscsi_bufaddr = (caddr_t)bufaddr; 22007 ucmd_buf.uscsi_buflen = buflen; 22008 ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf; 22009 ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense); 22010 ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT; 22011 ucmd_buf.uscsi_timeout = 60; 22012 22013 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL, 22014 UIO_SYSSPACE, path_flag); 22015 22016 switch (status) { 22017 case 0: 22018 break; 22019 case EIO: 22020 switch (ucmd_buf.uscsi_status) { 22021 case STATUS_RESERVATION_CONFLICT: 22022 status = EACCES; 22023 break; 22024 case STATUS_CHECK: 22025 if ((ucmd_buf.uscsi_rqstatus == STATUS_GOOD) && 22026 (scsi_sense_key((uint8_t *)&sense_buf) == 22027 KEY_ILLEGAL_REQUEST) && 22028 (scsi_sense_asc((uint8_t *)&sense_buf) == 0x24)) { 22029 /* 22030 * ASC 0x24: INVALID FIELD IN CDB 22031 */ 22032 switch (page_code) { 22033 case START_STOP_CYCLE_PAGE: 22034 /* 22035 * The start stop cycle counter is 22036 * implemented as page 0x31 in earlier 22037 * generation disks. In new generation 22038 * disks the start stop cycle counter is 22039 * implemented as page 0xE. To properly 22040 * handle this case if an attempt for 22041 * log page 0xE is made and fails we 22042 * will try again using page 0x31. 22043 * 22044 * Network storage BU committed to 22045 * maintain the page 0x31 for this 22046 * purpose and will not have any other 22047 * page implemented with page code 0x31 22048 * until all disks transition to the 22049 * standard page. 22050 */ 22051 mutex_enter(SD_MUTEX(un)); 22052 un->un_start_stop_cycle_page = 22053 START_STOP_CYCLE_VU_PAGE; 22054 cdb.cdb_opaque[2] = 22055 (char)(page_control << 6) | 22056 un->un_start_stop_cycle_page; 22057 mutex_exit(SD_MUTEX(un)); 22058 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 22059 status = sd_ssc_send( 22060 ssc, &ucmd_buf, FKIOCTL, 22061 UIO_SYSSPACE, path_flag); 22062 22063 break; 22064 case TEMPERATURE_PAGE: 22065 status = ENOTTY; 22066 break; 22067 default: 22068 break; 22069 } 22070 } 22071 break; 22072 default: 22073 break; 22074 } 22075 break; 22076 default: 22077 break; 22078 } 22079 22080 if (status == 0) { 22081 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 22082 SD_DUMP_MEMORY(un, SD_LOG_IO, "sd_send_scsi_LOG_SENSE: data", 22083 (uchar_t *)bufaddr, buflen, SD_LOG_HEX); 22084 } 22085 22086 SD_TRACE(SD_LOG_IO, un, "sd_send_scsi_LOG_SENSE: exit\n"); 22087 22088 return (status); 22089 } 22090 22091 22092 /* 22093 * Function: sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION 22094 * 22095 * Description: Issue the scsi GET EVENT STATUS NOTIFICATION command. 22096 * 22097 * Arguments: ssc - ssc contains pointer to driver soft state (unit) 22098 * structure for this target. 22099 * bufaddr 22100 * buflen 22101 * class_req 22102 * 22103 * Return Code: 0 - Success 22104 * errno return code from sd_ssc_send() 22105 * 22106 * Context: Can sleep. Does not return until command is completed. 22107 */ 22108 22109 static int 22110 sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION(sd_ssc_t *ssc, uchar_t *bufaddr, 22111 size_t buflen, uchar_t class_req) 22112 { 22113 union scsi_cdb cdb; 22114 struct uscsi_cmd ucmd_buf; 22115 int status; 22116 struct sd_lun *un; 22117 22118 ASSERT(ssc != NULL); 22119 un = ssc->ssc_un; 22120 ASSERT(un != NULL); 22121 ASSERT(!mutex_owned(SD_MUTEX(un))); 22122 ASSERT(bufaddr != NULL); 22123 22124 SD_TRACE(SD_LOG_IO, un, 22125 "sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION: entry: un:0x%p\n", un); 22126 22127 bzero(&cdb, sizeof (cdb)); 22128 bzero(&ucmd_buf, sizeof (ucmd_buf)); 22129 bzero(bufaddr, buflen); 22130 22131 cdb.scc_cmd = SCMD_GET_EVENT_STATUS_NOTIFICATION; 22132 cdb.cdb_opaque[1] = 1; /* polled */ 22133 cdb.cdb_opaque[4] = class_req; 22134 FORMG1COUNT(&cdb, buflen); 22135 22136 ucmd_buf.uscsi_cdb = (char *)&cdb; 22137 ucmd_buf.uscsi_cdblen = CDB_GROUP1; 22138 ucmd_buf.uscsi_bufaddr = (caddr_t)bufaddr; 22139 ucmd_buf.uscsi_buflen = buflen; 22140 ucmd_buf.uscsi_rqbuf = NULL; 22141 ucmd_buf.uscsi_rqlen = 0; 22142 ucmd_buf.uscsi_flags = USCSI_READ | USCSI_SILENT; 22143 ucmd_buf.uscsi_timeout = 60; 22144 22145 status = sd_ssc_send(ssc, &ucmd_buf, FKIOCTL, 22146 UIO_SYSSPACE, SD_PATH_DIRECT); 22147 22148 /* 22149 * Only handle status == 0, the upper-level caller 22150 * will put different assessment based on the context. 22151 */ 22152 if (status == 0) { 22153 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 22154 22155 if (ucmd_buf.uscsi_resid != 0) { 22156 status = EIO; 22157 } 22158 } 22159 22160 SD_TRACE(SD_LOG_IO, un, 22161 "sd_send_scsi_GET_EVENT_STATUS_NOTIFICATION: exit\n"); 22162 22163 return (status); 22164 } 22165 22166 22167 static boolean_t 22168 sd_gesn_media_data_valid(uchar_t *data) 22169 { 22170 uint16_t len; 22171 22172 len = (data[1] << 8) | data[0]; 22173 return ((len >= 6) && 22174 ((data[2] & SD_GESN_HEADER_NEA) == 0) && 22175 ((data[2] & SD_GESN_HEADER_CLASS) == SD_GESN_MEDIA_CLASS) && 22176 ((data[3] & (1 << SD_GESN_MEDIA_CLASS)) != 0)); 22177 } 22178 22179 22180 /* 22181 * Function: sdioctl 22182 * 22183 * Description: Driver's ioctl(9e) entry point function. 22184 * 22185 * Arguments: dev - device number 22186 * cmd - ioctl operation to be performed 22187 * arg - user argument, contains data to be set or reference 22188 * parameter for get 22189 * flag - bit flag, indicating open settings, 32/64 bit type 22190 * cred_p - user credential pointer 22191 * rval_p - calling process return value (OPT) 22192 * 22193 * Return Code: EINVAL 22194 * ENOTTY 22195 * ENXIO 22196 * EIO 22197 * EFAULT 22198 * ENOTSUP 22199 * EPERM 22200 * 22201 * Context: Called from the device switch at normal priority. 22202 */ 22203 22204 static int 22205 sdioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cred_p, int *rval_p) 22206 { 22207 struct sd_lun *un = NULL; 22208 int err = 0; 22209 int i = 0; 22210 cred_t *cr; 22211 int tmprval = EINVAL; 22212 boolean_t is_valid; 22213 sd_ssc_t *ssc; 22214 22215 /* 22216 * All device accesses go thru sdstrategy where we check on suspend 22217 * status 22218 */ 22219 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) { 22220 return (ENXIO); 22221 } 22222 22223 ASSERT(!mutex_owned(SD_MUTEX(un))); 22224 22225 /* Initialize sd_ssc_t for internal uscsi commands */ 22226 ssc = sd_ssc_init(un); 22227 22228 is_valid = SD_IS_VALID_LABEL(un); 22229 22230 /* 22231 * Moved this wait from sd_uscsi_strategy to here for 22232 * reasons of deadlock prevention. Internal driver commands, 22233 * specifically those to change a devices power level, result 22234 * in a call to sd_uscsi_strategy. 22235 */ 22236 mutex_enter(SD_MUTEX(un)); 22237 while ((un->un_state == SD_STATE_SUSPENDED) || 22238 (un->un_state == SD_STATE_PM_CHANGING)) { 22239 cv_wait(&un->un_suspend_cv, SD_MUTEX(un)); 22240 } 22241 /* 22242 * Twiddling the counter here protects commands from now 22243 * through to the top of sd_uscsi_strategy. Without the 22244 * counter inc. a power down, for example, could get in 22245 * after the above check for state is made and before 22246 * execution gets to the top of sd_uscsi_strategy. 22247 * That would cause problems. 22248 */ 22249 un->un_ncmds_in_driver++; 22250 22251 if (!is_valid && 22252 (flag & (FNDELAY | FNONBLOCK))) { 22253 switch (cmd) { 22254 case DKIOCGGEOM: /* SD_PATH_DIRECT */ 22255 case DKIOCGVTOC: 22256 case DKIOCGEXTVTOC: 22257 case DKIOCGAPART: 22258 case DKIOCPARTINFO: 22259 case DKIOCEXTPARTINFO: 22260 case DKIOCSGEOM: 22261 case DKIOCSAPART: 22262 case DKIOCGETEFI: 22263 case DKIOCPARTITION: 22264 case DKIOCSVTOC: 22265 case DKIOCSEXTVTOC: 22266 case DKIOCSETEFI: 22267 case DKIOCGMBOOT: 22268 case DKIOCSMBOOT: 22269 case DKIOCG_PHYGEOM: 22270 case DKIOCG_VIRTGEOM: 22271 #if defined(__i386) || defined(__amd64) 22272 case DKIOCSETEXTPART: 22273 #endif 22274 /* let cmlb handle it */ 22275 goto skip_ready_valid; 22276 22277 case CDROMPAUSE: 22278 case CDROMRESUME: 22279 case CDROMPLAYMSF: 22280 case CDROMPLAYTRKIND: 22281 case CDROMREADTOCHDR: 22282 case CDROMREADTOCENTRY: 22283 case CDROMSTOP: 22284 case CDROMSTART: 22285 case CDROMVOLCTRL: 22286 case CDROMSUBCHNL: 22287 case CDROMREADMODE2: 22288 case CDROMREADMODE1: 22289 case CDROMREADOFFSET: 22290 case CDROMSBLKMODE: 22291 case CDROMGBLKMODE: 22292 case CDROMGDRVSPEED: 22293 case CDROMSDRVSPEED: 22294 case CDROMCDDA: 22295 case CDROMCDXA: 22296 case CDROMSUBCODE: 22297 if (!ISCD(un)) { 22298 un->un_ncmds_in_driver--; 22299 ASSERT(un->un_ncmds_in_driver >= 0); 22300 mutex_exit(SD_MUTEX(un)); 22301 err = ENOTTY; 22302 goto done_without_assess; 22303 } 22304 break; 22305 case FDEJECT: 22306 case DKIOCEJECT: 22307 case CDROMEJECT: 22308 if (!un->un_f_eject_media_supported) { 22309 un->un_ncmds_in_driver--; 22310 ASSERT(un->un_ncmds_in_driver >= 0); 22311 mutex_exit(SD_MUTEX(un)); 22312 err = ENOTTY; 22313 goto done_without_assess; 22314 } 22315 break; 22316 case DKIOCFLUSHWRITECACHE: 22317 mutex_exit(SD_MUTEX(un)); 22318 err = sd_send_scsi_TEST_UNIT_READY(ssc, 0); 22319 if (err != 0) { 22320 mutex_enter(SD_MUTEX(un)); 22321 un->un_ncmds_in_driver--; 22322 ASSERT(un->un_ncmds_in_driver >= 0); 22323 mutex_exit(SD_MUTEX(un)); 22324 err = EIO; 22325 goto done_quick_assess; 22326 } 22327 mutex_enter(SD_MUTEX(un)); 22328 /* FALLTHROUGH */ 22329 case DKIOCREMOVABLE: 22330 case DKIOCHOTPLUGGABLE: 22331 case DKIOCINFO: 22332 case DKIOCGMEDIAINFO: 22333 case DKIOCGMEDIAINFOEXT: 22334 case DKIOCSOLIDSTATE: 22335 case MHIOCENFAILFAST: 22336 case MHIOCSTATUS: 22337 case MHIOCTKOWN: 22338 case MHIOCRELEASE: 22339 case MHIOCGRP_INKEYS: 22340 case MHIOCGRP_INRESV: 22341 case MHIOCGRP_REGISTER: 22342 case MHIOCGRP_CLEAR: 22343 case MHIOCGRP_RESERVE: 22344 case MHIOCGRP_PREEMPTANDABORT: 22345 case MHIOCGRP_REGISTERANDIGNOREKEY: 22346 case CDROMCLOSETRAY: 22347 case USCSICMD: 22348 goto skip_ready_valid; 22349 default: 22350 break; 22351 } 22352 22353 mutex_exit(SD_MUTEX(un)); 22354 err = sd_ready_and_valid(ssc, SDPART(dev)); 22355 mutex_enter(SD_MUTEX(un)); 22356 22357 if (err != SD_READY_VALID) { 22358 switch (cmd) { 22359 case DKIOCSTATE: 22360 case CDROMGDRVSPEED: 22361 case CDROMSDRVSPEED: 22362 case FDEJECT: /* for eject command */ 22363 case DKIOCEJECT: 22364 case CDROMEJECT: 22365 case DKIOCREMOVABLE: 22366 case DKIOCHOTPLUGGABLE: 22367 break; 22368 default: 22369 if (un->un_f_has_removable_media) { 22370 err = ENXIO; 22371 } else { 22372 /* Do not map SD_RESERVED_BY_OTHERS to EIO */ 22373 if (err == SD_RESERVED_BY_OTHERS) { 22374 err = EACCES; 22375 } else { 22376 err = EIO; 22377 } 22378 } 22379 un->un_ncmds_in_driver--; 22380 ASSERT(un->un_ncmds_in_driver >= 0); 22381 mutex_exit(SD_MUTEX(un)); 22382 22383 goto done_without_assess; 22384 } 22385 } 22386 } 22387 22388 skip_ready_valid: 22389 mutex_exit(SD_MUTEX(un)); 22390 22391 switch (cmd) { 22392 case DKIOCINFO: 22393 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCINFO\n"); 22394 err = sd_dkio_ctrl_info(dev, (caddr_t)arg, flag); 22395 break; 22396 22397 case DKIOCGMEDIAINFO: 22398 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCGMEDIAINFO\n"); 22399 err = sd_get_media_info(dev, (caddr_t)arg, flag); 22400 break; 22401 22402 case DKIOCGMEDIAINFOEXT: 22403 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCGMEDIAINFOEXT\n"); 22404 err = sd_get_media_info_ext(dev, (caddr_t)arg, flag); 22405 break; 22406 22407 case DKIOCGGEOM: 22408 case DKIOCGVTOC: 22409 case DKIOCGEXTVTOC: 22410 case DKIOCGAPART: 22411 case DKIOCPARTINFO: 22412 case DKIOCEXTPARTINFO: 22413 case DKIOCSGEOM: 22414 case DKIOCSAPART: 22415 case DKIOCGETEFI: 22416 case DKIOCPARTITION: 22417 case DKIOCSVTOC: 22418 case DKIOCSEXTVTOC: 22419 case DKIOCSETEFI: 22420 case DKIOCGMBOOT: 22421 case DKIOCSMBOOT: 22422 case DKIOCG_PHYGEOM: 22423 case DKIOCG_VIRTGEOM: 22424 #if defined(__i386) || defined(__amd64) 22425 case DKIOCSETEXTPART: 22426 #endif 22427 SD_TRACE(SD_LOG_IOCTL, un, "DKIOC %d\n", cmd); 22428 22429 /* TUR should spin up */ 22430 22431 if (un->un_f_has_removable_media) 22432 err = sd_send_scsi_TEST_UNIT_READY(ssc, 22433 SD_CHECK_FOR_MEDIA); 22434 22435 else 22436 err = sd_send_scsi_TEST_UNIT_READY(ssc, 0); 22437 22438 if (err != 0) 22439 goto done_with_assess; 22440 22441 err = cmlb_ioctl(un->un_cmlbhandle, dev, 22442 cmd, arg, flag, cred_p, rval_p, (void *)SD_PATH_DIRECT); 22443 22444 if ((err == 0) && 22445 ((cmd == DKIOCSETEFI) || 22446 (un->un_f_pkstats_enabled) && 22447 (cmd == DKIOCSAPART || cmd == DKIOCSVTOC || 22448 cmd == DKIOCSEXTVTOC))) { 22449 22450 tmprval = cmlb_validate(un->un_cmlbhandle, CMLB_SILENT, 22451 (void *)SD_PATH_DIRECT); 22452 if ((tmprval == 0) && un->un_f_pkstats_enabled) { 22453 sd_set_pstats(un); 22454 SD_TRACE(SD_LOG_IO_PARTITION, un, 22455 "sd_ioctl: un:0x%p pstats created and " 22456 "set\n", un); 22457 } 22458 } 22459 22460 if ((cmd == DKIOCSVTOC || cmd == DKIOCSEXTVTOC) || 22461 ((cmd == DKIOCSETEFI) && (tmprval == 0))) { 22462 22463 mutex_enter(SD_MUTEX(un)); 22464 if (un->un_f_devid_supported && 22465 (un->un_f_opt_fab_devid == TRUE)) { 22466 if (un->un_devid == NULL) { 22467 sd_register_devid(ssc, SD_DEVINFO(un), 22468 SD_TARGET_IS_UNRESERVED); 22469 } else { 22470 /* 22471 * The device id for this disk 22472 * has been fabricated. The 22473 * device id must be preserved 22474 * by writing it back out to 22475 * disk. 22476 */ 22477 if (sd_write_deviceid(ssc) != 0) { 22478 ddi_devid_free(un->un_devid); 22479 un->un_devid = NULL; 22480 } 22481 } 22482 } 22483 mutex_exit(SD_MUTEX(un)); 22484 } 22485 22486 break; 22487 22488 case DKIOCLOCK: 22489 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCLOCK\n"); 22490 err = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_PREVENT, 22491 SD_PATH_STANDARD); 22492 goto done_with_assess; 22493 22494 case DKIOCUNLOCK: 22495 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCUNLOCK\n"); 22496 err = sd_send_scsi_DOORLOCK(ssc, SD_REMOVAL_ALLOW, 22497 SD_PATH_STANDARD); 22498 goto done_with_assess; 22499 22500 case DKIOCSTATE: { 22501 enum dkio_state state; 22502 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCSTATE\n"); 22503 22504 if (ddi_copyin((void *)arg, &state, sizeof (int), flag) != 0) { 22505 err = EFAULT; 22506 } else { 22507 err = sd_check_media(dev, state); 22508 if (err == 0) { 22509 if (ddi_copyout(&un->un_mediastate, (void *)arg, 22510 sizeof (int), flag) != 0) 22511 err = EFAULT; 22512 } 22513 } 22514 break; 22515 } 22516 22517 case DKIOCREMOVABLE: 22518 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCREMOVABLE\n"); 22519 i = un->un_f_has_removable_media ? 1 : 0; 22520 if (ddi_copyout(&i, (void *)arg, sizeof (int), flag) != 0) { 22521 err = EFAULT; 22522 } else { 22523 err = 0; 22524 } 22525 break; 22526 22527 case DKIOCSOLIDSTATE: 22528 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCSOLIDSTATE\n"); 22529 i = un->un_f_is_solid_state ? 1 : 0; 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 DKIOCHOTPLUGGABLE: 22538 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCHOTPLUGGABLE\n"); 22539 i = un->un_f_is_hotpluggable ? 1 : 0; 22540 if (ddi_copyout(&i, (void *)arg, sizeof (int), flag) != 0) { 22541 err = EFAULT; 22542 } else { 22543 err = 0; 22544 } 22545 break; 22546 22547 case DKIOCREADONLY: 22548 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCREADONLY\n"); 22549 i = 0; 22550 if ((ISCD(un) && !un->un_f_mmc_writable_media) || 22551 (sr_check_wp(dev) != 0)) { 22552 i = 1; 22553 } 22554 if (ddi_copyout(&i, (void *)arg, sizeof (int), flag) != 0) { 22555 err = EFAULT; 22556 } else { 22557 err = 0; 22558 } 22559 break; 22560 22561 case DKIOCGTEMPERATURE: 22562 SD_TRACE(SD_LOG_IOCTL, un, "DKIOCGTEMPERATURE\n"); 22563 err = sd_dkio_get_temp(dev, (caddr_t)arg, flag); 22564 break; 22565 22566 case MHIOCENFAILFAST: 22567 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCENFAILFAST\n"); 22568 if ((err = drv_priv(cred_p)) == 0) { 22569 err = sd_mhdioc_failfast(dev, (caddr_t)arg, flag); 22570 } 22571 break; 22572 22573 case MHIOCTKOWN: 22574 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCTKOWN\n"); 22575 if ((err = drv_priv(cred_p)) == 0) { 22576 err = sd_mhdioc_takeown(dev, (caddr_t)arg, flag); 22577 } 22578 break; 22579 22580 case MHIOCRELEASE: 22581 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCRELEASE\n"); 22582 if ((err = drv_priv(cred_p)) == 0) { 22583 err = sd_mhdioc_release(dev); 22584 } 22585 break; 22586 22587 case MHIOCSTATUS: 22588 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCSTATUS\n"); 22589 if ((err = drv_priv(cred_p)) == 0) { 22590 switch (sd_send_scsi_TEST_UNIT_READY(ssc, 0)) { 22591 case 0: 22592 err = 0; 22593 break; 22594 case EACCES: 22595 *rval_p = 1; 22596 err = 0; 22597 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 22598 break; 22599 default: 22600 err = EIO; 22601 goto done_with_assess; 22602 } 22603 } 22604 break; 22605 22606 case MHIOCQRESERVE: 22607 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCQRESERVE\n"); 22608 if ((err = drv_priv(cred_p)) == 0) { 22609 err = sd_reserve_release(dev, SD_RESERVE); 22610 } 22611 break; 22612 22613 case MHIOCREREGISTERDEVID: 22614 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCREREGISTERDEVID\n"); 22615 if (drv_priv(cred_p) == EPERM) { 22616 err = EPERM; 22617 } else if (!un->un_f_devid_supported) { 22618 err = ENOTTY; 22619 } else { 22620 err = sd_mhdioc_register_devid(dev); 22621 } 22622 break; 22623 22624 case MHIOCGRP_INKEYS: 22625 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_INKEYS\n"); 22626 if (((err = drv_priv(cred_p)) != EPERM) && arg != NULL) { 22627 if (un->un_reservation_type == SD_SCSI2_RESERVATION) { 22628 err = ENOTSUP; 22629 } else { 22630 err = sd_mhdioc_inkeys(dev, (caddr_t)arg, 22631 flag); 22632 } 22633 } 22634 break; 22635 22636 case MHIOCGRP_INRESV: 22637 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_INRESV\n"); 22638 if (((err = drv_priv(cred_p)) != EPERM) && arg != NULL) { 22639 if (un->un_reservation_type == SD_SCSI2_RESERVATION) { 22640 err = ENOTSUP; 22641 } else { 22642 err = sd_mhdioc_inresv(dev, (caddr_t)arg, flag); 22643 } 22644 } 22645 break; 22646 22647 case MHIOCGRP_REGISTER: 22648 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_REGISTER\n"); 22649 if ((err = drv_priv(cred_p)) != EPERM) { 22650 if (un->un_reservation_type == SD_SCSI2_RESERVATION) { 22651 err = ENOTSUP; 22652 } else if (arg != NULL) { 22653 mhioc_register_t reg; 22654 if (ddi_copyin((void *)arg, ®, 22655 sizeof (mhioc_register_t), flag) != 0) { 22656 err = EFAULT; 22657 } else { 22658 err = 22659 sd_send_scsi_PERSISTENT_RESERVE_OUT( 22660 ssc, SD_SCSI3_REGISTER, 22661 (uchar_t *)®); 22662 if (err != 0) 22663 goto done_with_assess; 22664 } 22665 } 22666 } 22667 break; 22668 22669 case MHIOCGRP_CLEAR: 22670 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_CLEAR\n"); 22671 if ((err = drv_priv(cred_p)) != EPERM) { 22672 if (un->un_reservation_type == SD_SCSI2_RESERVATION) { 22673 err = ENOTSUP; 22674 } else if (arg != NULL) { 22675 mhioc_register_t reg; 22676 if (ddi_copyin((void *)arg, ®, 22677 sizeof (mhioc_register_t), flag) != 0) { 22678 err = EFAULT; 22679 } else { 22680 err = 22681 sd_send_scsi_PERSISTENT_RESERVE_OUT( 22682 ssc, SD_SCSI3_CLEAR, 22683 (uchar_t *)®); 22684 if (err != 0) 22685 goto done_with_assess; 22686 } 22687 } 22688 } 22689 break; 22690 22691 case MHIOCGRP_RESERVE: 22692 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_RESERVE\n"); 22693 if ((err = drv_priv(cred_p)) != EPERM) { 22694 if (un->un_reservation_type == SD_SCSI2_RESERVATION) { 22695 err = ENOTSUP; 22696 } else if (arg != NULL) { 22697 mhioc_resv_desc_t resv_desc; 22698 if (ddi_copyin((void *)arg, &resv_desc, 22699 sizeof (mhioc_resv_desc_t), flag) != 0) { 22700 err = EFAULT; 22701 } else { 22702 err = 22703 sd_send_scsi_PERSISTENT_RESERVE_OUT( 22704 ssc, SD_SCSI3_RESERVE, 22705 (uchar_t *)&resv_desc); 22706 if (err != 0) 22707 goto done_with_assess; 22708 } 22709 } 22710 } 22711 break; 22712 22713 case MHIOCGRP_PREEMPTANDABORT: 22714 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_PREEMPTANDABORT\n"); 22715 if ((err = drv_priv(cred_p)) != EPERM) { 22716 if (un->un_reservation_type == SD_SCSI2_RESERVATION) { 22717 err = ENOTSUP; 22718 } else if (arg != NULL) { 22719 mhioc_preemptandabort_t preempt_abort; 22720 if (ddi_copyin((void *)arg, &preempt_abort, 22721 sizeof (mhioc_preemptandabort_t), 22722 flag) != 0) { 22723 err = EFAULT; 22724 } else { 22725 err = 22726 sd_send_scsi_PERSISTENT_RESERVE_OUT( 22727 ssc, SD_SCSI3_PREEMPTANDABORT, 22728 (uchar_t *)&preempt_abort); 22729 if (err != 0) 22730 goto done_with_assess; 22731 } 22732 } 22733 } 22734 break; 22735 22736 case MHIOCGRP_REGISTERANDIGNOREKEY: 22737 SD_TRACE(SD_LOG_IOCTL, un, "MHIOCGRP_REGISTERANDIGNOREKEY\n"); 22738 if ((err = drv_priv(cred_p)) != EPERM) { 22739 if (un->un_reservation_type == SD_SCSI2_RESERVATION) { 22740 err = ENOTSUP; 22741 } else if (arg != NULL) { 22742 mhioc_registerandignorekey_t r_and_i; 22743 if (ddi_copyin((void *)arg, (void *)&r_and_i, 22744 sizeof (mhioc_registerandignorekey_t), 22745 flag) != 0) { 22746 err = EFAULT; 22747 } else { 22748 err = 22749 sd_send_scsi_PERSISTENT_RESERVE_OUT( 22750 ssc, SD_SCSI3_REGISTERANDIGNOREKEY, 22751 (uchar_t *)&r_and_i); 22752 if (err != 0) 22753 goto done_with_assess; 22754 } 22755 } 22756 } 22757 break; 22758 22759 case USCSICMD: 22760 SD_TRACE(SD_LOG_IOCTL, un, "USCSICMD\n"); 22761 cr = ddi_get_cred(); 22762 if ((drv_priv(cred_p) != 0) && (drv_priv(cr) != 0)) { 22763 err = EPERM; 22764 } else { 22765 enum uio_seg uioseg; 22766 22767 uioseg = (flag & FKIOCTL) ? UIO_SYSSPACE : 22768 UIO_USERSPACE; 22769 if (un->un_f_format_in_progress == TRUE) { 22770 err = EAGAIN; 22771 break; 22772 } 22773 22774 err = sd_ssc_send(ssc, 22775 (struct uscsi_cmd *)arg, 22776 flag, uioseg, SD_PATH_STANDARD); 22777 if (err != 0) 22778 goto done_with_assess; 22779 else 22780 sd_ssc_assessment(ssc, SD_FMT_STANDARD); 22781 } 22782 break; 22783 22784 case CDROMPAUSE: 22785 case CDROMRESUME: 22786 SD_TRACE(SD_LOG_IOCTL, un, "PAUSE-RESUME\n"); 22787 if (!ISCD(un)) { 22788 err = ENOTTY; 22789 } else { 22790 err = sr_pause_resume(dev, cmd); 22791 } 22792 break; 22793 22794 case CDROMPLAYMSF: 22795 SD_TRACE(SD_LOG_IOCTL, un, "CDROMPLAYMSF\n"); 22796 if (!ISCD(un)) { 22797 err = ENOTTY; 22798 } else { 22799 err = sr_play_msf(dev, (caddr_t)arg, flag); 22800 } 22801 break; 22802 22803 case CDROMPLAYTRKIND: 22804 SD_TRACE(SD_LOG_IOCTL, un, "CDROMPLAYTRKIND\n"); 22805 #if defined(__i386) || defined(__amd64) 22806 /* 22807 * not supported on ATAPI CD drives, use CDROMPLAYMSF instead 22808 */ 22809 if (!ISCD(un) || (un->un_f_cfg_is_atapi == TRUE)) { 22810 #else 22811 if (!ISCD(un)) { 22812 #endif 22813 err = ENOTTY; 22814 } else { 22815 err = sr_play_trkind(dev, (caddr_t)arg, flag); 22816 } 22817 break; 22818 22819 case CDROMREADTOCHDR: 22820 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADTOCHDR\n"); 22821 if (!ISCD(un)) { 22822 err = ENOTTY; 22823 } else { 22824 err = sr_read_tochdr(dev, (caddr_t)arg, flag); 22825 } 22826 break; 22827 22828 case CDROMREADTOCENTRY: 22829 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADTOCENTRY\n"); 22830 if (!ISCD(un)) { 22831 err = ENOTTY; 22832 } else { 22833 err = sr_read_tocentry(dev, (caddr_t)arg, flag); 22834 } 22835 break; 22836 22837 case CDROMSTOP: 22838 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSTOP\n"); 22839 if (!ISCD(un)) { 22840 err = ENOTTY; 22841 } else { 22842 err = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP, 22843 SD_TARGET_STOP, SD_PATH_STANDARD); 22844 goto done_with_assess; 22845 } 22846 break; 22847 22848 case CDROMSTART: 22849 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSTART\n"); 22850 if (!ISCD(un)) { 22851 err = ENOTTY; 22852 } else { 22853 err = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP, 22854 SD_TARGET_START, SD_PATH_STANDARD); 22855 goto done_with_assess; 22856 } 22857 break; 22858 22859 case CDROMCLOSETRAY: 22860 SD_TRACE(SD_LOG_IOCTL, un, "CDROMCLOSETRAY\n"); 22861 if (!ISCD(un)) { 22862 err = ENOTTY; 22863 } else { 22864 err = sd_send_scsi_START_STOP_UNIT(ssc, SD_START_STOP, 22865 SD_TARGET_CLOSE, SD_PATH_STANDARD); 22866 goto done_with_assess; 22867 } 22868 break; 22869 22870 case FDEJECT: /* for eject command */ 22871 case DKIOCEJECT: 22872 case CDROMEJECT: 22873 SD_TRACE(SD_LOG_IOCTL, un, "EJECT\n"); 22874 if (!un->un_f_eject_media_supported) { 22875 err = ENOTTY; 22876 } else { 22877 err = sr_eject(dev); 22878 } 22879 break; 22880 22881 case CDROMVOLCTRL: 22882 SD_TRACE(SD_LOG_IOCTL, un, "CDROMVOLCTRL\n"); 22883 if (!ISCD(un)) { 22884 err = ENOTTY; 22885 } else { 22886 err = sr_volume_ctrl(dev, (caddr_t)arg, flag); 22887 } 22888 break; 22889 22890 case CDROMSUBCHNL: 22891 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSUBCHNL\n"); 22892 if (!ISCD(un)) { 22893 err = ENOTTY; 22894 } else { 22895 err = sr_read_subchannel(dev, (caddr_t)arg, flag); 22896 } 22897 break; 22898 22899 case CDROMREADMODE2: 22900 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADMODE2\n"); 22901 if (!ISCD(un)) { 22902 err = ENOTTY; 22903 } else if (un->un_f_cfg_is_atapi == TRUE) { 22904 /* 22905 * If the drive supports READ CD, use that instead of 22906 * switching the LBA size via a MODE SELECT 22907 * Block Descriptor 22908 */ 22909 err = sr_read_cd_mode2(dev, (caddr_t)arg, flag); 22910 } else { 22911 err = sr_read_mode2(dev, (caddr_t)arg, flag); 22912 } 22913 break; 22914 22915 case CDROMREADMODE1: 22916 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADMODE1\n"); 22917 if (!ISCD(un)) { 22918 err = ENOTTY; 22919 } else { 22920 err = sr_read_mode1(dev, (caddr_t)arg, flag); 22921 } 22922 break; 22923 22924 case CDROMREADOFFSET: 22925 SD_TRACE(SD_LOG_IOCTL, un, "CDROMREADOFFSET\n"); 22926 if (!ISCD(un)) { 22927 err = ENOTTY; 22928 } else { 22929 err = sr_read_sony_session_offset(dev, (caddr_t)arg, 22930 flag); 22931 } 22932 break; 22933 22934 case CDROMSBLKMODE: 22935 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSBLKMODE\n"); 22936 /* 22937 * There is no means of changing block size in case of atapi 22938 * drives, thus return ENOTTY if drive type is atapi 22939 */ 22940 if (!ISCD(un) || (un->un_f_cfg_is_atapi == TRUE)) { 22941 err = ENOTTY; 22942 } else if (un->un_f_mmc_cap == TRUE) { 22943 22944 /* 22945 * MMC Devices do not support changing the 22946 * logical block size 22947 * 22948 * Note: EINVAL is being returned instead of ENOTTY to 22949 * maintain consistancy with the original mmc 22950 * driver update. 22951 */ 22952 err = EINVAL; 22953 } else { 22954 mutex_enter(SD_MUTEX(un)); 22955 if ((!(un->un_exclopen & (1<<SDPART(dev)))) || 22956 (un->un_ncmds_in_transport > 0)) { 22957 mutex_exit(SD_MUTEX(un)); 22958 err = EINVAL; 22959 } else { 22960 mutex_exit(SD_MUTEX(un)); 22961 err = sr_change_blkmode(dev, cmd, arg, flag); 22962 } 22963 } 22964 break; 22965 22966 case CDROMGBLKMODE: 22967 SD_TRACE(SD_LOG_IOCTL, un, "CDROMGBLKMODE\n"); 22968 if (!ISCD(un)) { 22969 err = ENOTTY; 22970 } else if ((un->un_f_cfg_is_atapi != FALSE) && 22971 (un->un_f_blockcount_is_valid != FALSE)) { 22972 /* 22973 * Drive is an ATAPI drive so return target block 22974 * size for ATAPI drives since we cannot change the 22975 * blocksize on ATAPI drives. Used primarily to detect 22976 * if an ATAPI cdrom is present. 22977 */ 22978 if (ddi_copyout(&un->un_tgt_blocksize, (void *)arg, 22979 sizeof (int), flag) != 0) { 22980 err = EFAULT; 22981 } else { 22982 err = 0; 22983 } 22984 22985 } else { 22986 /* 22987 * Drive supports changing block sizes via a Mode 22988 * Select. 22989 */ 22990 err = sr_change_blkmode(dev, cmd, arg, flag); 22991 } 22992 break; 22993 22994 case CDROMGDRVSPEED: 22995 case CDROMSDRVSPEED: 22996 SD_TRACE(SD_LOG_IOCTL, un, "CDROMXDRVSPEED\n"); 22997 if (!ISCD(un)) { 22998 err = ENOTTY; 22999 } else if (un->un_f_mmc_cap == TRUE) { 23000 /* 23001 * Note: In the future the driver implementation 23002 * for getting and 23003 * setting cd speed should entail: 23004 * 1) If non-mmc try the Toshiba mode page 23005 * (sr_change_speed) 23006 * 2) If mmc but no support for Real Time Streaming try 23007 * the SET CD SPEED (0xBB) command 23008 * (sr_atapi_change_speed) 23009 * 3) If mmc and support for Real Time Streaming 23010 * try the GET PERFORMANCE and SET STREAMING 23011 * commands (not yet implemented, 4380808) 23012 */ 23013 /* 23014 * As per recent MMC spec, CD-ROM speed is variable 23015 * and changes with LBA. Since there is no such 23016 * things as drive speed now, fail this ioctl. 23017 * 23018 * Note: EINVAL is returned for consistancy of original 23019 * implementation which included support for getting 23020 * the drive speed of mmc devices but not setting 23021 * the drive speed. Thus EINVAL would be returned 23022 * if a set request was made for an mmc device. 23023 * We no longer support get or set speed for 23024 * mmc but need to remain consistent with regard 23025 * to the error code returned. 23026 */ 23027 err = EINVAL; 23028 } else if (un->un_f_cfg_is_atapi == TRUE) { 23029 err = sr_atapi_change_speed(dev, cmd, arg, flag); 23030 } else { 23031 err = sr_change_speed(dev, cmd, arg, flag); 23032 } 23033 break; 23034 23035 case CDROMCDDA: 23036 SD_TRACE(SD_LOG_IOCTL, un, "CDROMCDDA\n"); 23037 if (!ISCD(un)) { 23038 err = ENOTTY; 23039 } else { 23040 err = sr_read_cdda(dev, (void *)arg, flag); 23041 } 23042 break; 23043 23044 case CDROMCDXA: 23045 SD_TRACE(SD_LOG_IOCTL, un, "CDROMCDXA\n"); 23046 if (!ISCD(un)) { 23047 err = ENOTTY; 23048 } else { 23049 err = sr_read_cdxa(dev, (caddr_t)arg, flag); 23050 } 23051 break; 23052 23053 case CDROMSUBCODE: 23054 SD_TRACE(SD_LOG_IOCTL, un, "CDROMSUBCODE\n"); 23055 if (!ISCD(un)) { 23056 err = ENOTTY; 23057 } else { 23058 err = sr_read_all_subcodes(dev, (caddr_t)arg, flag); 23059 } 23060 break; 23061 23062 23063 #ifdef SDDEBUG 23064 /* RESET/ABORTS testing ioctls */ 23065 case DKIOCRESET: { 23066 int reset_level; 23067 23068 if (ddi_copyin((void *)arg, &reset_level, sizeof (int), flag)) { 23069 err = EFAULT; 23070 } else { 23071 SD_INFO(SD_LOG_IOCTL, un, "sdioctl: DKIOCRESET: " 23072 "reset_level = 0x%lx\n", reset_level); 23073 if (scsi_reset(SD_ADDRESS(un), reset_level)) { 23074 err = 0; 23075 } else { 23076 err = EIO; 23077 } 23078 } 23079 break; 23080 } 23081 23082 case DKIOCABORT: 23083 SD_INFO(SD_LOG_IOCTL, un, "sdioctl: DKIOCABORT:\n"); 23084 if (scsi_abort(SD_ADDRESS(un), NULL)) { 23085 err = 0; 23086 } else { 23087 err = EIO; 23088 } 23089 break; 23090 #endif 23091 23092 #ifdef SD_FAULT_INJECTION 23093 /* SDIOC FaultInjection testing ioctls */ 23094 case SDIOCSTART: 23095 case SDIOCSTOP: 23096 case SDIOCINSERTPKT: 23097 case SDIOCINSERTXB: 23098 case SDIOCINSERTUN: 23099 case SDIOCINSERTARQ: 23100 case SDIOCPUSH: 23101 case SDIOCRETRIEVE: 23102 case SDIOCRUN: 23103 SD_INFO(SD_LOG_SDTEST, un, "sdioctl:" 23104 "SDIOC detected cmd:0x%X:\n", cmd); 23105 /* call error generator */ 23106 sd_faultinjection_ioctl(cmd, arg, un); 23107 err = 0; 23108 break; 23109 23110 #endif /* SD_FAULT_INJECTION */ 23111 23112 case DKIOCFLUSHWRITECACHE: 23113 { 23114 struct dk_callback *dkc = (struct dk_callback *)arg; 23115 23116 mutex_enter(SD_MUTEX(un)); 23117 if (!un->un_f_sync_cache_supported || 23118 !un->un_f_write_cache_enabled) { 23119 err = un->un_f_sync_cache_supported ? 23120 0 : ENOTSUP; 23121 mutex_exit(SD_MUTEX(un)); 23122 if ((flag & FKIOCTL) && dkc != NULL && 23123 dkc->dkc_callback != NULL) { 23124 (*dkc->dkc_callback)(dkc->dkc_cookie, 23125 err); 23126 /* 23127 * Did callback and reported error. 23128 * Since we did a callback, ioctl 23129 * should return 0. 23130 */ 23131 err = 0; 23132 } 23133 break; 23134 } 23135 mutex_exit(SD_MUTEX(un)); 23136 23137 if ((flag & FKIOCTL) && dkc != NULL && 23138 dkc->dkc_callback != NULL) { 23139 /* async SYNC CACHE request */ 23140 err = sd_send_scsi_SYNCHRONIZE_CACHE(un, dkc); 23141 } else { 23142 /* synchronous SYNC CACHE request */ 23143 err = sd_send_scsi_SYNCHRONIZE_CACHE(un, NULL); 23144 } 23145 } 23146 break; 23147 23148 case DKIOCGETWCE: { 23149 23150 int wce; 23151 23152 if ((err = sd_get_write_cache_enabled(ssc, &wce)) != 0) { 23153 break; 23154 } 23155 23156 if (ddi_copyout(&wce, (void *)arg, sizeof (wce), flag)) { 23157 err = EFAULT; 23158 } 23159 break; 23160 } 23161 23162 case DKIOCSETWCE: { 23163 23164 int wce, sync_supported; 23165 int cur_wce = 0; 23166 23167 if (ddi_copyin((void *)arg, &wce, sizeof (wce), flag)) { 23168 err = EFAULT; 23169 break; 23170 } 23171 23172 /* 23173 * Synchronize multiple threads trying to enable 23174 * or disable the cache via the un_f_wcc_cv 23175 * condition variable. 23176 */ 23177 mutex_enter(SD_MUTEX(un)); 23178 23179 /* 23180 * Don't allow the cache to be enabled if the 23181 * config file has it disabled. 23182 */ 23183 if (un->un_f_opt_disable_cache && wce) { 23184 mutex_exit(SD_MUTEX(un)); 23185 err = EINVAL; 23186 break; 23187 } 23188 23189 /* 23190 * Wait for write cache change in progress 23191 * bit to be clear before proceeding. 23192 */ 23193 while (un->un_f_wcc_inprog) 23194 cv_wait(&un->un_wcc_cv, SD_MUTEX(un)); 23195 23196 un->un_f_wcc_inprog = 1; 23197 23198 mutex_exit(SD_MUTEX(un)); 23199 23200 /* 23201 * Get the current write cache state 23202 */ 23203 if ((err = sd_get_write_cache_enabled(ssc, &cur_wce)) != 0) { 23204 mutex_enter(SD_MUTEX(un)); 23205 un->un_f_wcc_inprog = 0; 23206 cv_broadcast(&un->un_wcc_cv); 23207 mutex_exit(SD_MUTEX(un)); 23208 break; 23209 } 23210 23211 mutex_enter(SD_MUTEX(un)); 23212 un->un_f_write_cache_enabled = (cur_wce != 0); 23213 23214 if (un->un_f_write_cache_enabled && wce == 0) { 23215 /* 23216 * Disable the write cache. Don't clear 23217 * un_f_write_cache_enabled until after 23218 * the mode select and flush are complete. 23219 */ 23220 sync_supported = un->un_f_sync_cache_supported; 23221 23222 /* 23223 * If cache flush is suppressed, we assume that the 23224 * controller firmware will take care of managing the 23225 * write cache for us: no need to explicitly 23226 * disable it. 23227 */ 23228 if (!un->un_f_suppress_cache_flush) { 23229 mutex_exit(SD_MUTEX(un)); 23230 if ((err = sd_cache_control(ssc, 23231 SD_CACHE_NOCHANGE, 23232 SD_CACHE_DISABLE)) == 0 && 23233 sync_supported) { 23234 err = sd_send_scsi_SYNCHRONIZE_CACHE(un, 23235 NULL); 23236 } 23237 } else { 23238 mutex_exit(SD_MUTEX(un)); 23239 } 23240 23241 mutex_enter(SD_MUTEX(un)); 23242 if (err == 0) { 23243 un->un_f_write_cache_enabled = 0; 23244 } 23245 23246 } else if (!un->un_f_write_cache_enabled && wce != 0) { 23247 /* 23248 * Set un_f_write_cache_enabled first, so there is 23249 * no window where the cache is enabled, but the 23250 * bit says it isn't. 23251 */ 23252 un->un_f_write_cache_enabled = 1; 23253 23254 /* 23255 * If cache flush is suppressed, we assume that the 23256 * controller firmware will take care of managing the 23257 * write cache for us: no need to explicitly 23258 * enable it. 23259 */ 23260 if (!un->un_f_suppress_cache_flush) { 23261 mutex_exit(SD_MUTEX(un)); 23262 err = sd_cache_control(ssc, SD_CACHE_NOCHANGE, 23263 SD_CACHE_ENABLE); 23264 } else { 23265 mutex_exit(SD_MUTEX(un)); 23266 } 23267 23268 mutex_enter(SD_MUTEX(un)); 23269 23270 if (err) { 23271 un->un_f_write_cache_enabled = 0; 23272 } 23273 } 23274 23275 un->un_f_wcc_inprog = 0; 23276 cv_broadcast(&un->un_wcc_cv); 23277 mutex_exit(SD_MUTEX(un)); 23278 break; 23279 } 23280 23281 default: 23282 err = ENOTTY; 23283 break; 23284 } 23285 mutex_enter(SD_MUTEX(un)); 23286 un->un_ncmds_in_driver--; 23287 ASSERT(un->un_ncmds_in_driver >= 0); 23288 mutex_exit(SD_MUTEX(un)); 23289 23290 23291 done_without_assess: 23292 sd_ssc_fini(ssc); 23293 23294 SD_TRACE(SD_LOG_IOCTL, un, "sdioctl: exit: %d\n", err); 23295 return (err); 23296 23297 done_with_assess: 23298 mutex_enter(SD_MUTEX(un)); 23299 un->un_ncmds_in_driver--; 23300 ASSERT(un->un_ncmds_in_driver >= 0); 23301 mutex_exit(SD_MUTEX(un)); 23302 23303 done_quick_assess: 23304 if (err != 0) 23305 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 23306 /* Uninitialize sd_ssc_t pointer */ 23307 sd_ssc_fini(ssc); 23308 23309 SD_TRACE(SD_LOG_IOCTL, un, "sdioctl: exit: %d\n", err); 23310 return (err); 23311 } 23312 23313 23314 /* 23315 * Function: sd_dkio_ctrl_info 23316 * 23317 * Description: This routine is the driver entry point for handling controller 23318 * information ioctl requests (DKIOCINFO). 23319 * 23320 * Arguments: dev - the device number 23321 * arg - pointer to user provided dk_cinfo structure 23322 * specifying the controller type and attributes. 23323 * flag - this argument is a pass through to ddi_copyxxx() 23324 * directly from the mode argument of ioctl(). 23325 * 23326 * Return Code: 0 23327 * EFAULT 23328 * ENXIO 23329 */ 23330 23331 static int 23332 sd_dkio_ctrl_info(dev_t dev, caddr_t arg, int flag) 23333 { 23334 struct sd_lun *un = NULL; 23335 struct dk_cinfo *info; 23336 dev_info_t *pdip; 23337 int lun, tgt; 23338 23339 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL) { 23340 return (ENXIO); 23341 } 23342 23343 info = (struct dk_cinfo *) 23344 kmem_zalloc(sizeof (struct dk_cinfo), KM_SLEEP); 23345 23346 switch (un->un_ctype) { 23347 case CTYPE_CDROM: 23348 info->dki_ctype = DKC_CDROM; 23349 break; 23350 default: 23351 info->dki_ctype = DKC_SCSI_CCS; 23352 break; 23353 } 23354 pdip = ddi_get_parent(SD_DEVINFO(un)); 23355 info->dki_cnum = ddi_get_instance(pdip); 23356 if (strlen(ddi_get_name(pdip)) < DK_DEVLEN) { 23357 (void) strcpy(info->dki_cname, ddi_get_name(pdip)); 23358 } else { 23359 (void) strncpy(info->dki_cname, ddi_node_name(pdip), 23360 DK_DEVLEN - 1); 23361 } 23362 23363 lun = ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un), 23364 DDI_PROP_DONTPASS, SCSI_ADDR_PROP_LUN, 0); 23365 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, SD_DEVINFO(un), 23366 DDI_PROP_DONTPASS, SCSI_ADDR_PROP_TARGET, 0); 23367 23368 /* Unit Information */ 23369 info->dki_unit = ddi_get_instance(SD_DEVINFO(un)); 23370 info->dki_slave = ((tgt << 3) | lun); 23371 (void) strncpy(info->dki_dname, ddi_driver_name(SD_DEVINFO(un)), 23372 DK_DEVLEN - 1); 23373 info->dki_flags = DKI_FMTVOL; 23374 info->dki_partition = SDPART(dev); 23375 23376 /* Max Transfer size of this device in blocks */ 23377 info->dki_maxtransfer = un->un_max_xfer_size / un->un_sys_blocksize; 23378 info->dki_addr = 0; 23379 info->dki_space = 0; 23380 info->dki_prio = 0; 23381 info->dki_vec = 0; 23382 23383 if (ddi_copyout(info, arg, sizeof (struct dk_cinfo), flag) != 0) { 23384 kmem_free(info, sizeof (struct dk_cinfo)); 23385 return (EFAULT); 23386 } else { 23387 kmem_free(info, sizeof (struct dk_cinfo)); 23388 return (0); 23389 } 23390 } 23391 23392 /* 23393 * Function: sd_get_media_info_com 23394 * 23395 * Description: This routine returns the information required to populate 23396 * the fields for the dk_minfo/dk_minfo_ext structures. 23397 * 23398 * Arguments: dev - the device number 23399 * dki_media_type - media_type 23400 * dki_lbsize - logical block size 23401 * dki_capacity - capacity in blocks 23402 * dki_pbsize - physical block size (if requested) 23403 * 23404 * Return Code: 0 23405 * EACCESS 23406 * EFAULT 23407 * ENXIO 23408 * EIO 23409 */ 23410 static int 23411 sd_get_media_info_com(dev_t dev, uint_t *dki_media_type, uint_t *dki_lbsize, 23412 diskaddr_t *dki_capacity, uint_t *dki_pbsize) 23413 { 23414 struct sd_lun *un = NULL; 23415 struct uscsi_cmd com; 23416 struct scsi_inquiry *sinq; 23417 u_longlong_t media_capacity; 23418 uint64_t capacity; 23419 uint_t lbasize; 23420 uint_t pbsize; 23421 uchar_t *out_data; 23422 uchar_t *rqbuf; 23423 int rval = 0; 23424 int rtn; 23425 sd_ssc_t *ssc; 23426 23427 if ((un = ddi_get_soft_state(sd_state, SDUNIT(dev))) == NULL || 23428 (un->un_state == SD_STATE_OFFLINE)) { 23429 return (ENXIO); 23430 } 23431 23432 SD_TRACE(SD_LOG_IOCTL_DKIO, un, "sd_get_media_info_com: entry\n"); 23433 23434 out_data = kmem_zalloc(SD_PROFILE_HEADER_LEN, KM_SLEEP); 23435 rqbuf = kmem_zalloc(SENSE_LENGTH, KM_SLEEP); 23436 ssc = sd_ssc_init(un); 23437 23438 /* Issue a TUR to determine if the drive is ready with media present */ 23439 rval = sd_send_scsi_TEST_UNIT_READY(ssc, SD_CHECK_FOR_MEDIA); 23440 if (rval == ENXIO) { 23441 goto done; 23442 } else if (rval != 0) { 23443 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 23444 } 23445 23446 /* Now get configuration data */ 23447 if (ISCD(un)) { 23448 *dki_media_type = DK_CDROM; 23449 23450 /* Allow SCMD_GET_CONFIGURATION to MMC devices only */ 23451 if (un->un_f_mmc_cap == TRUE) { 23452 rtn = sd_send_scsi_GET_CONFIGURATION(ssc, &com, rqbuf, 23453 SENSE_LENGTH, out_data, SD_PROFILE_HEADER_LEN, 23454 SD_PATH_STANDARD); 23455 23456 if (rtn) { 23457 /* 23458 * We ignore all failures for CD and need to 23459 * put the assessment before processing code 23460 * to avoid missing assessment for FMA. 23461 */ 23462 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 23463 /* 23464 * Failed for other than an illegal request 23465 * or command not supported 23466 */ 23467 if ((com.uscsi_status == STATUS_CHECK) && 23468 (com.uscsi_rqstatus == STATUS_GOOD)) { 23469 if ((rqbuf[2] != KEY_ILLEGAL_REQUEST) || 23470 (rqbuf[12] != 0x20)) { 23471 rval = EIO; 23472 goto no_assessment; 23473 } 23474 } 23475 } else { 23476 /* 23477 * The GET CONFIGURATION command succeeded 23478 * so set the media type according to the 23479 * returned data 23480 */ 23481 *dki_media_type = out_data[6]; 23482 *dki_media_type <<= 8; 23483 *dki_media_type |= out_data[7]; 23484 } 23485 } 23486 } else { 23487 /* 23488 * The profile list is not available, so we attempt to identify 23489 * the media type based on the inquiry data 23490 */ 23491 sinq = un->un_sd->sd_inq; 23492 if ((sinq->inq_dtype == DTYPE_DIRECT) || 23493 (sinq->inq_dtype == DTYPE_OPTICAL)) { 23494 /* This is a direct access device or optical disk */ 23495 *dki_media_type = DK_FIXED_DISK; 23496 23497 if ((bcmp(sinq->inq_vid, "IOMEGA", 6) == 0) || 23498 (bcmp(sinq->inq_vid, "iomega", 6) == 0)) { 23499 if ((bcmp(sinq->inq_pid, "ZIP", 3) == 0)) { 23500 *dki_media_type = DK_ZIP; 23501 } else if ( 23502 (bcmp(sinq->inq_pid, "jaz", 3) == 0)) { 23503 *dki_media_type = DK_JAZ; 23504 } 23505 } 23506 } else { 23507 /* 23508 * Not a CD, direct access or optical disk so return 23509 * unknown media 23510 */ 23511 *dki_media_type = DK_UNKNOWN; 23512 } 23513 } 23514 23515 /* 23516 * Now read the capacity so we can provide the lbasize, 23517 * pbsize and capacity. 23518 */ 23519 if (dki_pbsize && un->un_f_descr_format_supported) { 23520 rval = sd_send_scsi_READ_CAPACITY_16(ssc, &capacity, &lbasize, 23521 &pbsize, SD_PATH_DIRECT); 23522 23523 /* 23524 * Override the physical blocksize if the instance already 23525 * has a larger value. 23526 */ 23527 pbsize = MAX(pbsize, un->un_phy_blocksize); 23528 } 23529 23530 if (dki_pbsize == NULL || rval != 0 || 23531 !un->un_f_descr_format_supported) { 23532 rval = sd_send_scsi_READ_CAPACITY(ssc, &capacity, &lbasize, 23533 SD_PATH_DIRECT); 23534 23535 switch (rval) { 23536 case 0: 23537 if (un->un_f_enable_rmw && 23538 un->un_phy_blocksize != 0) { 23539 pbsize = un->un_phy_blocksize; 23540 } else { 23541 pbsize = lbasize; 23542 } 23543 media_capacity = capacity; 23544 23545 /* 23546 * sd_send_scsi_READ_CAPACITY() reports capacity in 23547 * un->un_sys_blocksize chunks. So we need to convert 23548 * it into cap.lbsize chunks. 23549 */ 23550 if (un->un_f_has_removable_media) { 23551 media_capacity *= un->un_sys_blocksize; 23552 media_capacity /= lbasize; 23553 } 23554 break; 23555 case EACCES: 23556 rval = EACCES; 23557 goto done; 23558 default: 23559 rval = EIO; 23560 goto done; 23561 } 23562 } else { 23563 if (un->un_f_enable_rmw && 23564 !ISP2(pbsize % DEV_BSIZE)) { 23565 pbsize = SSD_SECSIZE; 23566 } else if (!ISP2(lbasize % DEV_BSIZE) || 23567 !ISP2(pbsize % DEV_BSIZE)) { 23568 pbsize = lbasize = DEV_BSIZE; 23569 } 23570 media_capacity = capacity; 23571 } 23572 23573 /* 23574 * If lun is expanded dynamically, update the un structure. 23575 */ 23576 mutex_enter(SD_MUTEX(un)); 23577 if ((un->un_f_blockcount_is_valid == TRUE) && 23578 (un->un_f_tgt_blocksize_is_valid == TRUE) && 23579 (capacity > un->un_blockcount)) { 23580 un->un_f_expnevent = B_FALSE; 23581 sd_update_block_info(un, lbasize, capacity); 23582 } 23583 mutex_exit(SD_MUTEX(un)); 23584 23585 *dki_lbsize = lbasize; 23586 *dki_capacity = media_capacity; 23587 if (dki_pbsize) 23588 *dki_pbsize = pbsize; 23589 23590 done: 23591 if (rval != 0) { 23592 if (rval == EIO) 23593 sd_ssc_assessment(ssc, SD_FMT_STATUS_CHECK); 23594 else 23595 sd_ssc_assessment(ssc, SD_FMT_IGNORE); 23596 } 23597 no_assessment: 23598 sd_ssc_fini(ssc); 23599 kmem_free(out_data, SD_PROFILE_HEADER_LEN); 23600 kmem_free(rqbuf, SENSE_LENGTH); 23601 return (rval); 23602 } 23603 23604 /* 23605 * Function: sd_get_media_info 23606 * 23607 * Description: This routine is the driver entry point for handling ioctl 23608 * requests for the media type or command set profile used by the 23609 * drive to operate on the media (DKIOCGMEDIAINFO). 23610 * 23611 * Arguments: dev - the device number 23612 * arg - pointer to user provided dk_minfo structure 23613 * specifying the media type, logical block size and 23614 * drive capacity. 23615 * flag - this argument is a pass through to ddi_copyxxx() 23616 * directly from the mode argument of ioctl(). 23617 * 23618 * Return Code: retur